crosstool-ng: configure@dda4742972e2

     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 # $*: skip=[y|n|]

   122 #     if set to 'y', skip the test, but still register the

   123 #     kconfig and var variables; if 'n' or empty, do the

   124 #     test.

   125 #     optional, default to 'n'

   126 #       eg: skip="${static_link_ko}"

   127 check_for() {

   128     local lib_exts

   129     local skip

   130     local val

   131     local item

   132     local where

   133     local status

   134     local ext

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

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

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

   139         case "${item}" in

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

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

   142                 ;;

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

   144         esac

   145     done

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

   148         ?*:?*:|?*::?*|:?*:?*|?*:?*:?*)

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

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

   151             fi

   152             ;;

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

   154     esac

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

   157         add_to_var_list "${var}"

   158     fi

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

   160         add_to_kconfig_list "${kconfig}"

   161     fi

   163     if [ "${skip}" = "y" ]; then

   164         return 0

   165     fi

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

   168         for item in ${prog}; do

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

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

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

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

   173                     status="${val} (cached)\n"

   174                     break

   175                 fi

   176             fi

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

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

   179                 printf "no\n"

   180                 continue

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

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

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

   184                        |head -n 1

   185                      )

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

   187                     printf "no\n"

   188                     unset where

   189                     continue

   190                 fi

   191             fi

   192             status="${where}"

   193             break

   194         done

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

   196             return 1

   197         fi

   198         printf "${status}\n"

   199         unset status

   200     fi

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

   203         for item in ${inc}; do

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

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

   206                 where="${item}"

   207                 status=yes

   208                 break;

   209             fi

   210             printf "no\n"

   211         done

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

   213             return 1

   214         fi

   215         printf "${status}\n"

   216         unset status

   217     fi

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

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

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

   222         fi

   223         for item in ${lib}; do

   224             for ext in ${lib_exts}; do

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

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

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

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

   229                     status=yes

   230                     break 2;

   231                 fi

   232                 printf "no\n"

   233             done

   234         done

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

   236             return 1

   237         fi

   238         printf "${status}\n"

   239         unset status

   240     fi

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

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

   244     fi

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

   246         eval ${kconfig}=y

   247     fi

   248 }

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

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

   252 has_or_abort() {

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

   254     # set in check_for(), called below

   255     local prog inc lib

   256     local var ver err kconfig

   258     if ! check_for "$@"; then

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

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

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

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

   263         fi

   264         printf "\n"

   265         # Bail out if --force is not specified

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

   267         printf "<*                                          *>\n"

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

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

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

   271         printf "<*                                          *>\n"

   272         printf "\n"

   273     fi

   274 }

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

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

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

   279 has_or_warn() {

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

   281     # set in check_for(), called below

   282     local prog inc lib

   283     local var ver err kconfig

   285     if ! check_for "$@"; then

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

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

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

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

   290         fi

   291     fi

   292 }

   294 do_help() {

   295     cat <<__EOF__

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

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

   300 Defaults for the options are specified in brackets.

   302 Configuration:

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

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

   305                           some pre-requisites are missing

   307 Installation directories:

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

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

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

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

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

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

   316 For better control, use the options below.

   318 Fine tuning of the installation directories:

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

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

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

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

   324 Optional Features:

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

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

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

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

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

   330 __EOF__

   331 }

   333 #---------------------------------------------------------------------

   334 # Set user's options

   336 while [ $# -ne 0 ]; do

   337     case "$1" in

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

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

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

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

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

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

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

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

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

   347         # Skip, auto-stuff compatibility

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

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

   350         --enable-shared|--disable-shared|--enable-static|--disable-static)           shift;;

   351         --program-prefix=*)                                                          shift;;

   352         --program-prefix)                                                            shift 2;;

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

   354     esac

   355 done

   357 # Use defaults

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

   360 # Special case when installing locally

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

   362     set_prefix "" "$( pwd )"

   363     set_bindir "" "$( pwd )"

   364     set_libdir "" "$( pwd )"

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

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

   367 fi

   369 #---------------------------------------------------------------------

   370 # Some sanity checks, now

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

   373 printf "Checking for 'grep'... "

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

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

   376 else

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

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

   379         printf "not found\n"

   380     else

   381         printf "${grep}\n"

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

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

   384             printf "yes\n"

   385         else

   386             printf "no\n"

   387             grep=

   388         fi

   389     fi

   390 fi

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

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

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

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

   395     do_error "Bailing out..."

   396 fi

   397 add_to_var_list grep

   399 printf "Checking for 'sed'... "

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

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

   402 else

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

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

   405         printf "not found\n"

   406     else

   407         printf "${sed}\n"

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

   409         touch .ct-ng.sed.test

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

   411             printf "yes\n"

   412         else

   413             printf "no\n"

   414             sed=

   415         fi

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

   417     fi

   418 fi

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

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

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

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

   423     do_error "Bailing out..."

   424 fi

   425 add_to_var_list sed

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

   428 has_or_abort prog=bash                              \

   429              var=bash                               \

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

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

   432 has_or_abort prog=cut

   433 has_or_abort prog=install var=install

   434 has_or_abort prog=make                                  \

   435              var=make                                   \

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

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

   438 has_or_abort prog=gcc

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

   440 has_or_abort prog=bison

   441 has_or_abort prog=flex

   442 has_or_abort prog=makeinfo

   443 has_or_abort prog=automake                                                      \

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

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

   446 has_or_abort prog=libtool                                                                           \

   447              var=libtool                                                                            \

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

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

   450 has_or_abort prog=stat

   451 has_or_abort prog="curl wget"

   452 has_or_abort prog=patch

   453 has_or_abort prog=tar

   454 has_or_abort prog=gzip

   455 has_or_abort prog=bzip2

   456 has_or_warn  prog=xz                                        \

   457              kconfig=has_xzutils                            \

   458              err="xz-comoressed tarballs will not be used"

   459 has_or_abort prog=readlink

   460 has_or_abort prog=objcopy var=objcopy

   461 has_or_abort prog=objdump var=objdump

   462 has_or_abort prog=readelf var=readelf

   463 has_or_abort prog=patch var=patch

   464 has_or_warn  prog=cvs                                                   \

   465              kconfig=has_cvs                                            \

   466              err="it will not be possible to use newlib cvs snapshots"

   467 has_or_warn  prog=svn                               \

   468              kconfig=has_svn                        \

   469              err="subversion is required to download eglibc"

   471 # Host system checks

   473 printf "Checking for host system... "

   474 host="$( uname -s )"

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

   476 case "${host}" in

   477     Linux)  ;;

   478     Cygwin) ;;

   479     *)

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

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

   482         ;;

   483 esac

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

   486 static_link_ok=""

   487 case "${host}" in

   488     Darwin) ;;

   489     *)  tmp=.static.tmp

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

   491 				int main() { return 0; }

   492 			_EOF_

   493         then

   494             static_link_ok="y"

   495         fi

   496         rm -f "${tmp}"

   497         ;;

   498 esac

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

   500     static_link_ko=""

   501     printf "yes\n"

   502 else

   503     static_link_ko="y"

   504     printf "no\n"

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

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

   507 fi

   508 add_to_kconfig_list static_link_ok

   510 # Library checks

   511 libs_exts="so dylib"

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

   513     libs_exts="${libs_exts} a"

   514 fi

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

   517 ncurses_libs="libncursesw libncurses libcurses"

   518 has_or_abort lib="${ncurses_libs}"                                          \

   519              lib_exts="${libs_exts}"                                        \

   520              inc="${ncurses_hdrs}"                                          \

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

   523 has_or_abort lib="libstdc++"            \

   524              lib_exts="${libs_exts}"    \

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

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

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

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

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

   531 has_or_warn  lib="libstdc++"                \

   532              lib_exts="a"                   \

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

   534              kconfig=has_static_libstdcxx   \

   535              skip="${static_link_ko}"

   537 has_or_warn  inc="expat.h"              \

   538              lib="libexpat"             \

   539              lib_exts="${libs_exts}"    \

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

   541              kconfig=has_expat

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

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

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

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

   547 has_or_warn  lib="libexpat"             \

   548              lib_exts="a"               \

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

   550              kconfig=has_static_expat   \

   551              skip="${static_link_ko}"

   553 for v in 7 6 5 4; do

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

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

   556 done

   557 has_or_warn  inc="${python_incs}"       \

   558              lib="${python_libs}"       \

   559              lib_exts="${libs_exts}"    \

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

   562 #---------------------------------------------------------------------

   563 # Compute the version string

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

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

   567 printf "\nComputing version string... "

   568 case "${VERSION}" in

   569     *+hg|hg)

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

   571         case "${REVISION}" in

   572             "")

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

   574             *)

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

   576                 ;;

   577         esac

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

   579         # arbitrarily deep directory structure

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

   581         ;;

   582 esac

   583 printf "${VERSION}\n"

   585 #---------------------------------------------------------------------

   586 # Compute and check install paths

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

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

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

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

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

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

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

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

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

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

   599 fi

   601 # Check that install PATHs are absolute

   602 for p in BIN LIB DOC MAN; do

   603     var="${p}DIR"

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

   605     case "${v}" in

   606         /*) ;;

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

   608     esac

   609 done

   611 #---------------------------------------------------------------------

   612 # That's all, folks!

   614 printf "Building up Makefile... "

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

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

   617             done

   618           )"

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

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

   621                               done

   622                             )/"

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

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

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

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

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

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

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

   630             -e "${var_sed}"                     \

   631             -e "${kconfig_sed}"                 \

   632          Makefile.in                            \

   633          >Makefile

   634 echo "done"

   636 cat <<__EOF__

   638 crosstool-NG configured as follows:

   639   PREFIX='${PREFIX}'

   640   BINDIR='${BINDIR}'

   641   LIBDIR='${LIBDIR}'

   642   DOCDIR='${DOCDIR}'

   643   MANDIR='${MANDIR}'

   645 Now run:

   646   make

   647 __EOF__

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

   649     printf "  make install\n"

   650 fi

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Wed Aug 10 23:13:46 2011 +0200 (2011-08-10)
changeset 2607	dda4742972e2
parent 2606	b6bf20def07f
child 2619	628192dbf847
permissions	-rwxr-xr-x