configure

#!/bin/bash 
#
#   configure -- Build configuration script for Embedthis Products
#
#   Copyright (c) Embedthis Software LLC, 2003-2011. All Rights Reserved.
#
#   This script creates the buildConfig.h, buildConfig.make and buildConfig.sh 
#   configuration files. buildConfig.h is included in every C/C++ source file, 
#   buildConfig.make is included by all makefiles and buildConfig.sh is included 
#   by the bld program and some other scripts.
#
#   The initial default settings are derrived from configuration files in the build directory. 
#
###############################################################################

unset CDPATH
# export CYGWIN=nodosfilewarning

#
#   Prefix for configuration files generated by configure
#
CONFIG_ARGS=.buildConfig.args
CONFIG_SH=build/bin/buildConfig.sh
CONFIG_MAKE=./buildConfig.make

if [ -d src/include ] ; then
	CONFIG_H=src/include/buildConfig.h
else
	CONFIG_H=buildConfig.h
fi

#
#   This programs version
#
CONFIGURE_VERSION=4.2.1

#
#   Default settings
#
BLD_DEFAULTS=standard

#
#   O/S has cygpath (Windows)
#
HAS_CYGPATH=0

#
#   Product name to configure
#
PRODUCT=

#
#   Flags prefixes
#
FLAGS="C D I LD J CPP"

#
#   Set preferred make
#
if which gnumake >/dev/null 2>&1 ; then
    MAKE=`which gnumake`
elif which gmake >/dev/null 2>&1 ; then
    MAKE=`which gmake`
else
    MAKE=make
fi

###############################################################################
#
#   Check the software installation and O/S
#

checkSetup() {

    #
    #   Windows path conversion utility
    #
    type -p cygpath >/dev/null 2>&1
    if [ $? = 0 ] ; then
        HAS_CYGPATH=1
    else
        HAS_CYGPATH=0
    fi

    #
    #   Ensure we can write to key directories
    #
    for d in . build build/bin bin obj lib
    do
        if [ ! -d $d ] ; then
            echo "Missing required directory \"$d\"" 1>&2
            echo "Create this directory and retry" 1>&2
            exit 255
        fi
        echo 2>/dev/null >$d/.test 
        if [ $? != 0 ] ; then
            echo "Can't write to $d" 1>&2
            echo "You do not have write permission for the $d directory." 1>&2
            echo "Log in as root or modify the permissions of this directory" 1>&2
            echo "and all its files." 1>&2
            exit 255
        fi
        rm -f $d/.test
    done

    if [ ! -f ./configure -o ! -d build ] ; then
        echo "configure: You must be in the top source directory." 1>&2
        exit 255
    fi

    #
    #   Convert paths to be absolute with a drive spec on windows
    #
    BLD_TOP=`canonPath .`
    BLD_TOOLS_DIR=${BLD_TOP}/build/bin

    #
    #   Sleuth the product. By convention products put a configure.PRODUCT file under the build directory.
    #
    PRODUCT_LIST=`echo build/configure.* | sed 's/[^. ]*\.//g'`
    if [ "${PRODUCT_LIST%\*}" != "${PRODUCT_LIST}" ] ; then
        echo "Can't find required file: build/configure.*" 1>&2
        echo "Install this file and retry." 1>&2
        exit 255
    fi

    if [ -d ../packages ] ; then
        rm -f extensions
        ln -s ../packages extensions
    fi
}


#
#   Link a file. If that fails, copy.
#
linkFile()
{
    source=$1
    dir=`dirname $2`
    base=`basename $2`

    rm -f $2
    if [ "$base" != "$2" ] ; then
        source=`echo $source | sed -e "s^${dir}/^^"`
    fi
    ln -s $source $2 2>/dev/null
    if [ $? != 0 ] ; then
        cp $1 $2
    fi
}


setSystemConfiguration() {

    [ "$BLD_HOST_SYSTEM" = "" ] && BLD_HOST_SYSTEM=`bash build/bin/config.guess`
    [ "$BLD_BUILD_SYSTEM" = "" ] && BLD_BUILD_SYSTEM=`bash build/bin/config.guess`

    parseSystemConfiguration HOST 
    parseSystemConfiguration BUILD 

    if [ "${BLD_HOST_SYSTEM}" != "${BLD_BUILD_SYSTEM}" ] ; then
        BLD_CROSS=1
        BLD_HOST_DIST=Unknown
        BLD_HOST_DIST_VER=Unknown
    else 
        BLD_CROSS=0
    fi
}


#
#   Parse the system configuration. This is called for the host and build configurations.
#
parseSystemConfiguration() {

    local cpu dist os rel system version unused value prefix

    #
    #   Parse the host system configuration
    #
    kind=$1
    parseSystem BLD_${kind}_SYSTEM $system BLD_${kind}_CPU unused BLD_${kind}_OS

    eval os=\$BLD_${kind}_OS
    case $os in
    WIN|WINCE)
        eval BLD_${kind}_UNIX=0
        eval BLD_${kind}_WIN=1
        ;;
    CYGWIN)
        eval BLD_${kind}_UNIX=1
        eval BLD_${kind}_WIN=0
        ;;
    FREEBSD)
        eval BLD_${kind}_UNIX=1
        eval BLD_${kind}_WIN=0
        ;;
    LINUX)
        eval BLD_${kind}_UNIX=1
        eval BLD_${kind}_WIN=0
        ;;
    SOLARIS*)
        eval BLD_${kind}_UNIX=1
        eval ${os}=SOLARIS
        eval BLD_${kind}_WIN=0
        ;;
    MACOSX)
        eval BLD_${kind}_UNIX=1
        eval BLD_${kind}_WIN=0
        ;;
    VXWORKS)
        eval BLD_${kind}_UNIX=0
        eval BLD_${kind}_WIN=0
        ;;
    *)
        eval BLD_${kind}_UNIX=0
        eval BLD_${kind}_WIN=0
        ;;
    esac

    #
    #   Determine the CPU family
    #
    eval cpu=\$BLD_${kind}_CPU
    case ${cpu} in
    amd64)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_IX64
        prefix=amd64
        ;;
    arm*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_ARM
        prefix=arm
        ;;
    i?86*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_IX86
        prefix="i?86"
        ;;
    m68k**)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_68K
        prefix=m68k
        ;;
    mips*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_MIPS
        prefix=mips
        ;;
    powerpc*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_PPC
        eval BLD_${kind}_CPU=ppc
        cpu=ppc
        prefix=ppc
        ;;
    ppc*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_PPC
        prefix=ppc
        ;;
    sparc*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_SPARC
        prefix=sparc
        ;;
    strongarm*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_ARM
        prefix=strongarm
        ;;
    x86_64*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_IX64
        prefix=x86_64
        ;;
    x86*|i?86*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_IX86
        ;;
    xscale*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_XSCALE
        prefix=xscale
        ;;
    sim)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_SIMNT
        prefix=sim
        ;;
    simnt)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_SIMNT
        prefix=simnt
        ;;
    simsparc)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_SIMSPARC
        prefix=simsparc
        ;;
    sh*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_SH4
        prefix=sh
        ;;
    universal)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_UNIVERSAL
        prefix=universal
        ;;
    xscale*)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_ARM
        prefix="xscale"
        ;;
    *)
        eval BLD_${kind}_CPU_ARCH=MPR_CPU_UNKNOWN
        echo "configure: CPU architecture unknown. Porting $BLD_PRODUCT is required. " 1>&2
        exit 2
        ;;
    esac

    eval value=\$BLD_${kind}_CPU
    eval BLD_${kind}_CPU_MODEL=`echo $value | sed s/$prefix//`

    #
    #   Determine the O/S distribution. This is quite a bit of spelunking.
    #
    #   /etc/debian_version
    #   /etc/redhat-release
    #   /etc/fedora-release
    #   /etc/gentoo-release
    #   /etc/SuSE-release
    #   /etc/slackware-release, /etc/slackware-version
    #   /etc/debian-release, /etc/debian-version
    #   /etc/release # Solars
    #   /etc/yellowdog-release
    #   /etc/mandrake-release

    dist="unspecified"
    version="unspecified"

    if [ $os = WIN -o $os = CYGWIN ] ; then

        # Microsoft Windows XP [Version 5.1.2600]
        # Microsoft Windows [Version 6.0.6000]

        rel=`cmd /c ver | tail -1`
        version=`echo $rel | sed 's/.*Version //;s/]//' | awk '{ print $1 }'`
        version=${version%%.*}
        #  if [ "$version" = 6 ] ; then
        #      dist=vista
        #  elif [ "$version" = 5 ] ; then
        #      dist=xp
        #  fi
        dist=MS

    elif [ $os = LINUX ] ; then
        if [ -f /etc/redhat-release ] ; then 

            case `cat /etc/redhat-release` in
            Fedora*)
                # Fedora Core release 4 (Stentz)
                # Fedora Core release 6 (Zod)
                # Fedora Core release 5.9 (FC6 Test3)
                version=`cat /etc/redhat-release | awk '{ print $4 }'` 
                dist="fedora"
                ;;
            "Red Hat Linux"*)
                # Red Hat Linux release 9 (Shrike)
                version=`cat /etc/redhat-release | awk '{ print $5 }'` 
                dist="rhl"
                ;;
            "Red Hat Enterprise"*)
                # Red Hat Enterprise Linux ES release 3 (Taroon Update 7)
                # Red Hat Enterprise Linux ES release 4 (Nahant Update 4)
                version=`cat /etc/redhat-release | awk '{ print $7 }'` 
                dist="rhel"
                ;;
            esac
        fi
        if [ -f /etc/SuSE-release ] ; then
            dist=suse
            version=`cat /etc/SuSE-release | head -1 | awk '{ print $2 }'`
        fi
        if [ -f /etc/gentoo-release ] ; then
            dist=suse
            version=`cat /etc/gentoo-release | head -1 | awk '{ print $5 }'`
        fi
        if [ -f /etc/debian_version ] ; then
            if [ -f /etc/issue ] ; then
                cat /etc/issue | grep -i ubuntu >/dev/null 2>&1
                if [ $? = 0 ] ; then
                    dist=ubuntu
                else
                    dist=debian
                fi
            fi
            if [ -f /etc/lsb-release ] ; then
                version=`cat /etc/lsb-release | grep RELEASE | sed 's/.*=//'`
            elif [ -f /etc/issue ] ; then
                version=`cat /etc/issue | awk '{ print $2 }'`
            fi
        fi

    elif [ $os = MACOSX ] ; then
        version=`sw_vers | grep ProductVersion | awk '{ print $2 }'`
        dist="Apple"

    elif [ $os = VXWORKS ] ; then
        dist="vxworks"

    elif [ $os = WINCE ] ; then
        dist="wince"
    fi

    eval BLD_${kind}_DIST=\"${dist}\"
    eval BLD_${kind}_DIST_VER=\"`echo ${version}`\"
}


