configure
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Thu Jan 29 22:09:55 2009 +0000 (2009-01-29)
changeset 1176 8508ec77df4c
parent 1140 6bdb31785d6c
child 1187 3a76b3242ed8
permissions -rwxr-xr-x
If compiling the Java frontend, we'll require a native gcj, but only in this case.

/trunk/scripts/crosstool-NG.sh.in | 8 7 1 0 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
     1 #!/bin/sh
     2 
     3 VERSION=$( cat .version )
     4 DATE=$( date +%Y%m%d )
     5 
     6 # All absolutely required tools, one per line to ease diff.
     7 # See function 'has_or_abort, below, for syntax
     8 #  - Hopefully, if gcc is present, then all associated tools will be
     9 #  - awk must be GNU awk
    10 #  - makeinfo for building docs, even if discarded later on
    11 #  - others obvious... :-/
    12 #
    13 # Format of a pattern to check for, one per line:
    14 #   pattern := var_name : tool_pattern  OR  tool_pattern
    15 #   tool_pattern := tool_test  OR  tool_pattern || tool_test
    16 #   tool_test := tool=regexp OR tool
    17 #   tool := basename of the tool  OR  absolute pathname to the tool
    18 #   regexp := valid grep(1) extended regular expression, $( tool --version)
    19 #             will be matched against this regexp.
    20 #
    21 # In case a pattern list is given (eg foo || bar || buz), then tests are performed
    22 # from left to right, stopping at the first matching test (like the shell
    23 # would parse 'foo || bar || buz' ).
    24 #
    25 # Examples:
    26 #    bash:bash=^GNU bash, version 3\.
    27 #     - if ${bash} is set and non-null, does nothing
    28 #     - else ensures that bash exists in the PATH, and that
    29 #         "$( "$( which bash )" --version |head -n 1 )"
    30 #       matches the regexp '^GNU bash, version 3\.'
    31 #       - if so, then sets bash="$( which bash )"
    32 #    autoconf=(GNU Autoconf) || autoconf2.50
    33 #     - does not look at an existing variable
    34 #     - ensures that:
    35 #         - 'autoconf' is to be found in the PATH, and that $( autoconf --version |head -n 1 )
    36 #           matches the regexp '(GNU Autoconf)' (which btw is the signature of
    37 #           autoconf >= 2.50),
    38 #       OR that:
    39 #         - 'autoconf2.50' is to be found in the PATH
    40 #
    41 TOOLS_TO_CHECK='
    42 bash:bash=^GNU bash, version 3\.
    43 cut
    44 xargs
    45 install:install=GNU coreutils
    46 make:make=^GNU Make
    47 gcc
    48 awk:awk=^GNU Awk || gawk=^GNU Awk
    49 bison
    50 flex
    51 makeinfo
    52 automake=\(GNU automake\) (1\.[[:digit:]]{2,}\.|[2-9][[:digit:]]*\.)
    53 libtool=\(GNU libtool\) (2[[:digit:]]*\.|1\.6[[:digit:]]*\.|1\.5\.[2-9][[:digit:]]+)
    54 curl || wget
    55 patch
    56 tar
    57 gzip
    58 bzip2
    59 '
    60 
    61 PREFIX_DEFAULT=/usr/local
    62 
    63 BINDIR_set=
    64 LIBDIR_set=
    65 DOCDIR_set=
    66 MANDIR_set=
    67 LOCAL_set=
    68 
    69 do_quit=
    70 
    71 # Simply print the error message, and exit. Obvious, he?
    72 do_error() {
    73     echo "${@}"
    74     exit 1
    75 }
    76 
    77 # A small function to test for existence of various tools
    78 # Usage: has_or_abort test_pattern (see top of file, TOOLS_TO_CHECK, for
    79 #                                   complete pattern format)
    80 has_or_abort() {
    81     local save_IFS
    82     local var_name
    83     local var_value
    84     local tool_pattern
    85     local field
    86 
    87     var_name="$( echo "${1}" |"${sed}" -r -e 's/^(([^=:]+):.+|[^:=]+=.+|[^:=]+)$/\2/;' )"
    88     field="${var_name:+2}"
    89     field="${field:-1}"
    90     tool_pattern="$( echo "${1}" |cut -d : -f ${field}- |"${sed}" -r -e 's/ *\|\| */\n/g;' )"
    91 
    92     save_IFS="${IFS}"
    93     # Set IFS to \n only
    94     IFS='
    95 '
    96     for item in ${tool_pattern}; do
    97         case "${item}" in
    98             *=*)
    99                 tool="${item%%=*}"
   100                 regexp="${item#*=}"
   101                 ;;
   102             *)  tool="${item}"
   103                 regexp=
   104                 ;;
   105         esac
   106 
   107         printf "Checking for '${tool}'... "
   108         if [ -n "${var_name}" ]; then
   109             eval var_value='"${'"${var_name}"'}"'
   110             if [ -n "${var_value}" ]; then
   111                 echo "${var_value} (cached)"
   112                 return 0
   113             fi
   114         fi
   115         where=$( which "${tool}" 2>/dev/null )
   116         if [ -z "${where}" ]; then
   117             echo "not found"
   118             where=
   119             continue
   120         elif [ -n "${regexp}" ]; then
   121             tool_version=$( ${tool} --version 2>&1 )
   122             str=$( echo "${tool_version}" |"${grep}" -E "${regexp}" |head -n 1 )
   123             if [ -z "${str}" ]; then
   124                 echo "not found"
   125                 where=""
   126                 continue
   127             fi
   128         fi
   129         break
   130     done
   131     if [ -z "${where}" ]; then
   132         for item in ${tool_pattern}; do
   133             case "${item}" in
   134                 *=*)
   135                     tool="${item%%=*}"
   136                     regexp="${item#*=}"
   137                     ;;
   138                 *)  tool="${item}"
   139                     regexp=
   140                     ;;
   141             esac
   142             printf "  could not find '${tool}'"
   143             [ -n "${regexp}" ] && printf " matching regexp '${regexp}'"
   144             echo
   145         done
   146         echo "Either you are missing entirely the needed tool,"
   147         echo "or the version you have is tool old."
   148         if [ -n "${var_name}" ]; then
   149             echo "You can give the path to this tool using: --with-${var_name}=PATH"
   150         fi
   151         # FORCE can be set in the environment
   152         [ -z "${FORCE}" ] && do_error "Bailing out..."
   153     else
   154         echo "${where}"
   155         if [ -n "${var_name}" ]; then
   156             eval ${var_name}='"'"${where}"'"'
   157         fi
   158     fi
   159     IFS="${save_IFS}"
   160     return 0
   161 }
   162 
   163 # Given an option string and the following argument,
   164 # echoes the value of the option.
   165 # If --var=val => echoes val and returns 0, meaning second arg was not consumed
   166 # If --var val => echoes val and returns non null, meaning second arg was used
   167 get_optval(){
   168     case "$1" in
   169         --*=?*)
   170             echo "${1#*=}"
   171             return 0
   172             ;;
   173         *)
   174             echo "${2}"
   175             return 1
   176             ;;
   177     esac
   178 }
   179 
   180 # The set_xxx functions will set the corresponding configuration variable
   181 # They return 0 if second arg was not consumed, and non-zero if it was consumed.
   182 set_prefix() {
   183     PREFIX="$( get_optval "$1" "$2" )"
   184 }
   185 set_bindir() {
   186     BINDIR_set=1
   187     BINDIR="$( get_optval "$1" "$2" )"
   188 }
   189 set_libdir() {
   190     LIBDIR_set=1
   191     LIBDIR="$( get_optval "$1" "$2" )"
   192 }
   193 set_docdir() {
   194     DOCDIR_set=1
   195     DOCDIR="$( get_optval "$1" "$2" )"
   196 }
   197 set_mandir() {
   198     MANDIR_set=1
   199     MANDIR="$( get_optval "$1" "$2" )"
   200 }
   201 set_tool() {
   202     local var_name="${1%%=*}"
   203     var_name="${var_name#--with-}"
   204     eval ${var_name}="\$( get_optval "$1" "$2" )"
   205 }
   206 
   207 do_help() {
   208     cat <<__EOF__
   209 \`configure' configures crosstool-NG-${VERSION} to adapt to many kind of systems.
   210 
   211 USAGE: ./configure [OPTION]...
   212 
   213 Defaults for the options are specified in brackets.
   214 
   215 Configuration:
   216   -h, --help              display this help and exit
   217 
   218 Installation directories:
   219   --prefix=PREFIX         install files in PREFIX [${PREFIX_DEFAULT}]
   220   --local                 don't install, and use current directory
   221 
   222 By default, \`make install' will install all the files in
   223 \`${PREFIX_DEFAULT}/bin', \`${PREFIX_DEFAULT}/lib' etc.  You can specify
   224 an installation prefix other than \`${PREFIX_DEFAULT}' using \`--prefix',
   225 for instance \`--prefix=\${HOME}'.
   226 
   227 For better control, use the options below.
   228 
   229 Fine tuning of the installation directories:
   230   --bindir=DIR            user executables [PREFIX/bin]
   231   --libdir=DIR            object code libraries [PREFIX/lib]
   232   --docdir=DIR            info documentation [PREFIX/share/doc]
   233   --mandir=DIR            man documentation [PREFIX/share/man]
   234 
   235 Optional Features:
   236   --with-install=PATH     Specify the full PATH to GNU install
   237   --with-make=PATH        Specify the full PATH to GNU make
   238   --with-grep=PATH        Specify the full PATH to GNU grep
   239   --with-sed=PATH         Specify the full PATH to GNU sed
   240   --with-awk=PATH         Specify the full PATH to GNU awk
   241   --with-bash=PATH        Specify the full PATH to bash >= 3.0
   242 __EOF__
   243 }
   244 
   245 #---------------------------------------------------------------------
   246 # Set user's options
   247 
   248 while [ $# -ne 0 ]; do
   249     case "$1" in
   250         --local)    LOCAL_set=1; shift;;
   251         --prefix*)  set_prefix "$1" "$2" && shift || shift 2;;
   252         --bindir*)  set_bindir "$1" "$2" && shift || shift 2;;
   253         --libdir*)  set_libdir "$1" "$2" && shift || shift 2;;
   254         --docdir*)  set_docdir "$1" "$2" && shift || shift 2;;
   255         --mandir*)  set_mandir "$1" "$2" && shift || shift 2;;
   256         --with-*)   set_tool   "$1" "$2" && shift || shift 2;;
   257         --help|-h)  do_help; exit 0;;
   258         *)          echo "Unrecognised option: '${1}'"; do_help; exit 1;;
   259     esac
   260 done
   261 
   262 # Use defaults
   263 [ -z "${PREFIX}" ] && set_prefix "" "${PREFIX_DEFAULT}"
   264 
   265 # Special case when installing locally
   266 if [ "${LOCAL_set}" = "1" ]; then
   267     set_prefix "" "$( pwd )"
   268     set_bindir "" "$( pwd )"
   269     set_libdir "" "$( pwd )"
   270     set_docdir "" "$( pwd )/docs"
   271     set_mandir "" "$( pwd )/docs"
   272 fi
   273 
   274 #---------------------------------------------------------------------
   275 # Some sanity checks, now
   276 
   277 # We check for grep and sed manually, because they are used in has_or_abort
   278 printf "Checking for 'grep'... "
   279 if [ -n "${grep}" ]; then
   280     echo "${grep} (cached)"
   281 else
   282     grep="$( which grep 2>/dev/null )"
   283     [ -z "${grep}" ] && do_error "not found"
   284     echo "${grep}"
   285 fi
   286 printf "Checking whether '${grep}' supports -E... "
   287 if echo 'foo' |"${grep}" -E 'foo' >/dev/null 2>&1; then
   288     echo "yes"
   289 else
   290     do_error "no"
   291 fi
   292 
   293 printf "Checking for 'sed'... "
   294 if [ -n "${sed}" ]; then
   295     echo "${sed} (cached)"
   296 else
   297     sed="$( which sed 2>/dev/null )"
   298     [ -z "${sed}" ] && do_error "not found"
   299     echo "${sed}"
   300 fi
   301 printf "Checking wether '${sed}' supports -i and -e... "
   302 touch .ct-ng.sed.test
   303 if "${sed}" -r -i -e 's/foo/bar/' .ct-ng.sed.test >/dev/null 2>&1; then
   304     rm -f .ct-ng.sed.test
   305     echo "yes"
   306 else
   307     rm -f .ct-ng.sed.test
   308     do_error "no"
   309 fi
   310 
   311 # Check the existence of absolutely required tools
   312 save_IFS="${IFS}"
   313 IFS='
   314 '
   315 for tool in ${TOOLS_TO_CHECK}; do
   316     has_or_abort "${tool}"
   317 done
   318 IFS="${save_IFS}"
   319 
   320 #---------------------------------------------------------------------
   321 # Compute the version string
   322 
   323 # If this version is a svn snapshot, try to get the revision number
   324 # If we can't get the revision number, use date
   325 printf "Computing version string... "
   326 case "${VERSION}" in
   327     *+svn|svn)
   328         REVISION="$( LC_ALL=C svnversion )"
   329         case "${REVISION}" in
   330             exported)
   331                 VERSION="${VERSION}_unknown@$( date +%Y%m%d.%H%M%S )";;
   332             *)
   333                 URL="$( LC_ALL=C svn info 2>/dev/null   \
   334                                  |egrep 'URL: '         \
   335                                  |cut -d ' ' -f 2-      \
   336                       )"
   337                 ROOT="$( LC_ALL=C svn info 2>/dev/null      \
   338                          |"${grep}" '^Repository Root: '    \
   339                          |cut -d ' ' -f 3-                  \
   340                        )"
   341                 VERSION="${VERSION}${URL#${ROOT}}@${REVISION}"
   342                 ;;
   343         esac
   344         # Arrange to have no / in the directory name, no need to create an
   345         # arbitrarily deep directory structure
   346         VERSION="$( echo "${VERSION}" |"${sed}" -r -e 's|/+|_|g;' )"
   347         ;;
   348 esac
   349 echo "${VERSION}"
   350 
   351 #---------------------------------------------------------------------
   352 # Compute and check install paths
   353 
   354 # Now we have the version string, we can build up the paths
   355 [ -z "${BINDIR_set}" ] && BINDIR="${PREFIX}/bin"
   356 [ -z "${LIBDIR_set}" ] && LIBDIR="${PREFIX}/lib/ct-ng-${VERSION}"
   357 [ -z "${DOCDIR_set}" ] && DOCDIR="${PREFIX}/share/doc/ct-ng-${VERSION}"
   358 [ -z "${MANDIR_set}" ] && MANDIR="${PREFIX}/share/man/man1"
   359 
   360 # Check that install PATHs are absolute
   361 for p in BIN LIB DOC MAN; do
   362     var="${p}DIR"
   363     eval v='"${'"${var}"'}"'
   364     case "${v}" in
   365         /*) ;;
   366         *)  do_error "'${var}' is not an absolute path: '${v}'"
   367     esac
   368 done
   369 
   370 #---------------------------------------------------------------------
   371 # That's all, folks!
   372 
   373 printf "Building up Makefile... "
   374 var_list="grep
   375           sed
   376           $( printf "${TOOLS_TO_CHECK}"                                 \
   377              |"${sed}" -r -e 's/^(([^=:]+):.+|[^:=]+=.+|[^:=]+)$/\2/;'
   378            )"
   379 var_sed="$( for var_name in ${var_list}; do
   380                 eval echo 's,@@${var_name}@@,${'"${var_name}"'},g'
   381             done 
   382           )"
   383 "${sed}" -r -e "s,@@BINDIR@@,${BINDIR},g
   384                 s,@@LIBDIR@@,${LIBDIR},g
   385                 s,@@DOCDIR@@,${DOCDIR},g
   386                 s,@@MANDIR@@,${MANDIR},g
   387                 s,@@VERSION@@,${VERSION},g
   388                 s,@@DATE@@,${DATE},g
   389                 ${var_sed}
   390                 s,@@LOCAL@@,${LOCAL_set},g"  Makefile.in >Makefile
   391 echo "done"
   392 
   393 cat <<__EOF__
   394 
   395 crosstool-NG configured as follows:
   396   PREFIX='${PREFIX}'
   397   BINDIR='${BINDIR}'
   398   LIBDIR='${LIBDIR}'
   399   DOCDIR='${DOCDIR}'
   400   MANDIR='${MANDIR}'
   401 
   402 Now run:
   403   make
   404   make install
   405 __EOF__