crosstool-ng: configure@12926229102b

     1 #!/bin/sh

     3 VERSION=$( cat .version )

     4 DATE=$( date +%Y%m%d )

     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 '

    61 PREFIX_DEFAULT=/usr/local

    63 BINDIR_set=

    64 LIBDIR_set=

    65 DOCDIR_set=

    66 MANDIR_set=

    67 LOCAL_set=

    69 do_quit=

    71 # Simply print the error message, and exit. Obvious, he?

    72 do_error() {

    73     echo "${@}"

    74     exit 1

    75 }

    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

    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;' )"

    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

   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 }

   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 }

   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 }

   207 do_help() {

   208     cat <<__EOF__

   209 \`configure' configures crosstool-NG-${VERSION} to adapt to many kind of systems.

   211 USAGE: ./configure [OPTION]...

   213 Defaults for the options are specified in brackets.

   215 Configuration:

   216   -h, --help              display this help and exit

   218 Installation directories:

   219   --prefix=PREFIX         install files in PREFIX [${PREFIX_DEFAULT}]

   220   --local                 don't install, and use current directory

   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}'.

   227 For better control, use the options below.

   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]

   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 }

   245 #---------------------------------------------------------------------

   246 # Set user's options

   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

   262 # Use defaults

   263 [ -z "${PREFIX}" ] && set_prefix "" "${PREFIX_DEFAULT}"

   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

   274 #---------------------------------------------------------------------

   275 # Some sanity checks, now

   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

   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

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

   320 #---------------------------------------------------------------------

   321 # Compute the version string

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

   351 #---------------------------------------------------------------------

   352 # Compute and check install paths

   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"

   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

   370 #---------------------------------------------------------------------

   371 # That's all, folks!

   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"

   393 cat <<__EOF__

   395 crosstool-NG configured as follows:

   396   PREFIX='${PREFIX}'

   397   BINDIR='${BINDIR}'

   398   LIBDIR='${LIBDIR}'

   399   DOCDIR='${DOCDIR}'

   400   MANDIR='${MANDIR}'

   402 Now run:

   403   make

   404   make install

   405 __EOF__

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Tue Jan 27 21:36:18 2009 +0000 (2009-01-27)
changeset 1161	12926229102b
parent 1140	6bdb31785d6c
child 1187	3a76b3242ed8
permissions	-rwxr-xr-x