#
#   Parse any user defined environment variables
#
parseEnvVars() {

    [ $quiet = 0 ] && echo -e "  # Parse environment variables ..."

    #
    #   If the user is overriding CC but doesn't set CXX, set it to the same
    #
    if [ "$CC" != "" -a "$CXX" = "" ] ; then
        CXX="$CC"
    fi
    if [ "$LD" != "" -a "$LDXX" = "" ] ; then
        LDXX="$CC"
    fi
    if [ -f "${BLD_TOP}/.embedthis" ] ; then
        BLD_EMBEDTHIS=1
    else
        BLD_EMBEDTHIS=0
    fi

    #
    #   Set default tool value if corresponding environment variable is defined
    #
    for t in ANT AR BREW CC DOXYGEN CXX JAVAC JDK JAR LD LDXX MT MUNCH NM RANLIB RC STRIP
    do
        eval value="\$${t}"
        if [ "$value" != "" ] ; then
            if [ $BLD_CROSS = 1 ] ; then
                eval BLD_HOST_${t}=\"$value\"
                eval CFG_HOST_${t}=\"$value\"
            else
                eval BLD_BUILD_${t}=\"$value\"
                eval CFG_BUILD_${t}=\"$value\"
            fi
        fi
    done

    for t in AR CC CXX LD LDXX MT NM RANLIB RC STRIP
    do
        eval value="\$BUILD_${t}"
        if [ "$value" != "" ] ; then
            eval BLD_BUILD_${t}=\"$value\"
            eval CFG_BUILD_${t}=\"$value\"
        fi
    done

    for t in $FLAGS
    do
        eval value="\$BUILD_${t}FLAGS"
        if [ "$value" != "" ] ; then
            eval BLD_BUILD_${t}FLAGS=\"$value\"
        fi
        eval value="\$${t}FLAGS"
        if [ "$value" != "" ] ; then
            eval BLD_HOST_${t}FLAGS=\"$value\"
            if [ "${BLD_HOST_SYSTEM}" = "${BLD_BUILD_SYSTEM}" ] ; then
                eval BLD_BUILD_${t}FLAGS=\"$value\"
            fi
        fi
    done

    if [ "$BLD_BUILD_CPPFLAGS" != "" ] ; then
        BLD_BUILD_DFLAGS="$BLD_BUILD_CPPFLAGS $BLD_BUILD_DFLAGS"
        BLD_BUILD_CPPFLAGS=
    fi
    if [ "$BLD_HOST_CPPFLAGS" != "" ] ; then
        BLD_HOST_DFLAGS="$BLD_HOST_CPPFLAGS $BLD_HOST_DFLAGS"
        BLD_HOST_CPPFLAGS=
    fi
}


#
#   Usage: parseSystem in-system out-cpu out-vendor out-os
#
parseSystem() {
    local system cpu vendor kernel os lowOS

    eval system=\$${1}
    cpu=${system%%-*}
    vendor=${system##${cpu}-}
    vendor=${vendor%%-*}
    kernel=${system##${cpu}-${vendor}-}
    os=${kernel##*-}
    kernel=${kernel%%-*}

    if [ "$kernel" != "" ] ; then
        os=$kernel
    fi

    os=`upper $os`

    case "${os}" in
    CYGWIN*|WIN)
        os=CYGWIN
        if [ "$CL_FOUND" = 1 ] ; then
            os=WIN
        elif [ ! -x /bin/cc.exe -o "$BLD_CC_CYGWIN" != 1 ] ; then
            BLD_BUILD_OS=WIN
            [ $quiet = 0 ] && echo -e "  # Search for MS compiler ..."
            . build/search.config
            search=`convertSearchPath "$BUILD_SEARCH_PATH"`:$PATH
            if [ "`probe --partial cl --search "$search" cl`" != "" ] ; then
                os=WIN
                CL_FOUND=1
            fi
        fi
        ;;
    VXWORKS*)
        os=VXWORKS
        ;;
    DARWIN*)
        os=MACOSX
        ;;
    FREEBSD*)
        os=FREEBSD
        ;;
    SOLARIS*)
        os=SOLARIS
        ;;
    WINCE)
        os=WINCE
        ;;
    esac

    lowOS=`lower $os`
    eval ${2}=$cpu
    eval ${3}=$vendor
    eval ${4}=$os
    eval ${1}="${cpu}-${vendor}-${lowOS}"

    [ "$verbose" -gt 2 ] && echo System set to "${cpu}-${vendor}-${lowOS}" >&2
}


