crosstool-ng: configure@a65f56df62de

     1 #!/bin/sh

     3 myname="${0##*/}"

     5 VERSION=$( cat .version )

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

     8 PREFIX_DEFAULT=/usr/local

    10 BINDIR_set=

    11 LIBDIR_set=

    12 DOCDIR_set=

    13 MANDIR_set=

    14 LOCAL_set=

    15 FORCE=

    17 do_quit=

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

    20 do_error() {

    21     printf "${myname}: ${@}\n"

    22     exit 1

    23 }

    25 # Given an option string and the following argument,

    26 # echoes the value of the option.

    27 # If --var=val => echoes val and returns 0, meaning second arg was not consumed

    28 # If --var val => echoes val and returns non null, meaning second arg was used

    29 get_optval(){

    30     case "$1" in

    31         --*=?*)

    32             printf "${1#*=}"

    33             return 0

    34             ;;

    35         *)

    36             printf "${2}"

    37             return 1

    38             ;;

    39     esac

    40 }

    42 # The set_xxx functions will set the corresponding configuration variable

    43 # They return 0 if second arg was not consumed, and non-zero if it was consumed.

    44 set_prefix() {

    45     PREFIX="$( get_optval "$1" "$2" )"

    46 }

    47 set_bindir() {

    48     BINDIR_set=1

    49     BINDIR="$( get_optval "$1" "$2" )"

    50 }

    51 set_libdir() {

    52     LIBDIR_set=1

    53     LIBDIR="$( get_optval "$1" "$2" )"

    54 }

    55 set_docdir() {

    56     DOCDIR_set=1

    57     DOCDIR="$( get_optval "$1" "$2" )"

    58 }

    59 set_mandir() {

    60     MANDIR_set=1

    61     MANDIR="$( get_optval "$1" "$2" )"

    62 }

    63 set_tool() {

    64     local var_name="${1%%=*}"

    65     var_name="${var_name#--with-}"

    66     eval ${var_name}="\$( get_optval "$1" "$2" )"

    67 }

    69 # var_list is a list of variables, each one holding a path to a

    70 # tool, either detected by ./configure, or specified by the user.

    71 var_list=""

    72 kconfig_list=""

    74 # This function adds a variable name to the above list of variable names.

    75 # $1: the name of the variable to add to the list

    76 add_to_var_list() {

    77     local v

    78     for v in ${var_list}; do

    79         [ "${v}" = "${1}" ] && return 0

    80     done

    81     var_list="${var_list} ${1}"

    82 }

    83 add_to_kconfig_list() {

    84     local k

    85     for k in ${kconfig_list}; do

    86         [ "${k}" = "${1}" ] && return 0

    87     done

    88     kconfig_list="${kconfig_list} ${1}"

    89 }

    91 # A function to test for required tools/headers/libraries

    92 # Return 0 (true) if found, !0 (false) if not found

    93 #

    94 # $*: [prog|inc|lib]=<name[ name...]>

    95 #     the name(s) of tool(s) to test for

    96 #     mandatory

    97 #       eg: prog=bash   prog="curl wget"

    98 # $*: var=<var_name>

    99 #     the name of the variable to test and set

   100 #     optional

   101 #       eg: var=bash    if ${bash} is set and non-null, use that,

   102 #                       else check for bash and set bash=$(which bash)

   103 # $*: ver=<regexp>

   104 #     for each 'prog', test if $(prog --version) matches 'regexp'

   105 #     optional

   106 #       eg: ver='^GNU bash, version [34]\.'

   107 # $*: lib_exts=<extension[ extension...]>

   108 #     the list of allowed library extension

   109 #     mandatory

   110 #       eg: lib_exts="so dylib"     lib_exts="so dylib a"

   111 # $*: err=<error_message>

   112 #     the error message to print if tool is missing

   113 #     optional, defaults to: '${prog}: none found'

   114 #       eg: err="'bash' 3.x or above was not found"

   115 #     Note: err may be printed by caller, not us

   116 # $*: kconfig=<var_name>

   117 #     the name of a variable to pass down to kconfig if

   118 #     the prog/inc/lib was found

   119 #     optional, defaults to none

   120 #       eg: kconfig=has_libncurses

   121 check_for() {

   122     local lib_exts

   123     local val

   124     local item

   125     local where

   126     local status

   127     local ext

   129     # Note: prog/inc/lib and var/kconfig/ver/err are set here,

   130     # but declared by the caller (because it needs it)

   131     for item in "${@}"; do

   132         case "${item}" in

   133             prog=*|inc=*|lib=*|var=*|ver=*|err=*|kconfig=*|lib_exts=*)

   134                 eval ${item%%=*}=\"${item#*=}\"

   135                 ;;

   136             *)  do_error "check_for: incorrect parameters: '${item}'";;

   137         esac

   138     done

   140     case "${prog}:${inc}:${lib}" in

   141         ?*:?*:|?*::?*|:?*:?*|?*:?*:?*)

   142             if [ -n "${var}" ]; then

   143                 do_error "check_for: the use of var is not compatible with passing several of [prog|inc|lib] at once"

   144             fi

   145             ;;

   146         ::) do_error "check_for: [prog|inc|lib] is mandatory";;

   147     esac

   149     if [ -n "${kconfig}" ]; then

   150         add_to_kconfig_list "${kconfig}"

   151     fi

   153     if [ -n "${prog}" ]; then

   154         for item in ${prog}; do

   155             printf "Checking for '${item}'... "

   156             if [ -n "${var}" ]; then

   157                 eval val="\${${var}}"

   158                 if [ -n "${val}" ]; then

   159                     printf "${val} (cached)\n"

   160                     add_to_var_list "${var}"

   161                     return 0

   162                 fi

   163             fi

   164             where="$( which "${item}" 2>/dev/null )"

   165             if [ -z "${where}" ]; then

   166                 printf "no\n"

   167                 continue

   168             elif [ -n "${ver}" ]; then

   169                 str=$( LC_ALL=C "${where}" --version 2>&1   \

   170                        |grep -E "${ver}"                    \

   171                        |head -n 1

   172                      )

   173                 if [ -z "${str}" ]; then

   174                     printf "no\n"

   175                     unset where

   176                     continue

   177                 fi

   178             fi

   179             status="${where}"

   180             break

   181         done

   182         if [ -z "${status}" ]; then

   183             return 1

   184         fi

   185         printf "${status}\n"

   186         unset status

   187     fi

   189     if [ -n "${inc}" ]; then

   190         for item in ${inc}; do

   191             printf "Checking for '${item}'... "

   192             if printf "#include \"${item}\"" |gcc -x c -c - -o /dev/null >/dev/null 2>&1; then

   193                 where="${item}"

   194                 status=yes

   195                 break;

   196             fi

   197             printf "no\n"

   198         done

   199         if [ -z "${status}" ]; then

   200             return 1

   201         fi

   202         printf "${status}\n"

   203         unset status

   204     fi

   206     if [ -n "${lib}" ]; then

   207         if [ -z "${lib_exts}" ]; then

   208             do_error "check_for: no library extension specified for '${lib}'"

   209         fi

   210         for item in ${lib}; do

   211             for ext in ${lib_exts}; do

   212                 printf "Checking for '${item}.${ext}'... "

   213                 where="$( gcc -print-file-name="${item}.${ext}" )"

   214                 if [ "${where}" != "${item}.${ext}" ]; then

   215                     where="$( readlink "${where}" )"

   216                     status=yes

   217                     break 2;

   218                 fi

   219                 printf "no\n"

   220             done

   221         done

   222         if [ -z "${status}" ]; then

   223             return 1

   224         fi

   225         printf "${status}\n"

   226         unset status

   227     fi

   229     if [ -n "${var}" ]; then

   230         eval ${var}='"'"${where}"'"'

   231         add_to_var_list "${var}"

   232     fi

   233     if [ -n "${kconfig}" ]; then

   234         eval ${kconfig}=y

   235     fi

   236 }

   238 # This function checks for a tool, and aborts if not found

   239 # See check_for(), above, for how to call has_or_abort

   240 has_or_abort() {

   241     # We declare these 6 variables here, although they are

   242     # set in check_for(), called below

   243     local prog inc lib

   244     local var ver err kconfig

   246     if ! check_for "$@"; then

   247         printf " * A mandatory dependency is missing, or version mis-match:\n"

   248         printf " * - ${err:-${prog}${inc}${lib}: none found}\n"

   249         if [ -n "${var}" ]; then

   250             printf " * --> You can give the path to this tool using: --with-${var}=PATH\n"

   251         fi

   252         printf "\n"

   253         # Bail out if --force is not specified

   254         [ -z "${FORCE}" ] && do_error "Bailing out..."

   255         printf "<*                                          *>\n"

   256         printf "<*            FORCE in action:              *>\n"

   257         printf "<* Continuing despite missing pre-requisite *>\n"

   258         printf "<*          Prepare for breakage            *>\n"

   259         printf "<*                                          *>\n"

   260         printf "\n"

   261     fi

   262 }

   264 # This function checks for a tool, and warns if not found

   265 # See check_for(), above, for how to call has_or_abort

   266 # Note: if err is not set, then no error message is printed

   267 has_or_warn() {

   268     # We declare these 6 variables here, although they are

   269     # set in check_for(), called below

   270     local prog inc lib

   271     local var ver err kconfig

   273     if ! check_for "$@"; then

   274         printf " * An optional dependency is missing, some features will be disabled"

   275         printf "${err:+:\n * - ${err}}\n"

   276         if [ -n "${var}" ]; then

   277             printf " * --> You can give the path to this tool using: --with-${var}=PATH\n"

   278         fi

   279     fi

   280 }

   282 do_help() {

   283     cat <<__EOF__

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

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

   288 Defaults for the options are specified in brackets.

   290 Configuration:

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

   292       --force             force configure to continue, even in case

   293                           some pre-requisites are missing

   295 Installation directories:

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

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

   299 By default, \`make install' will install all the files in

   300 \`${PREFIX_DEFAULT}/bin', \`${PREFIX_DEFAULT}/lib' etc.  You can specify

   301 an installation prefix other than \`${PREFIX_DEFAULT}' using \`--prefix',

   302 for instance \`--prefix=\${HOME}'.

   304 For better control, use the options below.

   306 Fine tuning of the installation directories:

   307   --bindir=DIR            user executables [PREFIX/bin]

   308   --libdir=DIR            object code libraries [PREFIX/lib]

   309   --docdir=DIR            info documentation [PREFIX/share/doc]

   310   --mandir=DIR            man documentation [PREFIX/share/man]

   312 Optional Features:

   313   --with-install=PATH     Specify the full PATH to GNU install

   314   --with-make=PATH        Specify the full PATH to GNU make >= 3.80

   315   --with-grep=PATH        Specify the full PATH to GNU grep

   316   --with-sed=PATH         Specify the full PATH to GNU sed

   317   --with-bash=PATH        Specify the full PATH to bash >= 3.0

   318 __EOF__

   319 }

   321 #---------------------------------------------------------------------

   322 # Set user's options

   324 while [ $# -ne 0 ]; do

   325     case "$1" in

   326         --local)    LOCAL_set="y"; shift;;

   327         --prefix*)  set_prefix "$1" "$2" && shift || shift 2;;

   328         --bindir*)  set_bindir "$1" "$2" && shift || shift 2;;

   329         --libdir*)  set_libdir "$1" "$2" && shift || shift 2;;

   330         --docdir*)  set_docdir "$1" "$2" && shift || shift 2;;

   331         --mandir*)  set_mandir "$1" "$2" && shift || shift 2;;

   332         --with-*)   set_tool   "$1" "$2" && shift || shift 2;;

   333         --force)    FORCE=1; shift;;

   334         --help|-h)  do_help; exit 0;;

   335         # Skip, auto-stuff compatibility

   336         --build=*|--host=*|--infodir=*|--datadir=*|--sysconfdir=*|--localstatedir=*) shift;;

   337         --build|--host|--infodir|--datadir|--sysconfdir|--localstatedir)             shift 2;;

   338         *)          printf "Unrecognised option: '${1}'\n"; do_help; exit 1;;

   339     esac

   340 done

   342 # Use defaults

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

   345 # Special case when installing locally

   346 if [ "${LOCAL_set}" = "y" ]; then

   347     set_prefix "" "$( pwd )"

   348     set_bindir "" "$( pwd )"

   349     set_libdir "" "$( pwd )"

   350     set_docdir "" "$( pwd )/docs"

   351     set_mandir "" "$( pwd )/docs"

   352 fi

   354 #---------------------------------------------------------------------

   355 # Some sanity checks, now

   357 # We check for grep and sed manually, because they are used in check_for()

   358 printf "Checking for 'grep'... "

   359 if [ -n "${grep}" ]; then

   360     printf "${grep} (cached)\n"

   361 else

   362     grep="$( which grep 2>/dev/null )"

   363     if [ -z "${grep}" ]; then

   364         printf "not found\n"

   365     else

   366         printf "${grep}\n"

   367         printf "Checking whether '${grep}' supports -E... "

   368         if echo 'foo' |"${grep}" -E 'foo' >/dev/null 2>&1; then

   369             printf "yes\n"

   370         else

   371             printf "no\n"

   372             grep=

   373         fi

   374     fi

   375 fi

   376 if [ -z "${grep}" ]; then

   377     printf "Either you are missing entirely the needed tool,\n"

   378     printf "or the version you have is too old.\n"

   379     printf "You can give the path to this tool using: --with-grep=PATH\n"

   380     do_error "Bailing out..."

   381 fi

   382 add_to_var_list grep

   384 printf "Checking for 'sed'... "

   385 if [ -n "${sed}" ]; then

   386     printf "${sed} (cached)\n"

   387 else

   388     sed="$( which sed 2>/dev/null )"

   389     if [ -z "${sed}" ]; then

   390         printf "not found\n"

   391     else

   392         printf "${sed}\n"

   393         printf "Checking whether '${sed}' supports -i and -e... "

   394         touch .ct-ng.sed.test

   395         if "${sed}" -r -i -e 's/foo/bar/' .ct-ng.sed.test >/dev/null 2>&1; then

   396             printf "yes\n"

   397         else

   398             printf "no\n"

   399             sed=

   400         fi

   401         rm -f .ct-ng.sed.test

   402     fi

   403 fi

   404 if [ -z "${sed}" ]; then

   405     printf "Either you are missing entirely the needed tool,\n"

   406     printf "or the version you have is too old.\n"

   407     printf "You can give the path to this tool using: --with-sed=PATH\n"

   408     do_error "Bailing out..."

   409 fi

   410 add_to_var_list sed

   412 # The regular list of tools we can now easily check for

   413 has_or_abort prog=bash                              \

   414              var=bash                               \

   415              ver='^GNU bash, version (3\.[1-9]|4)'  \

   416              err="'bash' 3.1 or above was not found"

   417 has_or_abort prog=cut

   418 has_or_abort prog=install var=install

   419 has_or_abort prog=make                                  \

   420              var=make                                   \

   421              ver='^GNU Make (3.[89][[:digit:]]|[4-9])'  \

   422              err="GNU 'make' 3.80 or above was not found"

   423 has_or_abort prog=gcc

   424 has_or_abort prog="awk gawk" ver='^GNU Awk' err="GNU 'awk' was not found"

   425 has_or_abort prog=bison

   426 has_or_abort prog=flex

   427 has_or_abort prog=makeinfo

   428 has_or_abort prog=automake                                                      \

   429              ver='\(GNU automake\) (1\.[[:digit:]]{2,}|[2-9][[:digit:]]*\.)'    \

   430              err="'automake' 1.10 or above was not found"

   431 has_or_abort prog=libtool                                                                           \

   432              var=libtool                                                                            \

   433              ver='\(GNU libtool.*\) (2[[:digit:]]*\.|1\.6[[:digit:]]*\.|1\.5\.[2-9][[:digit:]]+)'   \

   434              err="'libtool' 1.5.26 or above was not found"

   435 has_or_abort prog=stat

   436 has_or_abort prog="curl wget"

   437 has_or_abort prog=cvs

   438 has_or_abort prog=patch

   439 has_or_abort prog=tar

   440 has_or_abort prog=gzip

   441 has_or_abort prog=bzip2

   442 has_or_abort prog=lzma

   443 has_or_abort prog=readlink

   444 has_or_abort prog=objcopy var=objcopy

   445 has_or_abort prog=objdump var=objdump

   446 has_or_abort prog=readelf var=readelf

   447 has_or_abort prog=patch var=patch

   449 # Host system checks

   451 printf "Checking for host system... "

   452 host="$( uname -s )"

   453 printf "%s\n" "${host}"

   454 case "${host}" in

   455     Linux)  ;;

   456     Cygwin) ;;

   457     *)

   458         printf " * Runing under %s is not fully tested\n" "${host}"

   459         printf " * You may encounter some weird behavior\n"

   460         ;;

   461 esac

   463 printf "Checking if static linking is possible... "

   464 static_link_ok=""

   465 case "${host}" in

   466     Darwin) ;;

   467     *)  tmp=.static.tmp

   468         if gcc -xc - -static -o "${tmp}" >/dev/null 2>&1<<-_EOF_

   469 				int main() { return 0; }

   470 			_EOF_

   471         then

   472             static_link_ok="y"

   473         fi

   474         rm -f "${tmp}"

   475         ;;

   476 esac

   477 if [ "${static_link_ok}" = "y" ]; then

   478     printf "yes\n"

   479 else

   480     printf "no\n"

   481     printf " * An optional host feature is missing, some features will be disabled:\n"

   482     printf " * - It will not be possible to statically link toolchain's binaries\n"

   483 fi

   484 add_to_kconfig_list static_link_ok

   486 # Library checks

   487 libs_exts="so dylib a"

   489 ncurses_hdrs="ncurses/ncurses.h ncurses/curses.h ncurses.h curses.h"

   490 ncurses_libs="libncursesw libncurses libcurses"

   491 has_or_abort lib="${ncurses_libs}"                                          \

   492              lib_exts="${libs_exts}"                                        \

   493              inc="${ncurses_hdrs}"                                          \

   494              err="The 'ncurses' library is needed fo the menuconfig frontend"

   496 has_or_abort lib="libstdc++"            \

   497              lib_exts="${libs_exts}"    \

   498              err="The 'libstdc++' library is needed to build gcc"

   500 # Yes, we may be checking twice for libstdc++.a

   501 # The first is because we need one instance of libstdc++ (shared or static)

   502 # because it is needed for PPL; the second is because the static version is

   503 # required for static-linking, and if missing, the option is removed.

   504 has_or_warn  lib="libstdc++"    \

   505              lib_exts="a"       \

   506              err="static 'libstdc++' is needed to statically link the toolchain's executables" \

   507              kconfig=has_static_libstdcxx

   509 has_or_warn  inc="expat.h"              \

   510              lib="libexpat"             \

   511              lib_exts="${libs_exts}"    \

   512              err="The 'expat' header file and library are needed to link cross-gdb's executables" \

   513              kconfig=has_expat

   515 # Yes, we may be checking twice for libexpat.a

   516 # The first is because we need one instance of libexpat (shared or static)

   517 # because it is needed for cross-gdb; the second is because the static version

   518 # is required for static-linking, and if missing, the option is removed.

   519 has_or_warn  lib="libexpat" \

   520              lib_exts="a"   \

   521              err="static 'expat' is needed to statically link cross-gdb's executables" \

   522              kconfig=has_static_expat

   524 for v in 7 6 5 4; do

   525     python_incs="${python_incs} python2.${v}/Python.h"

   526     python_libs="${python_libs} libpython2.${v}"

   527 done

   528 has_or_warn  inc="${python_incs}"       \

   529              lib="${python_libs}"       \

   530              lib_exts="${libs_exts}"    \

   531              err="The 'python' header file and library are needed for some features of cross-gdb"

   533 #---------------------------------------------------------------------

   534 # Compute the version string

   536 # If this version is n hg clone, try to get the revision number

   537 # If we can't get the revision number, use date

   538 printf "\nComputing version string... "

   539 case "${VERSION}" in

   540     *+hg|hg)

   541         REVISION="$( hg id -n 2>/dev/null || true )"

   542         case "${REVISION}" in

   543             "")

   544                 VERSION="${VERSION}_unknown@$( date +%Y%m%d.%H%M%S )";;

   545             *)

   546                 VERSION="${VERSION}_$( hg id -b )@${REVISION%%+}_$( hg id -i )"

   547                 ;;

   548         esac

   549         # Arrange to have no / in the directory name, no need to create an

   550         # arbitrarily deep directory structure

   551         VERSION="$( printf "${VERSION}\n" |"${sed}" -r -e 's|/+|_|g;' )"

   552         ;;

   553 esac

   554 printf "${VERSION}\n"

   556 #---------------------------------------------------------------------

   557 # Compute and check install paths

   559 # Now we have the version string, we can build up the paths

   560 [ -z "${BINDIR_set}" ] && BINDIR="${PREFIX}/bin"

   561 [ -z "${LIBDIR_set}" ] && LIBDIR="${PREFIX}/lib"

   562 [ -z "${DOCDIR_set}" ] && DOCDIR="${PREFIX}/share/doc"

   563 [ -z "${MANDIR_set}" ] && MANDIR="${PREFIX}/share/man"

   565 # Install support files in our own sub-dir, so as not to mangle (system)

   566 # files and dirs, but only if not --local

   567 if [ -z "${LOCAL_set}" ]; then

   568     LIBDIR="${LIBDIR}/ct-ng-${VERSION}"

   569     DOCDIR="${DOCDIR}/ct-ng-${VERSION}"

   570 fi

   572 # Check that install PATHs are absolute

   573 for p in BIN LIB DOC MAN; do

   574     var="${p}DIR"

   575     eval v='"${'"${var}"'}"'

   576     case "${v}" in

   577         /*) ;;

   578         *)  do_error "'${var}' is not an absolute path: '${v}'"

   579     esac

   580 done

   582 #---------------------------------------------------------------------

   583 # That's all, folks!

   585 printf "Building up Makefile... "

   586 var_sed="$( for var_name in ${var_list}; do

   587                 eval echo 's,@@${var_name}@@,${'"${var_name}"'},g'

   588             done

   589           )"

   590 kconfig_sed="s/@@KCONFIG@@/$( for k_name in ${kconfig_list}; do

   591                                   eval printf \"${k_name}=\${${k_name}} \"

   592                               done

   593                             )/"

   594 "${sed}" -r -e "s,@@BINDIR@@,${BINDIR},g"       \

   595             -e "s,@@LIBDIR@@,${LIBDIR},g"       \

   596             -e "s,@@DOCDIR@@,${DOCDIR},g"       \

   597             -e "s,@@MANDIR@@,${MANDIR},g"       \

   598             -e "s,@@VERSION@@,${VERSION},g"     \

   599             -e "s,@@DATE@@,${DATE},g"           \

   600             -e "s,@@LOCAL@@,${LOCAL_set},g"     \

   601             -e "${var_sed}"                     \

   602             -e "${kconfig_sed}"                 \

   603          Makefile.in                            \

   604          >Makefile

   605 echo "done"

   607 cat <<__EOF__

   609 crosstool-NG configured as follows:

   610   PREFIX='${PREFIX}'

   611   BINDIR='${BINDIR}'

   612   LIBDIR='${LIBDIR}'

   613   DOCDIR='${DOCDIR}'

   614   MANDIR='${MANDIR}'

   616 Now run:

   617   make

   618 __EOF__

   619 if [ "${LOCAL_set}" != "y" ]; then

   620     printf "  make install\n"

   621 fi

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Tue Jun 28 00:29:02 2011 +0200 (2011-06-28)
changeset 2527	a65f56df62de
parent 2526	e5fb003a354c
child 2528	3b058d7049bf
permissions	-rwxr-xr-x