yann@182: #!/bin/sh
yann@182: 
yann@1105: VERSION=$( cat .version )
yann@1105: DATE=$( date +%Y%m%d )
yann@182: 
yann@673: # All absolutely required tools, one per line to ease diff.
yann@673: # See function 'has_or_abort, below, for syntax
yann@673: #  - Hopefully, if gcc is present, then all associated tools will be
yann@673: #  - awk must be GNU awk
yann@673: #  - makeinfo for building docs, even if discarded later on
yann@673: #  - others obvious... :-/
yann@876: #
yann@876: # Format of a pattern to check for, one per line:
yann@1140: #   pattern := var_name : tool_pattern  OR  tool_pattern
yann@1140: #   tool_pattern := tool_test  OR  tool_pattern || tool_test
yann@1105: #   tool_test := tool=regexp OR tool
yann@1105: #   tool := basename of the tool  OR  absolute pathname to the tool
yann@1105: #   regexp := valid grep(1) extended regular expression, $( tool --version)
yann@1105: #             will be matched against this regexp.
yann@876: #
yann@1106: # In case a pattern list is given (eg foo || bar || buz), then tests are performed
yann@876: # from left to right, stopping at the first matching test (like the shell
yann@876: # would parse 'foo || bar || buz' ).
yann@876: #
yann@876: # Examples:
yann@1140: #    bash:bash=^GNU bash, version 3\.
yann@1140: #     - if ${bash} is set and non-null, does nothing
yann@1140: #     - else ensures that bash exists in the PATH, and that
yann@1140: #         "$( "$( which bash )" --version |head -n 1 )"
yann@876: #       matches the regexp '^GNU bash, version 3\.'
yann@1140: #       - if so, then sets bash="$( which bash )"
yann@1106: #    autoconf=(GNU Autoconf) || autoconf2.50
yann@1140: #     - does not look at an existing variable
yann@1140: #     - ensures that:
yann@1140: #         - 'autoconf' is to be found in the PATH, and that $( autoconf --version |head -n 1 )
yann@1105: #           matches the regexp '(GNU Autoconf)' (which btw is the signature of
yann@1105: #           autoconf >= 2.50),
yann@876: #       OR that:
yann@876: #         - 'autoconf2.50' is to be found in the PATH
yann@876: #
yann@673: TOOLS_TO_CHECK='
yann@1140: bash:bash=^GNU bash, version 3\.
yann@1106: cut
yann@1106: xargs
yann@1140: install:install=GNU coreutils
yann@1140: make:make=^GNU Make
yann@1105: gcc
yann@1140: awk:awk=^GNU Awk || gawk=^GNU Awk
yann@1105: bison
yann@1105: flex
yann@1105: makeinfo
yann@1106: automake=\(GNU automake\) (1\.[[:digit:]]{2,}\.|[2-9][[:digit:]]*\.)
yann@1106: libtool=\(GNU libtool\) (2[[:digit:]]*\.|1\.6[[:digit:]]*\.|1\.5\.[2-9][[:digit:]]+)
yann@1106: curl || wget
yann@1105: patch
yann@1105: tar
yann@1105: gzip
yann@1105: bzip2
yann@673: '
yann@673: 
yann@183: PREFIX_DEFAULT=/usr/local
yann@182: 
yann@182: BINDIR_set=
yann@182: LIBDIR_set=
yann@182: DOCDIR_set=
yann@182: MANDIR_set=
yann@285: LOCAL_set=
yann@182: 
yann@641: do_quit=
yann@614: 
yann@673: # Simply print the error message, and exit. Obvious, he?
yann@673: do_error() {
yann@673:     echo "${@}"
yann@673:     exit 1
yann@673: }
yann@673: 
yann@673: # A small function to test for existence of various tools
yann@876: # Usage: has_or_abort test_pattern (see top of file, TOOLS_TO_CHECK, for
yann@876: #                                   complete pattern format)
yann@673: has_or_abort() {
yann@1140:     local save_IFS
yann@1140:     local var_name
yann@1140:     local var_value
yann@1140:     local tool_pattern
yann@1140:     local field
yann@1140: 
yann@1140:     var_name="$( echo "${1}" |"${sed}" -r -e 's/^((([^=:]+):.+|[^:=]+)=.+|[^:=]+)$/\3/;' )"
yann@1140:     field="${var_name:+2}"
yann@1140:     field="${field:-1}"
yann@1140:     tool_pattern="$( echo "${1}" |cut -d : -f ${field}- |"${sed}" -r -e 's/ *\|\| */\n/g;' )"
yann@1140: 
yann@1105:     save_IFS="${IFS}"
yann@1140:     # Set IFS to \n only
yann@1106:     IFS='
yann@1106: '
yann@1106:     for item in ${tool_pattern}; do
yann@1105:         case "${item}" in
yann@1105:             *=*)
yann@1105:                 tool="${item%%=*}"
yann@1105:                 regexp="${item#*=}"
yann@1105:                 ;;
yann@1105:             *)  tool="${item}"
yann@1105:                 regexp=
yann@1105:                 ;;
yann@1105:         esac
yann@1140: 
yann@1105:         printf "Checking for '${tool}'... "
yann@1140:         if [ -n "${var_name}" ]; then
yann@1140:             eval var_value='"${'"${var_name}"'}"'
yann@1140:             if [ -n "${var_value}" ]; then
yann@1140:                 echo "${var_value} (cached)"
yann@1140:                 return 0
yann@1140:             fi
yann@1140:         fi
yann@1105:         where=$( which "${tool}" 2>/dev/null )
yann@1105:         if [ -z "${where}" ]; then
yann@1105:             echo "not found"
yann@1105:             where=
yann@1105:             continue
yann@1106:         elif [ -n "${regexp}" ]; then
yann@1106:             tool_version=$( ${tool} --version 2>&1 )
yann@1106:             str=$( echo "${tool_version}" |"${grep}" -E "${regexp}" |head -n 1 )
yann@1106:             if [ -z "${str}" ]; then
yann@1106:                 echo "not found"
yann@1106:                 where=""
yann@1106:                 continue
yann@1105:             fi
yann@1105:         fi
yann@1106:         break
yann@1140:     done
yann@1106:     if [ -z "${where}" ]; then
yann@1106:         for item in ${tool_pattern}; do
yann@1106:             case "${item}" in
yann@1106:                 *=*)
yann@1106:                     tool="${item%%=*}"
yann@1106:                     regexp="${item#*=}"
yann@1106:                     ;;
yann@1106:                 *)  tool="${item}"
yann@1106:                     regexp=
yann@1106:                     ;;
yann@1106:             esac
yann@1106:             echo "  could not find '${tool}' matching regexp '${regexp}'"
yann@1106:         done
yann@1106:         echo "Either you are missing entirely the needed tool,"
yann@1106:         echo "or the version you have is tool old."
yann@1132:         # FORCE can be set in the environment
yann@1132:         [ -z "${FORCE}" ] && do_error "Bailing out..."
yann@1140:     else
yann@1140:         echo "${where}"
yann@1140:         if [ -n "${var_name}" ]; then
yann@1140:             eval ${var_name}='"'"${where}"'"'
yann@1140:         fi
yann@1106:     fi
yann@1105:     IFS="${save_IFS}"
yann@673:     return 0
yann@673: }
yann@673: 
yann@641: # Given an option string and the following argument,
yann@641: # echoes the value of the option.
yann@641: # If --var=val => echoes val and returns 0, meaning second arg was not consumed
yann@641: # If --var val => echoes val and returns non null, meaning second arg was used
yann@182: get_optval(){
yann@182:     case "$1" in
yann@182:         --*=?*)
yann@1140:             echo "${1#*=}"
yann@1105:             return 0
yann@182:             ;;
yann@182:         *)
yann@182:             echo "${2}"
yann@1105:             return 1
yann@182:             ;;
yann@182:     esac
yann@182: }
yann@182: 
yann@641: # The set_xxx functions will set the corresponding configuration variable
yann@641: # They return 0 if second arg was not consumed, and non-zero if it was consumed.
yann@182: set_prefix() {
yann@1105:     PREFIX="$( get_optval "$1" "$2" )"
yann@182: }
yann@182: set_bindir() {
yann@376:     BINDIR_set=1
yann@1105:     BINDIR="$( get_optval "$1" "$2" )"
yann@182: }
yann@182: set_libdir() {
yann@376:     LIBDIR_set=1
yann@1105:     LIBDIR="$( get_optval "$1" "$2" )"
yann@182: }
yann@182: set_docdir() {
yann@376:     DOCDIR_set=1
yann@1105:     DOCDIR="$( get_optval "$1" "$2" )"
yann@182: }
yann@182: set_mandir() {
yann@376:     MANDIR_set=1
yann@1105:     MANDIR="$( get_optval "$1" "$2" )"
yann@182: }
yann@1140: set_tool() {
yann@1140:     local var_name="${1%%=*}"
yann@1140:     var_name="${var_name#--with-}"
yann@1140:     eval ${var_name}="\$( get_optval "$1" "$2" )"
yann@614: }
yann@614: 
yann@183: do_help() {
yann@183:     cat <<__EOF__
yann@1140: \`configure' configures crosstool-NG-${VERSION} to adapt to many kind of systems.
yann@183: 
yann@183: USAGE: ./configure [OPTION]...
yann@183: 
yann@183: Defaults for the options are specified in brackets.
yann@183: 
yann@183: Configuration:
yann@1105:   -h, --help              display this help and exit
yann@615: 
yann@615: Installation directories:
yann@185:   --prefix=PREFIX         install files in PREFIX [${PREFIX_DEFAULT}]
yann@285:   --local                 don't install, and use current directory
yann@183: 
yann@183: By default, \`make install' will install all the files in
yann@183: \`${PREFIX_DEFAULT}/bin', \`${PREFIX_DEFAULT}/lib' etc.  You can specify
yann@183: an installation prefix other than \`${PREFIX_DEFAULT}' using \`--prefix',
yann@183: for instance \`--prefix=\${HOME}'.
yann@183: 
yann@183: For better control, use the options below.
yann@183: 
yann@183: Fine tuning of the installation directories:
yann@683:   --bindir=DIR            user executables [PREFIX/bin]
yann@683:   --libdir=DIR            object code libraries [PREFIX/lib]
yann@683:   --docdir=DIR            info documentation [PREFIX/share/doc]
yann@683:   --mandir=DIR            man documentation [PREFIX/share/man]
yann@614: 
yann@614: Optional Features:
yann@1140:   --with-install=PATH     Specify the full PATH to GNU install
yann@1140:   --with-make=PATH        Specify the full PATH to GNU make
yann@1140:   --with-grep=PATH        Specify the full PATH to GNU grep
yann@1140:   --with-sed=PATH         Specify the full PATH to GNU sed
yann@1140:   --with-awk=PATH         Specify the full PATH to GNU awk
yann@1140:   --with-bash=PATH        Specify the full PATH to bash >= 3.0
yann@183: __EOF__
yann@183: }
yann@183: 
yann@376: #---------------------------------------------------------------------
yann@376: # Set user's options
yann@376: 
yann@182: while [ $# -ne 0 ]; do
yann@182:     case "$1" in
yann@1140:         --local)    LOCAL_set=1; shift;;
yann@182:         --prefix*)  set_prefix "$1" "$2" && shift || shift 2;;
yann@182:         --bindir*)  set_bindir "$1" "$2" && shift || shift 2;;
yann@182:         --libdir*)  set_libdir "$1" "$2" && shift || shift 2;;
yann@182:         --docdir*)  set_docdir "$1" "$2" && shift || shift 2;;
yann@182:         --mandir*)  set_mandir "$1" "$2" && shift || shift 2;;
yann@1140:         --with-*)   set_tool   "$1" "$2" && shift || shift 2;;
yann@183:         --help|-h)  do_help; exit 0;;
yann@1140:         *)          echo "Unrecognised option: '${1}'"; do_help; exit 1;;
yann@182:     esac
yann@182: done
yann@182: 
yann@641: # Use defaults
yann@185: [ -z "${PREFIX}" ] && set_prefix "" "${PREFIX_DEFAULT}"
yann@641: 
yann@641: # Special case when installing locally
yann@285: if [ "${LOCAL_set}" = "1" ]; then
yann@1105:     set_prefix "" "$( pwd )"
yann@1105:     set_bindir "" "$( pwd )"
yann@1105:     set_libdir "" "$( pwd )"
yann@1105:     set_docdir "" "$( pwd )/docs"
yann@1105:     set_mandir "" "$( pwd )/docs"
yann@285: fi
yann@183: 
yann@376: #---------------------------------------------------------------------
yann@1140: # Some sanity checks, now
yann@1106: 
yann@1140: # We check for grep and sed manually, because they are used in has_or_abort
yann@1140: printf "Checking for 'grep'... "
yann@1140: if [ -n "${grep}" ]; then
yann@1140:     echo "${grep} (cached)"
yann@1140: else
yann@1140:     grep="$( which grep 2>/dev/null )"
yann@1140:     [ -z "${grep}" ] && do_error "not found"
yann@1140:     echo "${grep}"
yann@1106: fi
yann@1140: printf "Checking whether '${grep}' supports -E... "
yann@1140: if echo 'foo' |"${grep}" -E 'foo' >/dev/null 2>&1; then
yann@1140:     echo "yes"
yann@1140: else
yann@1140:     do_error "no"
yann@1140: fi
yann@1140: 
yann@1140: printf "Checking for 'sed'... "
yann@1140: if [ -n "${sed}" ]; then
yann@1140:     echo "${sed} (cached)"
yann@1140: else
yann@1140:     sed="$( which sed 2>/dev/null )"
yann@1140:     [ -z "${sed}" ] && do_error "not found"
yann@1140:     echo "${sed}"
yann@1140: fi
yann@1140: printf "Checking wether '${sed}' supports -i and -e... "
yann@1140: touch .ct-ng.sed.test
yann@1140: if "${sed}" -r -i -e 's/foo/bar/' .ct-ng.sed.test >/dev/null 2>&1; then
yann@1140:     rm -f .ct-ng.sed.test
yann@1140:     echo "yes"
yann@1140: else
yann@1140:     rm -f .ct-ng.sed.test
yann@1140:     do_error "no"
yann@1140: fi
yann@1140: 
yann@1140: # Check the existence of absolutely required tools
yann@1140: save_IFS="${IFS}"
yann@1140: IFS='
yann@1140: '
yann@1140: for tool in ${TOOLS_TO_CHECK}; do
yann@1140:     has_or_abort "${tool}"
yann@1140: done
yann@1140: IFS="${save_IFS}"
yann@1106: 
yann@1106: #---------------------------------------------------------------------
yann@1106: # Compute the version string
yann@376: 
yann@435: # If this version is a svn snapshot, try to get the revision number
yann@435: # If we can't get the revision number, use date
yann@641: printf "Computing version string... "
yann@435: case "${VERSION}" in
yann@1105:     *+svn|svn)
yann@1105:         REVISION="$( LC_ALL=C svnversion )"
yann@1105:         case "${REVISION}" in
yann@1105:             exported)
yann@1105:                 VERSION="${VERSION}_unknown@$( date +%Y%m%d.%H%M%S )";;
yann@1105:             *)
yann@1105:                 URL="$( LC_ALL=C svn info 2>/dev/null   \
yann@1105:                                  |egrep 'URL: '         \
yann@1105:                                  |cut -d ' ' -f 2-      \
yann@1105:                       )"
yann@1106:                 ROOT="$( LC_ALL=C svn info 2>/dev/null      \
yann@1106:                          |"${grep}" '^Repository Root: '    \
yann@1106:                          |cut -d ' ' -f 3-                  \
yann@1105:                        )"
yann@1105:                 VERSION="${VERSION}${URL#${ROOT}}@${REVISION}"
yann@1105:                 ;;
yann@1105:         esac
yann@1105:         # Arrange to have no / in the directory name, no need to create an
yann@1105:         # arbitrarily deep directory structure
yann@1106:         VERSION="$( echo "${VERSION}" |"${sed}" -r -e 's|/+|_|g;' )"
yann@444:         ;;
yann@435: esac
yann@553: echo "${VERSION}"
yann@435: 
yann@1106: #---------------------------------------------------------------------
yann@1106: # Compute and check install paths
yann@1106: 
yann@614: # Now we have the version string, we can build up the paths
yann@554: [ -z "${BINDIR_set}" ] && BINDIR="${PREFIX}/bin"
yann@554: [ -z "${LIBDIR_set}" ] && LIBDIR="${PREFIX}/lib/ct-ng-${VERSION}"
yann@554: [ -z "${DOCDIR_set}" ] && DOCDIR="${PREFIX}/share/doc/ct-ng-${VERSION}"
yann@554: [ -z "${MANDIR_set}" ] && MANDIR="${PREFIX}/share/man/man1"
yann@554: 
yann@1047: # Check that install PATHs are absolute
yann@1047: for p in BIN LIB DOC MAN; do
yann@1105:     var="${p}DIR"
yann@1105:     eval v='"${'"${var}"'}"'
yann@1105:     case "${v}" in
yann@1105:         /*) ;;
yann@1105:         *)  do_error "'${var}' is not an absolute path: '${v}'"
yann@1105:     esac
yann@1047: done
yann@1047: 
yann@1106: #---------------------------------------------------------------------
yann@1106: # That's all, folks!
yann@614: 
yann@641: printf "Building up Makefile... "
yann@1140: var_list="grep
yann@1140:           sed
yann@1140:           $( printf "${TOOLS_TO_CHECK}"                                 \
yann@1140:              |"${sed}" -r -e 's/^((([^=:]+):.+|[^:=]+)=.+|[^:=]+)$/\3/;'
yann@1140:            )"
yann@1140: var_sed="$( for var_name in ${var_list}; do
yann@1140:                 eval echo 's,@@${var_name}@@,${'"${var_name}"'},g'
yann@1140:             done 
yann@1140:           )"
yann@1106: "${sed}" -r -e "s,@@BINDIR@@,${BINDIR},g
yann@1106:                 s,@@LIBDIR@@,${LIBDIR},g
yann@1106:                 s,@@DOCDIR@@,${DOCDIR},g
yann@1106:                 s,@@MANDIR@@,${MANDIR},g
yann@1106:                 s,@@VERSION@@,${VERSION},g
yann@1106:                 s,@@DATE@@,${DATE},g
yann@1140:                 ${var_sed}
yann@1106:                 s,@@LOCAL@@,${LOCAL_set},g"  Makefile.in >Makefile
yann@673: echo "done"
yann@185: 
yann@185: cat <<__EOF__
yann@673: 
yann@197: crosstool-NG configured as follows:
yann@554:   PREFIX='${PREFIX}'
yann@554:   BINDIR='${BINDIR}'
yann@554:   LIBDIR='${LIBDIR}'
yann@554:   DOCDIR='${DOCDIR}'
yann@554:   MANDIR='${MANDIR}'
yann@1106: 
yann@1106: Now run:
yann@1106:   make
yann@1106:   make install
yann@185: __EOF__