#
#   Convert a path to a canonical form: absolute (Windows: with drive spec)
#
canonPath() {
    local path

    path="$1"
    if [ "$path" = "" ] ; then
        echo "$path"
        return
    fi
    if [ $HAS_CYGPATH = 1 ] ; then
        #
        #   These conversions will ensure we get a drive spec and that we have
        #    forward slashes instead of back slashes
        #
        d=`cygpath -am "${path}"`
        d=`cygpath -u "${d}"`
        cygpath -am "${d}"
        return
    fi

    if [ "${path##..}" != "${path}" ] ; then
        cd .. ; echo `pwd`${path##..} ; cd - >/dev/null 2>&1
    elif [ "${path##.}" != "${path}" ] ; then
        echo `pwd`${path##.}
    elif [ "${path##/}" != "${path}" ] ; then
        # Absolute
        echo "$path"
    else
        # Relative
        echo `pwd`/${path#/}
    fi
}


#
#   Convert a path to be relative to $BLD_TOP. Used because gnu make on windows can't handle drive specs in dependencies.
#
relativePath() {

    local base home dir i d c oldd parents
    local count ccount seg commonDir commonLevels

    home="$PWD"

    dir="$1"

    if [ "BLD_HOST_OS" = "WIN" -o "$BLD_HOST_OS" = "WINCE" ] ; then
        dir=`canonPath "$dir" | tr '[A-Z]' '[a-z]'`
        cwd=`canonPath "$PWD" | tr '[A-Z]' '[a-z]'`
    else
        dir=`canonPath "$dir"`
        cwd=`canonPath "$PWD"`
    fi

    if [ "$dir" = "$cwd" ] ; then
        echo "\${BLD_TOP}"
        return
    fi
    if [ "$dir" != "${dir/BLD_TOP/}" ] ; then
        echo "$dir"
        return
    fi

    #
    #   Find longest common dir portion
    #
    declare -a dseg
    d="$dir"
    i=0
    while [ "$d" != "${d##*/}" ] ; do
        seg=${d%%/*}                    # Extract first path segment
        dseg[$i]="${seg}"
        d=${d#*/}                       # Strip first path segment
        i=$((i + 1))
    done
    dseg[$i]="${d}"
    
    declare -a cseg
    c="$cwd"
    i=0
    while [ "$c" != "${c##*/}" ] ; do
        seg=${c%%/*}                    # Extract first path segment
        cseg[$i]="${seg}"
        c=${c#*/}                       # Strip first path segment
        i=$((i + 1))
    done
    cseg[$i]="${c}"
    
    count=${#dseg[*]}
    ccount=${#cseg[*]}

    if [ $count -gt $ccount ] ; then
        count=$ccount
    fi

    if [ "${BLD_HOST_OS}" = "WIN" -o "$BLD_HOST_OS" = "WINCE" ] ; then
        if [ "${dseg[0]}" != "${cseg[0]}" ] ; then
            echo "Path ${dir} on different drive" 1>&2
            echo "to the current drive" 1>&2
            echo "This configuration is not supported. Aborting." 1>&2
            exit 255
        fi
    fi

    #
    #   Find common parent dirs
    #
    commonDir=""
    i=0
    while [ $i -lt $count ] ; do
        [ "${dseg[$i]}" != "${cseg[$i]}" ] && break
        commonDir="$commonDir/${dseg[$i]}"
        i=$((i + 1))
    done
    commonDir="${commonDir#/*}"
    commonLevels=$i

    #
    #   Find how many levels up to common parent for cwd
    #
    parents=""
    i=$commonLevels
    while [ $i -lt ${#cseg[*]} ] ; do
        parents="../$parents"
        i=$((i + 1))
    done

    base=`echo $dir | sed "s!^$commonDir!!"`
    echo "\${BLD_TOP}/${parents}$base" | sed 's!\/\/!\/!g'
}


#
#   Remove an old prefix from a path and prepend a new prefix
#
#   remapDir dir oldPath newPath
#
remapDir() {
    local dir oldPrefix newPrefix

    dir="$1"
    oldPrefix="$2"
    newPrefix="$3"

    if [ $HAS_CYGPATH = 1 ] ; then
        dir=`cygpath -m "$dir"`
        oldPrefix=`cygpath -m "$oldPrefix"`
        newPrefix=`cygpath -m "$newPrefix"`
    fi
    if [ "${dir##$oldPrefix}" != "$dir" ] ; then
        echo "${newPrefix}${dir##$oldPrefix}"
    else
        echo "${dir}"
    fi
}


#
#   Convert the search path into a normal PATH style with ":" separators
#   On windows, this requires cygwin paths in searchPath.
#
convertSearchPath() 
{
    local x

    if [ "$1" != "" ] ; then
        [ "$verbose" -gt 2 ] && echo "ConvertPath expanding $1" 1>&2
        echo $1 | sed "s/[  ]'/=/g" | tr "=" "\n" | sed "s/'//g" |
        sed "s/[() ]/?/g" | grep -v '^$' | while read x
        do
            [ "$x" = "" ] && continue
            if [ "$BLD_BUILD_OS" = WIN ] ; then
                eval ls -d1 "$x" 2>/dev/null | sort | while read f
                do
                    cygpath "$f"
                done
            else
                eval ls -d1 "$x" 2>/dev/null | sort
            fi
        done | grep -v '^$' | tr '\n' : | sed 's/:$//'
    fi
}


findComponents() {
    local with build host mandatory name path upperName os

    [ $quiet = 0 ] && echo -e "  # Finding components ..."

    for kind in BUILD HOST ; do
        [ $quiet = 0 ] && echo -e "  #\n  # Search for `lower $kind` components"

        eval SEARCH_PATH=\$${kind}_SEARCH_PATH
        if [ "$verbose" -gt 0 ] ; then
            echo -n -e "\nSearch for $kind components using $kind search path:\n    "
            echo $SEARCH_PATH | sed -e 's/:/
    /g'
        fi

        for name in $BLD_COMPONENTS ; do
            upperName=`upper ${name}`

            eval with=\$CFG_${kind}_${upperName}_WITH
            [ "$with" != 1 ] && continue
 
            if [ ! -f "${BLD_TOP}/build/components/${name}" ] ; then
                echo "Missing component file: build/components/$name"
                continue
            fi

            eval BLD_UNIX_LIKE=\$BLD_${kind}_UNIX              
            eval BLD_WIN_LIKE=\$BLD_${kind}_WIN              

            [ "$verbose" -gt 0 ] && echo -e "\nSearch for component \"${name}\" using script \"build/components/${name}\""

            . "${BLD_TOP}/build/components/${name}"

            eval path="\$CFG_${kind}_${upperName}"
            eval mandatory=\$CFG_${kind}_${upperName}_MANDATORY

            [ "$BLD_DISABLE_ALL" = 1 -a $mandatory != 1 ] && continue

            if [ "$verbose" = 0 ] ; then
                [ $quiet = 0 ] && printf "  # Scanning for %-12s" "${name}:"
            fi

            #
            #   Invoke the component definition function
            #
            unset MSG
            eval os=\$BLD_${kind}_OS
            OS=$os NAME=$name KIND=$kind defineComponent "$path"

#            eval path="\$CFG_${kind}_${upperName}"
#            if [ "$mandatory" = 1 -a "$path" = "" ] ; then
#                eval realName=\$BLD_${kind}_${upperName}
#                [ "$realName" != "" ] && name=$realName
#                echo -e "\nconfigure: Can't find mandatory component: $name"  1>&2
#                exit 255
#            fi
#
#            if [ "$path" != "" ] ; then
#                eval ${kind}_COMPONENTS=\"\$${kind}_COMPONENTS ${name}\"
#                [ $quiet = 0 -a $verbose = 0 ] && echo "$path"
#            else
#                if [ "$MSG" != "" ] ; then
#                    [ $quiet = 0 ] && echo $MSG
#                else
#                    [ $quiet = 0 ] && echo "optional component not included"
#                fi
#            fi
        done
        [ $BLD_CROSS = 0 ] && break
    done
    [ "$verbose" -gt 0 ] && echo
}


warnComponent() {
    local kind upper actual
    kind=$KIND

    name=$1
    actual=$2
    if [ "$actual" = "" ] ; then
        actual="$name"
    fi
    upper=`upper ${name}`
    eval mandatory="\$CFG_${kind}_${upper}_MANDATORY"

    if [ "$mandatory" = 1 ] ; then
        echo -e "\n\nCan't find required component: $name\n" >&2
        echo -e "$*\n" >&2
        exit 255
    fi
    if [ "$verbose" != 0 ] ; then
        echo -e "    optional component $name not included"
    elif [ $quiet = 0 ] ; then
        echo "optional component not included"
    fi
}


#
#   Return true if not builtin
#
isExternal() {
    local path dir

    dir=`canonPath "$PWD"`
    path=`canonPath "$1"`
    if [ "$path" != "." -a "$path" = "${path#$dir}" ] ; then
        return 0
    fi
    return 1
}

#
#   Configure a component. Called by build/components/*
#
configureComponent() {
    local cflags dflags dependencies kind iflags imports jflags ldflags libpaths libs name upperDep new
    local path withlibs withpaths upper builtin priorMandatory priorPath emitter disable optional extra

    kind=$KIND
    builtin=0
    libpaths=

    [ "$verbose" != 0 ] && echo -e "    configureComponent $@"

    while [ "${1#--}" != "$1" ] ; do
        case ${1#--} in
        builtin)
            builtin=1
            ;;
        cflags)
            shift ; cflags="$1"
            ;;
        dependencies)
            shift ; dependencies="$1"
            ;;
        dflags)
            shift ; dflags="$1"
            ;;
        disable)
            shift ; disable="$1"
            ;;
        emitter)
            shift ; emitter="$1"
            ;;
        iflags)
            shift ; iflags="$1"
            ;;
        imports)
            shift ; imports="$1"
            ;;
        jflags)
            shift ; jflags="$1"
            ;;
        ldflags)
            shift ; ldflags="$1"
            ;;
        libpaths)
            shift ; libpaths=`canonPath "$1"`
            ;;
        libs)
            shift ; libs="$1"
            ;;
        optional-dependencies)
            shift ; optional="$1"
            ;;
        path)
            shift ; path="$1"
            ;;
        withlibs)
            shift ; withlibs="$1"
            ;;
        withpaths)
            shift ; withpaths=`canonPath "$1"`
            ;;
        *)  
            ;;
        esac
        shift
    done

    name=$1
    if [ "$name" = "" ] ; then
        echo "configureComponent: component missing name"  1>&2
        exit 255
    fi
    if [ "$disable" != "" ] ; then
        echo "configureComponent: component missing name"  1>&2
        return 0
    fi

    if [ "$HAS_CYGPATH" = 1 ] ; then
        local p1 cpwd
        p1=`canonPath "$path"`
        cpwd=`canonPath "$PWD"`
        [ "$p1" != "${p1#$cpwd}" ] && builtin=1
    else 
        [ "$path" != "${path#$PWD}" ] && builtin=1
    fi

    [ $BLD_CROSS = 0 ] && kind=BUILD

    upper=`upper ${name}`
    eval mandatory="\$CFG_${kind}_${upper}_MANDATORY"
    eval priorPath="\$CFG_${upper}"

    if [ "$priorPath" != "" ] ; then
        path="$priorPath"
    fi

    eval unset CFG_${kind}_${upper}

    for dep in $dependencies 
    do
        upperDep=`upper ${dep}`
        if [ "`compath $dep`" = "" ] ; then
            if [ "$mandatory" = 1 ] ; then
                echo "configureComponent: Missing dependency \"${dep}\" for mandatory component: ${name}" 1>&2
                exit 255
            fi
        fi
    done

    if [ "$BLD_FEATURE_STATIC" = 1 ] ; then

        for dep in $optional $dependencies
        do
            udep=`upper ${dep}`
            eval present=\$CFG_${kind}_${udep}
            if [ "$present" != "" ] ; then
                eval extra=\$CFG_${kind}_${udep}_LIBPATHS
                [ "$extra" != "" ] && libpaths="$libpaths $extra"
                eval extra=\$CFG_${kind}_${udep}_LIBS
                [ "$extra" != "" ] && libs="$libs $extra"
            fi
        done
    else
        for dep in $optional $dependencies
        do
            udep=`upper ${dep}`
            eval present=\$CFG_${kind}_${udep}
            if [ "$present" != "" ] ; then
                eval extra=\$CFG_${kind}_${udep}_LIBPATHS
                [ "$extra" != "" ] && libpaths="$libpaths $extra"
                [ "$extra" != "" ] && withpaths="$withpaths $extra"

                eval extra=\$CFG_${kind}_${udep}_LIBS
                [ "$extra" != "" ] && libs="$libs $extra"
                [ "$extra" != "" ] && withlibs="$withlibs $extra"
            fi
        done
    fi

    #
    #   Cleanup leading spaces
    #
    libs=${libs# *}
    libpaths=${libpaths# *}
    withlibs=${withlibs# *}
    withpaths=${withpaths# *}

    #
    #   Imports must be relative because they are used as targets
    #
    new=""
    for i in $imports ; do
        new="$new `relativePath "$i"`"
    done
    imports="$new"

    #
    #   Don't make unique if static on Linux. ld does not rescan.
    #
    if [ "$BLD_FEATURE_STATIC" != 1 -o "${BLD_HOST_OS}" != "LINUX" ] ; then
        libs=`unique $libs`
        withlibs=`unique $withlibs`
    fi

    eval CFG_${kind}_${upper}=\"${path}\"
    eval CFG_${kind}_${upper}_BUILTIN=\"$builtin\"
    eval CFG_${kind}_${upper}_CFLAGS=\"$cflags\"
    eval CFG_${kind}_${upper}_DEPENDENCIES=\"$dependencies\"
    eval CFG_${kind}_${upper}_DFLAGS=\"$dflags\"
    eval CFG_${kind}_${upper}_EMITTER=$emitter
    eval CFG_${kind}_${upper}_IFLAGS=\"$iflags\"
    eval CFG_${kind}_${upper}_IMPORTS=\"'$imports'\"
    eval CFG_${kind}_${upper}_JFLAGS=\"$jflags\"
    eval CFG_${kind}_${upper}_LDFLAGS=\"$ldflags\"
    eval CFG_${kind}_${upper}_LIBPATHS=\"$libpaths\"
    eval CFG_${kind}_${upper}_LIBS=\"$libs\"
    eval CFG_${kind}_${upper}_MANDATORY=\"$mandatory\"
    eval CFG_${kind}_${upper}_OPTIONAL_DEPENDENCIES=\"$optional\"
    eval CFG_${kind}_${upper}_WITHLIBS=\"$withlibs\"
    eval CFG_${kind}_${upper}_WITHPATHS=\"$withpaths\"

    eval ${kind}_COMPONENTS=\"\$${kind}_COMPONENTS ${name}\"
    [ $quiet = 0 -a $verbose = 0 ] && echo "$path"
}


#
#   probe [--path path] [--partial file] [--emit-dir] [--search searchPath] component  
#
#   --path path         Test first if this path exists, if so, return it.
#   --partial file      Test if this partial file exists along the search path
#   --search path       Use this instead of the default search path.
#   --emit-dir          Emit the directory portion. Otherwise return the full matching path.
#
#   Can supply both dir and file options. Will search using dir first
#
probe()
{
    local name args d emitdir f partial found path search trace SAVE_IFS OLD_PATH

    trace=$verbose
    args="$@"
    emitdir=0

    while [ "${1#--}" != "$1" ] ; do
        case ${1#--} in
        emitdir|emit-dir)
            emitdir=1
            ;;
        partial)
            shift ; partial=$1
            ;;
        path)
            shift ; path=$1
            ;;
        search)
            shift ; search=$1
            ;;
        verbose)
            trace=1
            ;;
        esac
        shift
    done

    name=$1
    if [ "$name" = "" ] ; then
        echo "probe: Missing name" 1>&2
        exit 255
    fi

    [ "$trace" != 0 ] && echo -e "    probe $args" 1>&2

    if [ "$partial" = "" -a "$path" = "" ] ; then
        echo -e "\nprobe: $name did not specifiy a partial or path" >&2
        exit 255
    fi

    if [ "$path" != "" ] ; then
        if [ -f "$path" -o -x "$path" -o -d "$path" ] ; then
            if [ "$emitdir" = 1 ] ; then
                found=${found#${partial}}
            fi
            found=`canonPath "${path}"`
            [ "$trace" != 0 -a "$found" != "" ] && echo "    probe: found $name at $found" 1>&2
        fi
    fi
    if [ "$found" = "" ] ; then
        #
        #   Fast search using "type". Works for executables only.
        #
        [ "$search" = "" ] && search="$SEARCH_PATH"
        OLD_PATH="$PATH"
        PATH="$search"
        found=`type -P "$partial" 2>/dev/null`
        PATH=$OLD_PATH
        if [ "$emitdir" = "1" ] ; then
            found=${found%${partial}}
            found=${found%/}
        fi
        [ "$trace" != 0 -a "$found" != "" ] && echo "    probe: $name at found $found" 1>&2
    fi

    #
    #   Search manually along the search path
    #
    if [ "$found" = "" ] ; then
        SAVE_IFS=$IFS
        IFS=":"

        for d in $search ; do
            [ "$trace" != 0 -a "$found" != "" ] && echo "    probe: testing $name at $d" 1>&2
            [ "${d}" = "/" ] && d=
            f=${d}/${partial}
            if [ -f "${f}" -o -d "${f}" ] ; then
                [ "${d}" = "" ] && d=/
                if [ "$emitdir" = "1" ] ; then
                    found="$d"
                else
                    found=${d}/${partial}
                fi
                search=
                [ "$trace" != 0 -a "$found" != "" ] && echo "    probe: found $name at $found" 1>&2
                break
            fi
        done
        IFS="$SAVE_IFS"
    fi

    if [ "$found" = "" ] ; then
        [ "$trace" != 0 ] && echo "    probe: $name not found" 1>&2
        echo $found
    else
        canonPath "${found%*/}"
    fi
}


#
#   Add a component to build with
#
with() {
    local arg dir forOs kind kinds mandatory os name upperName lowerName components

    mandatory=1

    kinds="BUILD HOST"
    while [ "${1#--}" != "$1" ] ; do
        case ${1#--} in
        build)
            kinds="BUILD"
            ;;
        host)
            kinds="HOST"
            ;;
        mandatory)
            mandatory=1
            ;;
        optional)
            mandatory=0
            ;;
        os=*)
            forOs="${1#--*=}"
            forOs=`upper ${forOs}`
            ;;
        esac
        shift
    done

    [ $BLD_CROSS = 0 ] && kinds=BUILD

    #
    #   Ejs must be built on both sides if required on the host side. This is needed to compile modules.
    #
    [ "$1" = "ejs" -a "$kinds" = "HOST" ] && kinds="BUILD HOST"

    for kind in $kinds ; do
        eval os=\$BLD_${kind}_OS
        for arg in $* ; do
            name="${arg%=*}"
            dir="${arg##*=}"

            eval XX_${name}=1 >/dev/null 2>&1
            if [ $? != 0 ] ; then
                echo "configure: Bad \"with\" option: with-${name}" >&2
                exit 255
            fi
            [ "$dir" = "${arg}" ] && dir=

            upperName=`upper ${name}`
            lowerName=`lower ${name}`

            if [ "$forOs" = "" -o "$forOs" = "$os" ] ; then
                components=" ${BLD_COMPONENTS} "
                if [ "${components/ ${lowerName} /}" = "$components" ] ; then
                    BLD_COMPONENTS="$BLD_COMPONENTS $lowerName"
                fi
                eval CFG_${kind}_${upperName}=$dir
                eval CFG_${kind}_${upperName}_WITH=1
                eval CFG_${kind}_${upperName}_MANDATORY=$mandatory
            fi
        done
    done
}


without() {
    local name upperName lowerName components

    name="$1"
    upperName=`upper ${name}`
    lowerName=`lower ${name}`

    if [ ! -f build/components/${lowerName} ] ; then
        echo "Unknown component \"${name}\". Ignoring and continuing ..."
    fi
    components=" ${BLD_COMPONENTS} "
    if [ "${components/ $lowerName /}" = "$components" ] ; then
        BLD_COMPONENTS="$BLD_COMPONENTS $lowerName"
    fi
    BLD_COMPONENTS="${components/ $lowerName / }"
    eval "CFG_WITHOUT_${upperName}"=1
    eval "BLD_FEATURE_${upperName}"=0
}


findLibrary()
{
    local path prefix name suffix suffixes file

    name="$1"

    suffixes=".so .dylib .a .dll"
    if [ "${name%.*}" != "${name}" ] ; then
        suffixes=".${name#*.}"
        name="${name%.*}"
    fi

    eval cpu=\$BLD_${KIND}_CPU
    paths=""
    if [ "$cpu" = "x86_64" -a -x /usr/lib64 ] ; then
        paths="$paths /usr/lib64"
    else
        paths="$paths /usr/lib"
    fi
    paths="$paths /usr/local/lib /opt/local/lib"

    for path in ${paths}
    do
        for suffix in `echo $suffixes`
        do
            for prefix in lib ""
            do
                [ "$path" = "" ] && continue

                for file in "${path}/${prefix}${name}${suffix}"* "${path}/${prefix}${name}"*${suffix}* ; do
                    [ "$verbose" -gt 0 ] && echo "findLibrary: Probing ${file}" >&2

                    [ -d "${file}" ] && continue

                    if [ -f "${file}" -o -L "${file}" ] ; then
                        [ "$verbose" -gt 0 ] && echo -e "findLibrary: FOUND ${file}\n" >&2

                        if [ "$OS" = "WIN" ] ; then
                            echo "${file}"
                        else 
                            if [ "${name%${BLD_ARCH}}" != "${name}" ] ; then
                                echo "${file}"
                            else
                                echo canonPath "${file}"
                            fi
                        fi
                        return
                    fi
                done
            done
        done
    done
}


#
#   Return a unique set of words without changing the order
#
unique() {
    local result
    set -f 
    for word in $*
    do 
        case " $result " in 
        *\ $word\ *) ;; 
        *) result=${result:+"$result "}$word 
        ;; 
        esac 
    done 
    echo $result 
    set +f
}


createBuildConfig() {
    #
    #   Create the buildConfig.sh and buildConfig.make files
    #
    [ $quiet = 0 ] && echo "  #"
    rm -f $CONFIG_SH $CONFIG_MAKE $CONFIG_H
    for f in $CONFIG_SH $CONFIG_MAKE $CONFIG_H
    do
        [ $quiet = 0 ] && echo "  # Creating $f ..."
        createConfig $f
    done

    cp $CONFIG_MAKE config.tmp 
    sed 's/'\''//g' < config.tmp | sed -e 's/""//g' >$CONFIG_MAKE
    sed 's/'\''//g' < config.tmp | sed 's/"//g' >$CONFIG_MAKE
    rm -f config.tmp

    #
    #   Modify the $CONFIG_H file. Do the following edits:
    #   - Convert '#define' to '//' comments
    #   - Convert X=Y to #define X Y
    #   - Convert all "'" to '"'
    #
    cp $CONFIG_H config.sav

    egrep -v '^	#$|^	#	|^	# |^# |^#$|^# |^    # ' < config.sav | egrep -v '^export ' | \
        sed 's/\([^=]*\)=\(.*\)/#define \1 \2/' | sed 's/'\''/"/g' | \
        sed 's/^#define/    #define/' | sed 's/^ #/#/' >$CONFIG_H
    addScripts
    if [ "$BLD_HOST_OS" = WIN ] ; then
        cp $CONFIG_H /tmp/config$$.tmp
        cat /tmp/config$$.tmp | grep -v 'BLD_ABS_' >$CONFIG_H
        rm -f /tmp/config$$.tmp 
    fi
    chmod 444 $CONFIG_SH $CONFIG_MAKE $CONFIG_H
    rm -f config.sav config.tmp

    >$CONFIG_ARGS
    for t in ANT AR BREW CC DOXYGEN CXX JAVAC JDK JAR LD LDXX MT MUNCH NM RANLIB RC STRIP
    do
        eval value="\$${t}"
        if [ "$value" != "" ] ; then
            echo "export $t=\"$value\"" >>$CONFIG_ARGS
        fi
    done

    for t in AR CC CXX LD LDXX MT NM RANLIB RC STRIP
    do
        eval value="\$BUILD_${t}"
        if [ "$value" != "" ] ; then
            echo "export $t=\"$value\"" >>$CONFIG_ARGS
        fi
    done

    for t in $FLAGS
    do
        eval value="\$BUILD_${t}FLAGS"
        if [ "$value" != "" ] ; then
            echo "export ${t}FLAGS=\"$value\"" >>$CONFIG_ARGS
        fi
        eval value="\$${t}FLAGS"
        if [ "$value" != "" ] ; then
            echo "export ${t}FLAGS=\"$value\"" >>$CONFIG_ARGS
        fi
    done

    echo "export PATH=\"$PATH\"" >>$CONFIG_ARGS
    echo -e "\n./configure $CMD_LINE" >>$CONFIG_ARGS

    [ $quiet = 0 -a $verbose != 0 ] && echo "  # Creating $CONFIG_ARGS ..."
}

#
#   Add scripts to buildConfig.sh
#
addScripts() {
    cat >>$CONFIG_SH <<!SCRIPT_EOF_0
#
#   Patch the !!BLD_XXX!! 
#
patchFile() {
    local file arg

    [ \$# -lt 1 ] && echo "Bad args: patchFile \$*" && exit 255

    arg=1
    while [ \$arg -le \$# ] ; do
        file=\${!arg}
        if [ -s "\${file}" ] ; then
!SCRIPT_EOF_0

    echo "            cp \"\${file}\" /tmp/in\$\$.tmp" >>$CONFIG_SH

    i=0
    for v in BLD_ABS_BIN_DIR BLD_ABS_INC_DIR BLD_ABS_JEM_DIR BLD_ABS_LIB_DIR BLD_ABS_MOD_DIR BLD_ABS_OBJ_DIR BLD_APPWEB BLD_APPWEB_BUILTIN BLD_APPWEB_DEPENDENCIES BLD_APPWEB_LIBS BLD_APPWEB_OPTIONAL_DEPENDENCIES BLD_APPWEB_WITH BLD_AR BLD_ARCH BLD_AR_BUILTIN BLD_AR_WITH BLD_BIN_DIR BLD_BIN_NAME BLD_BIN_PREFIX BLD_BUILD_ARCH BLD_BUILD_CLASS BLD_BUILD_CPU BLD_BUILD_CPU_ARCH BLD_BUILD_CPU_MODEL BLD_BUILD_CPU_UPPER BLD_BUILD_EXE BLD_BUILD_OBJ BLD_BUILD_OS BLD_BUILD_PIOBJ BLD_BUILD_SHLIB BLD_BUILD_SHOBJ BLD_BUILD_SYSTEM BLD_BUILD_UNIX BLD_BUILD_WIN BLD_CC BLD_CC_BUILTIN BLD_CC_CYGWIN BLD_CC_DIAB BLD_CC_DYN_LOAD BLD_CC_MMU BLD_CC_MTUNE BLD_CC_STACK_PROTECTOR BLD_CC_WITH BLD_CFG_PREFIX BLD_CFLAGS BLD_CLASS BLD_CLEAN_INSTALL BLD_COMMERCIAL BLD_COMPANY BLD_COMPONENTS BLD_CPU BLD_CPU_ARCH BLD_CPU_MODEL BLD_CPU_UPPER BLD_CROSS BLD_DATE BLD_DEBUG BLD_DEFAULTS BLD_DFLAGS BLD_DIRS BLD_DIST BLD_DIST_VER BLD_DOC_PREFIX BLD_EXE BLD_FEATURE_ANGEL BLD_FEATURE_APACHE BLD_FEATURE_APPWEB BLD_FEATURE_AR BLD_FEATURE_ASSERT BLD_FEATURE_CC BLD_FEATURE_CMD BLD_FEATURE_COMPLETE_CROSS BLD_FEATURE_COMPLETE_NATIVE BLD_FEATURE_CONFIG_PARSE BLD_FEATURE_DEVICE BLD_FEATURE_DOC BLD_FEATURE_DOXYGEN BLD_FEATURE_EJS BLD_FEATURE_EJS_DB BLD_FEATURE_EJS_DOC BLD_FEATURE_EJS_E4X BLD_FEATURE_EJS_LANG BLD_FEATURE_EJS_WEB BLD_FEATURE_FLOATING_POINT BLD_FEATURE_HTTP BLD_FEATURE_HTTP_CLIENT BLD_FEATURE_JAVA_VM BLD_FEATURE_LEGACY_API BLD_FEATURE_MAKE BLD_FEATURE_MATRIXSSL BLD_FEATURE_MULTITHREAD BLD_FEATURE_NUM_TYPE BLD_FEATURE_OPENSSL BLD_FEATURE_RANLIB BLD_FEATURE_REGEXP BLD_FEATURE_SAMPLES BLD_FEATURE_SERVICES BLD_FEATURE_SQLITE BLD_FEATURE_SSL BLD_FEATURE_STATIC BLD_FEATURE_TEST BLD_FEATURE_XML BLD_HOST_CPU BLD_HOST_CPU_ARCH BLD_HOST_CPU_MAPPED BLD_HOST_CPU_MODEL BLD_HOST_CPU_UPPER BLD_HOST_DIST BLD_HOST_DIST_VER BLD_HOST_OS BLD_HOST_SYSTEM BLD_HOST_UNIX BLD_HOST_WIN BLD_IFLAGS BLD_INC_DIR BLD_INC_NAME BLD_INC_PREFIX BLD_JEM_DIR BLD_JEM_PREFIX BLD_JFLAGS BLD_LDFLAGS BLD_LIB BLD_LIB_DIR BLD_LIB_NAME BLD_LIB_PREFIX BLD_LICENSE BLD_LOG_PREFIX BLD_MAKE BLD_MAKE_BUILTIN BLD_MAKE_WITH BLD_MAN_PREFIX BLD_MOD_DIR BLD_MOD_NAME BLD_MOD_PREFIX BLD_NAME BLD_NUMBER BLD_NUMBER_ONLY BLD_OBJ BLD_OBJ_DIR BLD_OBJ_NAME BLD_OS BLD_OSVER BLD_PIOBJ BLD_PRD_PREFIX BLD_PREFIX BLD_PRODUCT BLD_RANLIB BLD_RANLIB_BUILTIN BLD_RANLIB_WITH BLD_SAM_PREFIX BLD_SBIN_PREFIX BLD_SHLIB BLD_SHOBJ BLD_SRC_PREFIX BLD_TOOLS_DIR BLD_TUNE BLD_TYPE BLD_UNIX_LIKE BLD_VERSION BLD_VER_PREFIX BLD_WEB_PREFIX BLD_WIN_LIKE BUILD_CROSS_OR_COMPLETE_NATIVE BUILD_NATIVE_OR_COMPLETE_CROSS ORIG_BLD_BIN_PREFIX ORIG_BLD_CFG_PREFIX ORIG_BLD_DOC_PREFIX ORIG_BLD_INC_PREFIX ORIG_BLD_JEM_PREFIX ORIG_BLD_LIB_PREFIX ORIG_BLD_LOG_PREFIX ORIG_BLD_MAN_PREFIX ORIG_BLD_MOD_PREFIX ORIG_BLD_PRD_PREFIX ORIG_BLD_PREFIX ORIG_BLD_SAM_PREFIX ORIG_BLD_SBIN_PREFIX ORIG_BLD_SRC_PREFIX ORIG_BLD_VER_PREFIX ORIG_BLD_WEB_PREFIX ROOT_DIR
    do
        if [ $i -eq 0 ] ; then
            echo "            sed -e \"" >>$CONFIG_SH
        fi
        echo "s^!!${v}!!^\${$v}^g;" >>$CONFIG_SH
        i=$((i+1))
        if [ $i -ge 50 ] ; then
            echo "            \" < /tmp/in\$\$.tmp > /tmp/out\$\$.tmp" >>$CONFIG_SH
            echo "            mv /tmp/out\$\$.tmp /tmp/in\$\$.tmp" >>$CONFIG_SH
            i=0
        fi
    done
    if [ $i -eq 0 ] ; then
        echo "            mv /tmp/in\$\$.tmp \"\${file}\"" >>$CONFIG_SH
    else
        echo "            \" < /tmp/in\$\$.tmp > /tmp/out\$\$.tmp" >>$CONFIG_SH
        echo "            rm -f /tmp/in\$\$.tmp" >>$CONFIG_SH
        echo "            mv /tmp/out\$\$.tmp \"\${file}\"" >>$CONFIG_SH
    fi

    cat >>$CONFIG_SH <<!SCRIPT_EOF_1
        fi
        arg=\$((arg + 1))
    done
}
!SCRIPT_EOF_1
}


#
#   Create the buildConfig header
#
createConfigHeader()
{
    NAME=$1
    FILE=$2

    rm -f $NAME
    if [ "$NAME" = $CONFIG_H ]
    then
        cat >$FILE <<!EOF_CONFIG_HEADER_H
/*  
 *  ${NAME} -- Build configuration file.
 *  
 *  WARNING: DO NOT EDIT. This file is generated by configure.
 *
 *  Use "./configure --help" for available options.
 */ 

!EOF_CONFIG_HEADER_H
    else
        cat >$FILE <<!EOF_CONFIG_HEADER_SH_MAKE
#   
#   ${NAME} -- Build configuration file.
#   
#   WARNING: DO NOT EDIT. This file is generated by configure.
#   
#   Use "./configure --help" for available options.
#   
################################################################################
!EOF_CONFIG_HEADER_SH_MAKE
    fi
}


#
#   Create a buildConfig.* file. NAME is the first arg.
#
createConfig()
{
    local enabled kind d dir

    NAME=$1

    rm -f $NAME
    createConfigHeader $NAME $NAME

    BLD_HOST_CPU_UPPER=`upper $BLD_HOST_CPU`
    BLD_BUILD_CPU_UPPER=`upper $BLD_BUILD_CPU`
    local upper=`upper $BLD_PRODUCT`

    cat >>$NAME <<!EOF_CONFIG1
#
#   Key Product Settigns
#
!EOF_CONFIG1

    patch=${BLD_VERSION##*.}
    major=${BLD_VERSION%%.*}
    y=${BLD_VERSION%.*}
    minor=${y#*.}

    vnum=$(( ((((major * 1000) + minor) * 1000) + patch) ))
    echo "BLD_${upper}_PRODUCT=1" >>$NAME
    cat >>$NAME <<!EOF_CONFIG1a
BLD_PRODUCT="$BLD_PRODUCT"
BLD_NAME="$BLD_NAME"
BLD_VERSION="$BLD_VERSION"
BLD_NUMBER="$BLD_NUMBER"
BLD_NUMBER_ONLY="${BLD_NUMBER%-*}"
BLD_MAJOR_VERSION=$major
BLD_MINOR_VERSION=$minor
BLD_PATCH_VERSION=$patch
BLD_VNUM="$vnum"
BLD_TYPE="$BLD_TYPE"
BLD_TUNE=$BLD_TUNE
BLD_DEFAULTS="$BLD_DEFAULTS"
BLD_COMPONENTS="$BLD_COMPONENTS"
BLD_EMBEDTHIS=$BLD_EMBEDTHIS

#
#   Other Product Settings
#
BLD_COMPANY="$BLD_COMPANY"
BLD_DEBUG=$BLD_DEBUG
BLD_DIRS="$BLD_DIRS"
BLD_CLEAN_INSTALL="$BLD_CLEAN_INSTALL"
BLD_LICENSE="$BLD_LICENSE"
BLD_COMMERCIAL="$BLD_COMMERCIAL"

#
#   Host and Build System Settings.
#
BLD_HOST_SYSTEM="$BLD_HOST_SYSTEM"
BLD_BUILD_SYSTEM="$BLD_BUILD_SYSTEM"
BLD_CROSS="$BLD_CROSS"

#
#   Host System Settings 
#
BLD_HOST_OS="$BLD_HOST_OS"
BLD_HOST_CPU_ARCH=$BLD_HOST_CPU_ARCH
BLD_HOST_CPU="$BLD_HOST_CPU"
BLD_HOST_CPU_UPPER="$BLD_HOST_CPU_UPPER"
BLD_HOST_CPU_MODEL="$BLD_HOST_CPU_MODEL"
BLD_HOST_DIST="$BLD_HOST_DIST"
BLD_HOST_DIST_VER="$BLD_HOST_DIST_VER"
BLD_HOST_UNIX=$BLD_HOST_UNIX
BLD_HOST_WIN=$BLD_HOST_WIN
!EOF_CONFIG1a

    if [ "$BLD_HOST_OS" = VXWORKS ] ; then
        echo "BLD_BUILD_CPU_VX=$BLD_BUILD_CPU_VX" >>$NAME
        echo "BLD_BUILD_SYSTEM_VX=$BLD_BUILD_SYSTEM_VX" >>$NAME
    fi

    cat >>$NAME <<!EOF_CONFIG2

#
#   Build System Settings for Build Tools
#
BLD_BUILD_OS="$BLD_BUILD_OS"
BLD_BUILD_CPU_ARCH=$BLD_BUILD_CPU_ARCH
BLD_BUILD_CPU="$BLD_BUILD_CPU"
BLD_BUILD_CPU_UPPER="$BLD_BUILD_CPU_UPPER"
BLD_BUILD_CPU_MODEL="$BLD_BUILD_CPU_MODEL"
BLD_BUILD_UNIX=$BLD_BUILD_UNIX
BLD_BUILD_WIN=$BLD_BUILD_WIN

#
#   System and Installation Directories
#
BLD_ROOT_PREFIX="$BLD_ROOT_PREFIX"
BLD_PREFIX="$BLD_PREFIX"
BLD_CFG_PREFIX="$BLD_CFG_PREFIX"
BLD_BIN_PREFIX="$BLD_BIN_PREFIX"
BLD_DOC_PREFIX="$BLD_DOC_PREFIX"
BLD_INC_PREFIX="$BLD_INC_PREFIX"
BLD_JEM_PREFIX="$BLD_JEM_PREFIX"
BLD_LIB_PREFIX="$BLD_LIB_PREFIX"
BLD_LOG_PREFIX="$BLD_LOG_PREFIX"
BLD_MAN_PREFIX="$BLD_MAN_PREFIX"
BLD_MOD_PREFIX="$BLD_MOD_PREFIX"
BLD_PRD_PREFIX="$BLD_PRD_PREFIX"
BLD_SAM_PREFIX="$BLD_SAM_PREFIX"
BLD_SRC_PREFIX="$BLD_SRC_PREFIX"
BLD_VER_PREFIX="$BLD_VER_PREFIX"
BLD_WEB_PREFIX="$BLD_WEB_PREFIX"

#
#   Absolute native library and module directories
#
!EOF_CONFIG2

    v=`eval canonPath "${BLD_BUILD_LIB_DIR}"` 
    echo -e "BLD_BUILD_LIB_DIR=\"${v}\""      >>$NAME
    v=`eval canonPath "${BLD_BUILD_MOD_DIR}"` 
    echo -e "BLD_BUILD_MOD_DIR=\"${v}\""      >>$NAME

    cat >>$NAME <<!EOF_STANDARD_FEATURES

#
#   Standard Feature Selection
#
BLD_FEATURE_ASSERT=$BLD_FEATURE_ASSERT
BLD_FEATURE_CMD=$BLD_FEATURE_CMD
BLD_FEATURE_COMPLETE_NATIVE=$BLD_FEATURE_COMPLETE_NATIVE
BLD_FEATURE_COMPLETE_CROSS=$BLD_FEATURE_COMPLETE_CROSS
BLD_FEATURE_DOC=$BLD_FEATURE_DOC
BLD_FEATURE_DEVICE=$BLD_FEATURE_DEVICE
BLD_FEATURE_FLOATING_POINT=$BLD_FEATURE_FLOATING_POINT
BLD_FEATURE_LEGACY_API=$BLD_FEATURE_LEGACY_API
BLD_FEATURE_MULTITHREAD=$BLD_FEATURE_MULTITHREAD
BLD_FEATURE_NUM_TYPE=${BLD_FEATURE_NUM_TYPE}
BLD_FEATURE_NUM_TYPE_STRING="${BLD_FEATURE_NUM_TYPE}"
BLD_FEATURE_SAMPLES=$BLD_FEATURE_SAMPLES
BLD_FEATURE_TEST=$BLD_FEATURE_TEST
!EOF_STANDARD_FEATURES

	if [ $NAME = $CONFIG_H ] ; then
        echo '' >>$NAME
		echo '    #ifdef STATIC_OVERRIDE' >>$NAME
		echo '        BLD_FEATURE_STATIC=STATIC_OVERRIDE' >>$NAME
		echo '    #else' >>$NAME
		echo "        BLD_FEATURE_STATIC=$BLD_FEATURE_STATIC" >>$NAME
		echo '    #endif' >>$NAME
	else
		echo "BLD_FEATURE_STATIC=$BLD_FEATURE_STATIC" >>$NAME
	fi
	echo >>$NAME

    createFeatureConfig $NAME

    #
    #   These are used when Makefiles need to absolutely pick a build tool
    #   and need to use BLD_BUILD_EXE
    #
    echo -e "\n#\n#   File extensions \n#" >>$NAME
    for kind in BUILD HOST ; do
        for t in ARCH EXE OBJ PIOBJ CLASS SHLIB SHOBJ ; do
            eval value=\$BLD_${kind}_${t}
            eval value=\"$value\"
            echo BLD_${kind}_${t}=\"$value\" >>$NAME
        done
        [ $BLD_CROSS = 0 ] && break
    done

    if [ $BLD_CROSS = 0 ] ; then
        createCrossConfig $NAME BUILD >>$NAME
    else

        cat >>$NAME <<!EOF_CONFIG2d

#
#   Select Native or cross development flags
#
!EOF_CONFIG2d

        if [ $NAME = $CONFIG_MAKE ] ; then
            echo 'BUILD_NATIVE ?= 1' >>$NAME
            if [ "${BLD_CROSS}" = 1 ] ; then
                echo 'BUILD_CROSS ?= 1' >>$NAME
            fi
            echo '' >>$NAME

            echo 'ifneq ($(BUILDING_CROSS),1)' >>$NAME

        elif [ $NAME = $CONFIG_SH ] ; then
            echo ': ${BUILD_NATIVE:=1}' >>$NAME
            if [ "${BLD_CROSS}" = 1 ] ; then
                echo ': ${BUILD_CROSS:=1}' >>$NAME
            fi
            echo -e 'if [ "${BUILDING_CROSS}" != 1 ] ; then' >>$NAME
        else
            echo -e ' #if !BUILDING_CROSS' >>$NAME
        fi

        for kind in BUILD HOST 
        do
            createCrossConfig $NAME $kind >>$NAME
            if [ $kind = BUILD ] ; then
                if [ $NAME = $CONFIG_H ] ; then
                    echo -e '\n #else' >>$NAME
                else
                    echo -e '\nelse' >>$NAME
                fi
            fi
        done

        [ $NAME = $CONFIG_MAKE ] && echo -e 'endif\n' >>$NAME
        [ $NAME = $CONFIG_SH ] && echo -e 'fi\n' >>$NAME
        [ $NAME = $CONFIG_H ] && echo -e ' #endif' >>$NAME
    fi

    if [ $NAME = $CONFIG_MAKE ] ; then
        echo 'EXPORT_OBJECTS ?= 1' >>$NAME
        echo 'ifeq ($(EXPORT_OBJECTS),0)' >>$NAME
        echo '  BLD_OBJ_DIR := .' >>$NAME
        echo 'endif' >>$NAME
        echo '' >>$NAME

    elif [ $NAME = $CONFIG_SH ] ; then
        echo 'if [ "${EXPORT_OBJECTS}" = 0 ] ; then' >>$NAME
        echo '  BLD_OBJ_DIR=.' >>$NAME
        echo 'fi' >>$NAME
        echo '' >>$NAME
    fi

    if [ "$BLD_HOST_OS" = VXWORKS ] ; then
        if [ "${NAME}" = "$CONFIG_SH" ] ; then
            echo export WIND_HOME=\"${WIND_HOME}\" >>$NAME
            echo export WIND_BASE=\"${WIND_BASE}\" >>$NAME
            echo export WIND_HOST_TYPE=\"${WIND_HOST_TYPE}\" >>$NAME
        else
            echo export WIND_HOME=${WIND_HOME} >>$NAME
            echo export WIND_BASE=${WIND_BASE} >>$NAME
            echo export WIND_HOST_TYPE=${WIND_HOST_TYPE} >>$NAME
        fi
        echo >>$NAME
    fi
}


createCrossConfig()
{
    local name kind v os path top t

    name=$1
    kind=$2

    eval os=\$BLD_${kind}_OS

    if [ $kind = "HOST" ] ; then
        echo -e "\n    #\n	#	Configuration for Cross-Compilation for the Target\n	#\n"
    else
        echo -e "\n    #\n	#	Configuration for Native Compilation on the Build System\n	#\n"
    fi

    if [ $NAME = $CONFIG_MAKE -a $BLD_CROSS = 1 ] ; then
        if [ $kind = "HOST" ] ; then
            echo -e "	BUILD_NATIVE_OR_COMPLETE_CROSS=$BLD_FEATURE_COMPLETE_CROSS"
            echo -e "	BUILD_CROSS_OR_COMPLETE_NATIVE=1"
        else
            echo -e "	BUILD_NATIVE_OR_COMPLETE_CROSS=1"
            echo -e "	BUILD_CROSS_OR_COMPLETE_NATIVE=$BLD_FEATURE_COMPLETE_NATIVE"
        fi
    else
        echo -e "	BUILD_NATIVE_OR_COMPLETE_CROSS=1"
        echo -e "	BUILD_CROSS_OR_COMPLETE_NATIVE=1"
    fi

    echo -e "\n	#\n	#   O/S and CPU settings\n	#"
    eval v=\$BLD_${kind}_OS ;           echo -e "\t$v=1"
    eval v=\$BLD_${kind}_OS ;           echo -e "\tBLD_OS=\"$v\""
    eval v=\$BLD_${kind}_CPU_ARCH ;     echo -e "\tBLD_CPU_ARCH=$v"

    eval v=\$BLD_${kind}_CPU ;          echo -e "\tBLD_CPU=\"$v\""
    eval v=\$BLD_${kind}_CPU_UPPER ;    echo -e "\tBLD_CPU_UPPER=\"$v\""
    eval v=\$BLD_${kind}_CPU_MODEL ;    echo -e "\tBLD_CPU_MODEL=\"$v\""
    eval v=\$BLD_${kind}_DIST ;         echo -e "\tBLD_DIST=\"$v\""
    eval v=\$BLD_${kind}_DIST_VER ;     echo -e "\tBLD_DIST_VER=\"$v\""
    eval v=\$BLD_${kind}_UNIX ;         echo -e "\tBLD_UNIX_LIKE=$v"
    eval v=\$BLD_${kind}_WIN ;          echo -e "\tBLD_WIN_LIKE=$v"

    echo -e "\n\t#\n\t#   Compiler and linker flags\n\t#"
    for t in $FLAGS
    do
        eval v=\$BLD_${kind}_${t}FLAGS ;echo -e "\tBLD_${t}FLAGS=\"$v\""                 
    done

    echo -e "\n\t#\n\t#   File extensions\n\t#"

    eval v=\$BLD_${kind}_ARCH  ;        echo -e "\tBLD_ARCH=\"${v}\""
    eval v=\$BLD_${kind}_EXE   ;        echo -e "\tBLD_EXE=\"${v}\""
    eval v=\$BLD_${kind}_CLASS ;        echo -e "\tBLD_CLASS=\"${v}\""
    eval v=\$BLD_${kind}_SHLIB ;        echo -e "\tBLD_SHLIB=\"${v}\""
    eval v=\$BLD_${kind}_SHOBJ ;        echo -e "\tBLD_SHOBJ=\"${v}\""

    if [ "${BLD_FEATURE_STATIC}" = "0" ] ; then
        eval v=\$BLD_${kind}_SHOBJ ;    echo -e "\tBLD_LIB=\"${v}\""            
        eval v=\$BLD_${kind}_PIOBJ ;    echo -e "\tBLD_OBJ=\"${v}\""            
        eval v=\$BLD_${kind}_PIOBJ ;    echo -e "\tBLD_PIOBJ=\"${v}\""            
    else
        eval v=\$BLD_${kind}_ARCH ;     echo -e "\tBLD_LIB=\"${v}\""            
        eval v=\$BLD_${kind}_OBJ ;      echo -e "\tBLD_OBJ=\"${v}\""            
        eval v=\$BLD_${kind}_PIOBJ ;    echo -e "\tBLD_PIOBJ=\"${v}\""            
    fi

    echo -e "\n\t#\n\t#   Output directories \n\t#" >>$NAME

    for d in BIN LIB OBJ MOD INC
    do
        eval dir=\$BLD_${kind}_${d}_DIR
        dir=${dir/\${BLD_TOP\}\/}
        echo "    BLD_${d}_NAME=\"${dir}\""
    done

    echo -e '\tBLD_TOOLS_DIR="${BLD_TOP}/build/bin"' >>$NAME

    eval v=\$BLD_${kind}_BIN_DIR ;      echo -e "\tBLD_BIN_DIR=${v}"
    eval v=\$BLD_${kind}_OBJ_DIR ;      echo -e "\tBLD_OBJ_DIR=${v}"
    eval v=\$BLD_${kind}_MOD_DIR ;      echo -e "\tBLD_MOD_DIR=${v}"
    eval v=\$BLD_${kind}_JEM_DIR ;      echo -e "\tBLD_JEM_DIR=${v}"
    eval v=\$BLD_${kind}_LIB_DIR ;      echo -e "\tBLD_LIB_DIR=${v}"
    eval v=\$BLD_${kind}_INC_DIR ;      echo -e "\tBLD_INC_DIR=${v}"

    eval v=\${BLD_${kind}_BIN_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_BIN_DIR=\"${v}\""
    eval v=\${BLD_${kind}_LIB_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_LIB_DIR=\"${v}\""
    eval v=\${BLD_${kind}_OBJ_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_OBJ_DIR=\"${v}\""
    eval v=\${BLD_${kind}_MOD_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_MOD_DIR=\"${v}\""
    eval v=\${BLD_${kind}_JEM_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_JEM_DIR=\"${v}\""
    eval v=\${BLD_${kind}_INC_DIR} ;    v=`eval canonPath "${v}"` ;  echo -e "\tBLD_ABS_INC_DIR=\"${v}\""

    if [ $kind = "HOST" ] ; then
        echo -e "\n\t#\n\t#   Cross Compilation Features\n\t#"
        echo "    BLD_FEATURE_ROMFS=$BLD_FEATURE_ROMFS"
    else
        echo -e "\n\t#\n\t#   Native Compilation Features\n\t#"
        echo "    BLD_FEATURE_ROMFS=0"
    fi

    if [ $name != $CONFIG_H ] ; then
        #
        #   Set PATH, INCLUDE and LIB environment variables
        #
        echo -e "\n\t#\n\t#   Setup environment variables\n\t#" 
        if [ "$os" = WIN -o "$os" = WINCE ] ; then
            for var in INCLUDE LIB 
            do
                eval v=\"\$CFG_${kind}_${var}\"
                if [ "${name}" = "$CONFIG_SH" ] ; then
                    echo -e "\texport" $var=\"${v}\;\$${var}\" 
                else
                    echo -e "\texport" $var:=${v}\;\$\(${var}\)    
                fi
                echo 
            done
        fi

        top="$BLD_TOP"
        if [ $HAS_CYGPATH = 1 ] ; then
            top=`cygpath "${top}"`
        fi

        if [ "${BLD_HOST_OS}" = "LINUX" ] ; then
            SYS_DIR=":/sbin:/usr/sbin:"
        fi
        eval path=\$CFG_${kind}_PATH
        if [ "${name}" = "$CONFIG_SH" ] ; then
            echo -e "\texport PATH=\"\${top}/bin:${top}/modules:${top}/lib:${top}/lib:${top}/build/bin${SYS_DIR}:${path}:\${PATH}\"" 
        else
            echo -e "\texport PATH:=${top}/bin:${top}/modules:${top}/lib:${top}/lib:${top}/build/bin${SYS_DIR}:${path}:\$(PATH)" 
        fi
    fi

    emitComponents $kind
}


emitComponents() {
    local host p dir v emitter present value

    kind=$1

    for p in $BLD_COMPONENTS
    do
        p=`upper ${p}`
        eval present="\$CFG_${kind}_${p}"
        eval dir=\$CFG_${p}_DIR

        echo -e "\n\t#\n\t#   ${p}\n\t#" 
        if [ "$present" = "" ] ; then 
            echo -e "\tBLD_FEATURE_${p}=0" 
            continue
        else
            echo -e "\tBLD_FEATURE_${p}=1" 
        fi

        set | grep "^CFG_${kind}_${p}" | egrep -v "_EMITTER|_WITH_|_MANDATORY" | while read v
        do
            v=${v%=*}
            eval value=\$$v
            v=${v/CFG/BLD}
            if [ "$value" != "" ] ; then
                v=${v/_${kind}/}
                if [ $name != $CONFIG_MAKE ] ; then
                    if [ "${v}" = ${v/BUILTIN/} ] ; then
                        value=\"${value}\"
                    fi
                fi
                echo -e "\t${v#_}=$value"
            fi
        done

        eval emitter="\$CFG_${kind}_${p}_EMITTER"
        if [ "$emitter" != "" ] ; then
            KIND=$kind $emitter
        fi
    done
    echo 

    set | grep "^CFG_WITHOUT" | while read v
    do
        v=${v%=*}
        v=${v/CFG/BLD}
        v=${v/WITHOUT/FEATURE}
        echo -e "\t${v#_}=0"
    done
    echo 
}


showBuildConfig() {
    local p

    [ $quiet = 1 ] && return 0

    echo "  # Configuration for this build:"
    echo "  #"
    echo "  #   Configuring Product:   ${BLD_PRODUCT}"
    echo "  #   Base configuration:    build/${BLD_DEFAULTS}.defaults"
    echo "  #   Version:               ${BLD_VERSION}-${BLD_NUMBER}"
    echo "  #   Host system:           ${BLD_HOST_SYSTEM}, ${BLD_HOST_OS}, ${BLD_HOST_CPU}"
    echo "  #   Build system:          ${BLD_BUILD_SYSTEM}, ${BLD_BUILD_OS}, ${BLD_BUILD_CPU}"
    echo "  #   Debug Type:            ${BLD_TYPE}"
    echo "  #   Tune for:              ${BLD_TUNE}"
    if [ "$BLD_FEATURE_MULTITHREAD" = 1 ] ; then
        echo "  #   Threading              multi-threaded"
    else
        echo "  #   Threading              single-threaded"
    fi
    if [ "$BLD_FEATURE_STATIC" = 1 ] ; then
        echo "  #   Linking                static"
    else
        echo "  #   Linking                shared"
    fi
    echo -n "  #   Build components:      "
    i=0
    for p in ${BUILD_COMPONENTS}
    do
        echo -n "$p "
        i=$((i +1))
        if [ $i -gt 8 ] ; then
            i=0
            echo -e -n "\n  #                          "
        fi
    done
    echo
    if [ $BLD_CROSS = 1 ] ; then
        echo -n "  #   Host components:       "
        for p in ${HOST_COMPONENTS}
        do
            echo -n "$p "
        done
        echo
    fi
    echo -e "  #   Directories:"
    for p in PRD VER CFG BIN JEM LIB MOD WEB INC
    do
        eval dir=\$BLD_${p}_PREFIX
        echo -e "  #   ${p}   ${dir}"
    done
    echo
}


postGen() {
    local f

    if [ "$BLD_HOST_OS" = "LINUX" -o "$BLD_HOST_OS" = "SOLARIS" -o "$BLD_HOST_OS" = "FREEBSD" \
            -o "$BLD_HOST_OS" = MACOSX ] ; then
        if [ "$BLD_DEBUG" = 0 ] ; then
            if [ "`echo $LD_LIBRARY_PATH | grep bin`" = "" ] ; then
                if [ $quiet = 0 -a ! -f ${BLD_TOP}/.embedthis ] ; then
                    echo -e "  #\n  # If you wish to debug natively in the build tree, you will need to set the"
                    if [ "$BLD_HOST_OS" = MACOSX ] ; then
                        echo -e "  # DYLD_LIBRARY_PATH environment variable to include the \"lib\" directory. Try:"
                        echo -e "  #\n  #    export DYLD_LIBRARY_PATH=`pwd`/lib"
                    else
                        echo -e "  # LD_LIBRARY_PATH environment variable to include the \"lib\" directory. Try:"
                        echo -e "  #\n  #    export LD_LIBRARY_PATH=`pwd`/lib"
                    fi
                    echo -e "  #\n  # See \"INSTALL.TXT\" for details."
                    echo -e "  #"
                fi
            fi
        fi
    fi
    for f in bld config.guess config.sub edep priv
    do
        chmod +x "${BLD_TOP}/build/bin/$f" >/dev/null 2>&1
    done

    #
    #   Touch all headers and remove objects to force a (somewhat) clean build
    #
    echo -e "  # Cleanup and generate make dependencies ...\n  #"
    files=`echo src/include/*`
    [ "$files" != 'src/include/*' ] && touch src/include/*
    rm -f obj/*.o obj/*.obj bin/*.exe
    rm -f lib/*.so lib/*.dylib lib/*.lib lib/*.dll lib/*.a
    rm -f modules/*.so modules/*.dylib modules/*.mod modules/*.dll
    [ -f .makedep ] && $MAKE -C bin clean depend 2>&1 >/dev/null
    $MAKE depend 2>&1 >/dev/null
    $MAKE clean 2>&1 >/dev/null
}


#
#   Output the --help usage message
#
standardHelp()
{
    cat <<!EOF_HELP

usage: configure [OPTIONS]...

Installation directories:
  When doing a "make install" the --prefix and --binDir are used. The other
  directory options are not yet fully supported.

  --prefix=PATH            Set the default base installation directory for 
                             the product. Default is /usr/lib/${BLD_PRODUCT} on 
                             Unix, /Program Files/${BLD_NAME} on Windows.
  --datadir                Directory for generic data files. Typically
                             /usr/share on Unix systems.
  --docdir=PATH            Set the directory for the documentation.
  --incdir=PATH            Set the directory for include headers. --includedir and
                             --oldincludedir are aliases.
  --localstatedir          Set the directory for modifiable files. Typically 
                              /var on Unix. 
  --logdir=PATH            Set the directory for logging.
  --mandir=PATH            Set the directory for the manual pages (UNIX only).
  --samdir=PATH            Set the directory for the samples.
  --sbindir=PATH           Set the directory for system binaries.
  --srcdir=PATH            Set the directory for source files.
  --sysconfdir=PATH        Set the directory for read-only data for the product. 
                             Default is /etc/${BLD_PRODUCT} on Unix.
  --webdir=PATH            Set the directory for web files

Standard options that are ignored but provided for compatibility with autoconf.
  --exec-prefix
  --sbindir
  --sharedstatedir
  --infodir
  --program-prefix
  --program-suffix
  --program-transform-name

System Types:
  --build=BUILD            Configure for building on BUILD [Default is guessed].
                             BUILD format is cpu-vendor-os.
  --host=HOST              Cross-compile for ${BLD_PRODUCT} to run on HOST
                             [Default is set to BUILD]. HOST format is
                             cpu-vendor-os. Can also use --target as an alias
                             for --host. WARNING: WindRiver calls the build 
                             system the host system.
                           and the host system, they call the target.
  --device=DEVICE          Device or emulator. On CE set to PocketPC2003 or 
                             Smartphone2003.

General Features:
  --buildNumber=NUMBER     Set the build number part of the version (1.0.0.X).
  --defaults=FILE          Set the file name of the defaults master in conf
  --help                   Display this message.
  --cygwin                 Use the cygwin compiler in preference if a Microsoft
                           Visual Studio compiler is also installed.
  --diab                   Use the diab compiler for VxWorks
  --name=NAME              Set the full product name (BLD_NAME define).
  --product=NAME           Set the one word (no spaces) name of the product.
  --quiet, -q, --silent    Run quietly.
  --search path            Search this path first for components.
  --setLibVersion=X.X.X    Set the shared library version number.
  --setVersion=X.X.X       Set the product version number.
  --type=BUILD             Set the build type to (DEBUG|RELEASE).
                           Can also use --debug or --release
  --tune=KIND              Set the tune kind to (SIZE|BALANCED|SPEED).

Optional Build Features:   (See more features below)
  --disable-FEATURE        Do not include the FEATURE.
  --enable-FEATURE         Include the FEATURE.

  --enable-all             Include all possible features and modules.
  --disable-all            Include as little as possible.

  --enable-assert          Build with assert checking.
  --enable-complete-cross  Build everything for the target host system.
  --enable-complete-native Build everything for the build system. [default]
  --enable-doc             Build the documentation.
  --enable-floating-point  Build with floating point support in JavaScript.
  --enable-legacy-api      Build with legacy API support for backwards 
                             compatibility.
  --enable-log             Build with error logging.
  --enable-multi-thread    Build multi-threaded.
  --enable-rom             Build with the ability to load files from ROM.
  --enable-samples         Build the samples
  --enable-test            Build all unit tests.
  --shared                 Build an ${BLD_PRODUCT} shared library and program. [default]
                           Use either --shared or --static but not both.
  --static                 Build a static ${BLD_PRODUCT} library and program. [default]

Environment Variables:

Some important environment variables that may be defined to control
building for the destination host. Note that environment variables will have
no effect when passed into makefiles, they must be passed via configure.

  AR                       Archiver command
  CC                       C/C++ compiler command.
  DOXYGEN                  Doxygen documentation generation command.
  LD                       Linker command.
  MT                       The windows manifest command.
  NM                       The nm command.
  RANLIB                   The ranlib command.
  STRIP                    The strip command.

  CFLAGS                   Compiler flags for compilation
  DFLAGS                   Compiler preprocessor defines for compilation
  IFLAGS                   Preprocessor and include flags.
  LDFLAGS                  Linker flags. For example: use -L<dir> to specify
                           where to find libraries in non-standard directories.

These variables are for native compilation of tools needed by the build
process.
  BUILD_CC                 C/C++ compiler to use for native /local compilation
                           and linking on the build system.
  BUILD_LD                 Linker to use for native /local linking on the
                           build system.
  BUILD_MT                 Windows manifest command.

Search paths are defined by the PATH environment variable, the --host-search,
--build-search and the paths defined in build/search.config.
!EOF_HELP
}


lower() {
    echo $* | tr '[:upper:]' '[:lower:]'
}


upper() {
    echo $* | tr '[:lower:]' '[:upper:]'
}


compath() {
    local upperName
    upperName=`upper $*`
    eval echo \$CFG_${KIND}_${upperName}
}

isdefined() {
    local upperName
    upperName=`upper $*`
    eval value=\$CFG_${KIND}_${upperName}
    if [ "$value" != "" ] ; then 
        return 0
    else 
        return 1
    fi
}

###############################################################################
#
#   Main
#
quiet=0
verbose=0
CMD_LINE="$@"

. build/configure.*

checkSetup

# BLD_FEATURE_COMPLETE_NATIVE=0
# BLD_FEATURE_COMPLETE_CROSS=0
ENV_BUILD_SEARCH_PATH=$BUILD_SEARCH_PATH
ENV_HOST_SEARCH_PATH=$HOST_SEARCH_PATH

#
#   Command args are parsed in 2 phases. First parse the args that are critical for 
#   determining the system and cross-build configuration. After that, the build default
#   files are loaded and the rest of the args are parsed.
#
while [ "${1#--}" != "$1" -o "${1#-}" != "$1" ] ; do

    ARG="${1#*=}"
    [ "$ARG" = "$1" ] && ARG=

    SW=`echo ${1#--} | tr '[A-Z]' '[a-z]'`
    case ${SW} in
    build=*)
        system=`bash build/bin/config.sub "${ARG}"`
        if [ $? != 0 -o "$system" = "" ] ; then
            echo "configure: Can't recognize build system: $ARG"  1>&2
            exit 2
        fi
        BLD_BUILD_SYSTEM=${system}
        ;;
    build-search=*)
        BUILD_SEARCH_PATH="${ARG}"
        ;;
    cygwin)
        BLD_CC_CYGWIN=1
        ;;
    defaults=*)
        BLD_DEFAULTS="${ARG}"
        if [ ! -f "build/${BLD_DEFAULTS}.defaults" ] ; then
            echo "configure: Can't find build/${BLD_DEFAULTS}.defaults" 1>&2
            exit 2
        fi
        ;;
    device=*)
        BLD_FEATURE_DEVICE="${ARG}"
        ;;
    diab)
        BLD_CC_DIAB=1
        ;;
    help|-\?)
        standardHelp
        help
        exit 0
        ;;
    host=*|target=*)
        system=`bash build/bin/config.sub "${ARG}"`
        if [ $? != 0 -o "$system" = "" ] ; then
            echo "configure: Can't recognize host system configuration: $ARG"  1>&2
            exit 2
        fi
        BLD_HOST_SYSTEM=${system}
        ;;
    product=*)
        BLD_PRODUCT="${ARG}"
        args="$args $1"
        ;;
    quiet|-q)
        quiet=1
        ;;
    host-search=*)
        HOST_SEARCH_PATH="${ARG}"
        ;;
    verbose|-v)
        verbose=1
        ;;
    version|-V)
        echo $CONFIGURE_VERSION
        exit 0
        ;;
    *)  
        args="$args $1"
        ;;
    esac
    shift
done
set -- $args

if [ $quiet = 0 ] ; then
    echo -e "\n  #\n  # Running Embedthis Configure $CONFIGURE_VERSION"
    echo -e "  # "
    echo -e "  # Initializing configure ..."
fi

#
#   Set the system configuration
#
[ $quiet = 0 ] && echo -e "  # Sleuth system configuration ..."
setSystemConfiguration

#
#   Build up the search path
#
[ $quiet = 0 ] && echo -e "  # Prepare search path ..."
. build/search.config
BUILD_SEARCH_PATH=`convertSearchPath "$BUILD_SEARCH_PATH"`:$PATH
HOST_SEARCH_PATH=`convertSearchPath "$HOST_SEARCH_PATH"`:$PATH

if [ "$ENV_BUILD_SEARCH_PATH" != "" ] ; then
    BUILD_SEARCH_PATH=`convertSearchPath "$ENV_BUILD_SEARCH_PATH"`:"$BUILD_SEARCH_PATH"
fi
if [ "$ENV_HOST_SEARCH_PATH" != "" ] ; then
    HOST_SEARCH_PATH=`convertSearchPath "$ENV_HOST_SEARCH_PATH"`:"$HOST_SEARCH_PATH"
fi

#
#   Read the base configuration 
#
[ $quiet = 0 ] && echo -e "  # Reading standard product configuration: build/product.config ..."
. build/$BLD_DEFAULTS.defaults

#
#   Parse the rest of the command line args. See above for the pre-parsed args
#
while [ "${1#--}" != "$1" ] ; do

    ARG="${1#*=}"
    [ "$ARG" = "$1" ] && ARG=

    SW=`echo ${1#--} | tr '[A-Z]' '[a-z]'`
    case ${SW} in
#   bindir=*)
#      BLD_BIN_PREFIX=`canonPath "${ARG}"`
#       ;;
    buildNumber=*)
        BLD_NUMBER="${ARG}"
        ;;
    debug)
        BLD_TYPE=DEBUG
        BLD_DEBUG=1
        ;;
    disable-assert)
        BLD_FEATURE_ASSERT=0
        ;;
    disable-complete-cross)
        BLD_FEATURE_COMPLETE_CROSS=0
        ;;
    disable-complete-native)
        BLD_FEATURE_COMPLETE_NATIVE=0
        ;;
    disable-doc)
        BLD_FEATURE_DOC=0
        BLD_OPTIONAL_TOOLS=`echo $BLD_OPTIONAL_TOOLS | sed 's/DOXYGEN//'`
        ;;
    disable-floating-point)
        BLD_FEATURE_FLOATING_POINT=0
        ;;
    disable-legacy-api)
        BLD_FEATURE_LEGACY_API=0
        ;;
    disable-log)
        BLD_FEATURE_LOG=0
        ;;
    disable-multi-thread|disable-multithread|single)
        BLD_FEATURE_MULTITHREAD=0
        ;;
    disable-rom-fs|disable-rom|disable-romfs)
        BLD_FEATURE_ROMFS=0
        ;;
    disable-run-as-service)
        BLD_FEATURE_RUN_AS_SERVICE=0
        ;;
    disable-samples)
        BLD_FEATURE_SAMPLES=0
        ;;
    disable-shared)
        BLD_FEATURE_STATIC=1
        ;;
    disable-static)
        BLD_FEATURE_STATIC=0
        ;;
    disable-test)
        BLD_FEATURE_TEST=0
        ;;
    disable-mmu|disable-vmalloc)
        BLD_MMU_OVERRIDE=0
        ;;
    enable-assert)
        BLD_FEATURE_ASSERT=1
        ;;
    enable-complete-cross|complete-cross)
        BLD_FEATURE_COMPLETE_CROSS=1
        ;;
    enable-complete-native|complete-native)
        BLD_FEATURE_COMPLETE_NATIVE=1
        ;;
    enable-doc)
        BLD_FEATURE_DOC=1
        BLD_OPTIONAL_TOOLS=`echo $BLD_OPTIONAL_TOOLS | sed 's/DOXYGEN//'`
        BLD_OPTIONAL_TOOLS=`echo $BLD_OPTIONAL_TOOLS DOXYGEN`
        ;;
    enable-floating-point)
        BLD_FEATURE_FLOATING_POINT=1
        ;;
    enable-legacy-api)
        BLD_FEATURE_LEGACY_API=1
        ;;
    enable-log)
        BLD_FEATURE_LOG=1
        ;;
    enable-multi-thread|enable-multithread|multithread)
        BLD_FEATURE_MULTITHREAD=1
        ;;
    enable-rom-fs|enable-rom|enable-romfs|rom)
        BLD_FEATURE_ROMFS=1
        ;;
    enable-run-as-service)
        BLD_FEATURE_RUN_AS_SERVICE=1
        ;;
    enable-samples)
        BLD_FEATURE_SAMPLES=1
        ;;
    enable-shared|shared)
        BLD_FEATURE_STATIC=0
        ;;
    enable-static|static)
        BLD_FEATURE_STATIC=1
        ;;
    enable-test)
        BLD_FEATURE_TEST=1
        ;;
    enable-mmu|enable-vmalloc)
        BLD_MMU_OVERRIDE=1
        ;;
    docdir=*)
        BLD_DOC_PREFIX=`canonPath "${ARG}"`
        ;;
    datadir=*)
        BLD_DOC_PREFIX=`canonPath "${ARG}"/${BLD_PRODUCT}`
        BLD_SAM_PREFIX=`canonPath "${ARG}"/${BLD_PRODUCT}/samples`
        ;;
    incdir=*|includedir=*|oldincludedir=*)
        BLD_INC_PREFIX=`canonPath "${ARG}"`
        ;;
#    libdir=*)
#       BLD_LIB_PREFIX=`canonPath "${ARG}"`
#       ;;
#    libexecdir=*)
#       BLD_LIB_PREFIX=`canonPath "${ARG}"/${BLD_PRODUCT}/${BLD_VERSION}`
#       BLD_MOD_PREFIX=`canonPath "${ARG}"/${BLD_PRODUCT}/${BLD_VERSION}/modules`
#       BLD_JEM_PREFIX=`canonPath "${ARG}"/${BLD_PRODUCT}/jems`
#       ;;
    localstatedir=*)
        BLD_WEB_PREFIX=`canonPath "${ARG}"/www/${BLD_PRODUCT}-default`
        ;;
    logdir=*)
        BLD_LOG_PREFIX=`canonPath "${ARG}"`
        ;;
    mandir=*)
        BLD_MAN_PREFIX=`canonPath "${ARG}"`
        ;;
#   moddir=*)
#       BLD_MOD_PREFIX=`canonPath "${ARG}"`
#       ;;
    name=*)
        BLD_NAME="${ARG}"
        ;;
    prefix=*)
        BLD_BIN_PREFIX=`remapDir "$BLD_BIN_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_CFG_PREFIX=`remapDir "$BLD_CFG_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_DOC_PREFIX=`remapDir "$BLD_DOC_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_INC_PREFIX=`remapDir "$BLD_INC_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_JEM_PREFIX=`remapDir "$BLD_JEM_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_LIB_PREFIX=`remapDir "$BLD_LIB_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_MAN_PREFIX=`remapDir "$BLD_MAN_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_MOD_PREFIX=`remapDir "$BLD_MOD_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_PRD_PREFIX=`remapDir "$BLD_PRD_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_ROOT_PREFIX=`remapDir "$BLD_ROOT_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_SAM_PREFIX=`remapDir "$BLD_SAM_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_SRC_PREFIX=`remapDir "$BLD_SRC_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_VER_PREFIX=`remapDir "$BLD_VER_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_WEB_PREFIX=`remapDir "$BLD_WEB_PREFIX" "$BLD_PREFIX" "$ARG"`
        BLD_PREFIX=`canonPath "${ARG}"`
        ;;
    product=*)
        BLD_PRODUCT="${ARG}"
        ;;
    release)
        BLD_TYPE=RELEASE
        BLD_DEBUG=0
        ;;
    setVersion=*)
        BLD_VERSION="${ARG}"
        ;;
    silent)
        quiet=1
        ;;
    samdir=*)
        BLD_SAM_PREFIX=`canonPath "${ARG}"`
        ;;
    srcdir=*)
        BLD_SRC_PREFIX=`canonPath "${ARG}"`
        ;;
    sysconfdir=*)
        BLD_CFG_PREFIX=`remapDir "$BLD_CFG_PREFIX" "$BLD_SYSCONF_PREFIX" "$ARG"`
        BLD_SYSCONF_PREFIX=`canonPath "${ARG}"`
        ;;
    tune=*)
        BLD_TUNE=`upper ${ARG}`
        [ "$BLD_TUNE" = "SIZE" ] && BLD_TUNE=MPR_TUNE_SIZE
        [ "$BLD_TUNE" = "BALANCED" ] && BLD_TUNE=MPR_TUNE_BALANCED
        [ "$BLD_TUNE" = "SPEED" ] && BLD_TUNE=MPR_TUNE_SPEED
        if [ "$BLD_TUNE" != "MPR_TUNE_SIZE" -a "$BLD_TUNE" != "MPR_TUNE_BALANCED" \
                -a "$BLD_TUNE" != "MPR_TUNE_SPEED" ] ; then
            echo "configure: unknown --tune option: $ARG" >&2
            exit 2
        fi
        ;;
    type=*)
        BLD_TYPE="${ARG}"
        [ "$BLD_TYPE" = "debug" ] && BLD_TYPE=DEBUG
        [ "$BLD_TYPE" = "release" ] && BLD_TYPE=RELEASE
        if [ "$BLD_TYPE" != "DEBUG" -a "$BLD_TYPE" != "RELEASE" ] ; then
            echo "configure: unknown --type option: $ARG" >&2
            exit 2
        fi
        if [ "$BLD_TYPE" = "DEBUG" ] ; then
            BLD_DEBUG=1
        else
            BLD_DEBUG=0
        fi
        ;;
    webdir=*)
        BLD_WEB_PREFIX=`canonPath "${ARG}"`
        ;;
    with-*)
        name="${1#--*-}"
        if [ "${name#host-}" != "$name" ] ; then
            with --host "${name#host-}"
        elif [ "${name#build-}" != "$name" ] ; then
            with --build "${name#build-}"
        elif [ "${name#both-}" != "$name" ] ; then
            with "${name#both-}"
        else
            with --host "${1#--*-}"
        fi
        ;;
    without-*)
        without "${1#--*-}"
        ;;

    #
    #   Ignored but provided for compatibility with autoconf
    #
    bindir=*|libdir=*|libexecdir=*|moddir=*)
        ;;
    disable-nls|enable-nls)
        ;;
    exec-prefix=*|sbindir=*|sharedstatedir=*|localstatedir=*)
        ;;
    infodir=*|program-prefix=*|program-suffix=*|program-transform-name=*)
        ;;

    *)  
        parseArg "${1}"
        if [ $? != 0 ] ; then
            echo "configure: unknown option: $1" >&2
            exit 255
        fi
        ;;
    esac
    shift
done

if [ "$1" != "" ] ; then
    echo "configure: unknown option: $1" >&2
    exit 255
fi

applyDependencies
parseEnvVars
findComponents
manageFeatures
createBuildConfig
postGen
showBuildConfig

exit 0