configure

#! /bin/sh
#
# A (not so) simple configure script.
#
# Authors: Christian Holm Christensen and Fons Rademakers
#
# To help with debugging the script, some comments are preprended with
# 3 '#' echo and 3 '%' - replace that pattern with echo and 3 '%' to
# get printouts.  When done replace the pattern echo and 3 '%' with the
# original pattern of 3 '#' echo and 3 '%'.  Emacs command M-C-% does
# this easily.
#
######################################################################
#
### echo %%% Some global variables
#
found_lib=no
found_dir=no
found_hdr=no
show_pkglist=no
fail_on_missing=no
noact="no"
nohowto="no"
logfile=config.log
altcc=
altcxx=
altf77=
altld=

deprecated_options="         \
   enable_mathcore           \
   enable_cern               \
"

options="                    \
   enable_afs                \
   enable_alien              \
   enable_asimage            \
   enable_astiff             \
   enable_bonjour            \
   enable_builtin_afterimage \
   enable_builtin_ftgl       \
   enable_builtin_freetype   \
   enable_builtin_glew       \
   enable_builtin_pcre       \
   enable_builtin_zlib       \
   enable_castor             \
   enable_chirp              \
   enable_cintex             \
   enable_clarens            \
   enable_editline           \
   enable_dcache             \
   enable_exceptions         \
   enable_explicitlink       \
   enable_fftw3              \
   enable_gviz               \
   enable_gdml               \
   enable_genvector          \
   enable_gfal               \
   enable_glite              \
   enable_globus             \
   enable_gsl_shared         \
   enable_hdfs               \
   enable_krb5               \
   enable_ldap               \
   enable_mathmore           \
   enable_memstat            \
   enable_minuit2            \
   enable_monalisa           \
   enable_mysql              \
   enable_odbc               \
   enable_opengl             \
   enable_oracle             \
   enable_peac               \
   enable_pgsql              \
   enable_pythia6            \
   enable_pythia8            \
   enable_python             \
   enable_qt                 \
   enable_qtgsi              \
   enable_reflex             \
   enable_roofit             \
   enable_ruby               \
   enable_rfio               \
   enable_rpath              \
   enable_sapdb              \
   enable_shadowpw           \
   enable_shared             \
   enable_soversion          \
   enable_srp                \
   enable_ssl                \
   enable_table              \
   enable_tmva               \
   enable_unuran             \
   enable_winrtdebug         \
   enable_xft                \
   enable_xml                \
   enable_xrootd             \
"

#
# This sets all options to "yes" - we turn off those we don't want
# on per default explictly afterwards.
#
for c in $options ; do eval ${c}="yes" ; done
for c in $deprecated_options ; do eval ${c}="yes" ; done
for c in $options ; do eval ${c}_explicit="" ; done

enable_afs=no
enable_gdml=no
enable_globus=no
enable_explicitlink=no
enable_gsl_shared=no
enable_krb5=no
enable_qt=no
enable_qtgsi=no
enable_roofit=no
enable_minuit2=no
enable_rpath=no
enable_ruby=no
enable_shadowpw=
enable_soversion=no
enable_table=no
enable_thread=yes        # cannot be disabled (not in above options list)
enable_unuran=no
enable_winrtdebug=
enable_xrootd=           # must be set explicitely via --enable-xrootd
enable_builtin_glew=no

# Remove old log file
rm -f $logfile

#
# ./configure arguments and defaults set via supported env vars
#
envvars="
THREAD           \
OPENGL           \
MYSQL            \
ORACLE           \
PGSQL            \
QTDIR            \
SAPDB            \
RFIO             \
CASTOR           \
GFAL             \
GSL              \
HDFS             \
PYTHIA6          \
PYTHIA8          \
FFTW3            \
GVIZ             \
PYTHONDIR        \
DCACHE           \
CHIRP            \
DNSSD            \
ALIEN            \
ASIMAGE          \
LDAP             \
GLOBUS_LOCATION  \
GLITE            \
MEMSTAT          \
MONALISA         \
SRP              \
SSL              \
AFS              \
ROOFIT           \
MINUIT2          \
TABLE            \
XMLDIR           \
ROOTDICTTYPE     \
"
configenvvars=
for c in $envvars ; do
   cc=`eval echo "$"$c | sed 's,\\\,\\\\\\\,g'`
   if test ! "x$cc" = "x" ; then
      if test ! "x$configenvvars" = "x" ; then
         configenvvars="$configenvvars $c=$cc"
      else
         configenvvars="$c=$cc"
      fi
   fi
done

configargs="$*"
# don't write --nohowto to config.h
configargs=`echo $configargs | sed 's, *--nohowto,,g'`

configoptions=
if test ! "x$configenvvars" = "x" ; then
   configoptions=$configenvvars
fi
if test ! "x$configargs" = "x" ; then
   if test ! "x$configoptions" = "x" ; then
      configoptions="$configoptions $configargs"
   else
      configoptions=$configargs
   fi
fi
configoptions=`echo $configoptions | sed 's,\\\,\\\\\\\,g'`

######################################################################
#
### echo %%% Some common functions
#
#_____________________________________________________________________
message() {
    # Write a simple message to std out
    if test $# -lt 1 ; then
        echo "message: Too few arguments"
        return 1
    fi
    echo $ac_n "$* ... $ac_c"
    logmsg "$*"
}

#_____________________________________________________________________
logmsg() {
    # Write a simple message to std out
    if test $# -lt 1 ; then
        echo "logmsg: Too few arguments"
        return 1
    fi
    if test "x$1" = "x-n"; then
       shift
       echo -n "$*" >> $logfile
    else
       echo "$*" >> $logfile
    fi
}

#_____________________________________________________________________
result() {
    echo "$*"
    logmsg "Result: $*"
}

#_____________________________________________________________________
checking_msg() {
    # Write a simple "checking" message to std out.
    if test $# -lt 1 ; then
        echo "checking_msg: Too few arguments"
        return 1
    fi
    echo $ac_n "Checking for$ac_c"
    logmsg $ac_n "Checking for$ac_c"
    while test $# -gt 1 ; do
        echo $ac_n " $1,$ac_c"
        logmsg $ac_n " $1,$ac_c"
        shift
        if test $# -eq 1 ; then
            echo $ac_n " or$ac_c"
            logmsg $ac_n " or$ac_c"
        fi
    done
    echo $ac_n " $1 ... $ac_c"
    logmsg " $1 ... "
}

#_____________________________________________________________________
check_libpic() {
    # This function will try to find out if an archive library [$1]
    # contains relocatable code. Currently works only for linux.
    # The result of the check is stored in is_libpic, 1 if true,
    # 0 otherwise, which should be immediately copied, since the variable
    # will be overwritten at next invocation of this function.

    is_libpic=1

    # Assert that we got enough arguments
    if test $# -ne 1 ; then
        echo "check_libpic: not 1 argument"
        return 1
    fi

    case $platform in
    linux) ;;
    *)     return 0;
           ;;
    esac

    # Save arguments in logical names
    chklibpic=$1
    if [ "x`basename $chklibpic .a`" != "x`basename $chklibpic`" ]; then
        # we have an archive .a file
        logmsg "Checking if $chklibpic contains relocatable code"
        logmsg " ar t $chklibpic | awk '{ if (NR==1) {print \$1 } }'"
        objpic=`ar t $chklibpic | awk '{ if (NR==1) {print $1 } }'`
        logmsg " ar x $chklibpic $objpic"
        ar x $chklibpic $objpic
        logmsg " objdump -r $objpic | grep -v ' .debug_' | grep 'R_X86_64_32'"
        objdump -r $objpic | grep -v ' .debug_' | grep 'R_X86_64_32' > /dev/null 2>& 1
        ret=$?
        rm -f $objpic
        logmsg " result: $ret"
        if test $ret -eq 0 ; then
            is_libpic=0
            logmsg " is not a relocatable library"
        fi
    fi
}

#_____________________________________________________________________
check_lib64() {
    # This function will try to find out if a library [$1] contains 64 bit
    # or 32 bit code. Currently works only for linux.
    # The result of the check is stored in is_lib64, 1 if true,
    # 0 otherwise, which should be immediately copied, since the variable
    # will be overwritten at next invocation of this function.

    is_lib64=0

    # Assert that we got enough arguments
    if test $# -ne 1 ; then
        echo "check_lib64: not 1 argument"
        return 1
    fi

    # Save arguments in logical names
    chklib64=$1
    logmsg "Checking if $chklib64 is a 64bit library"
    if [ "x`basename $chklib64 .a`" != "x`basename $chklib64`" ]; then
        # we have an archive .a file
        logmsg " objdump -a $chklib64 | grep 'x86-64'"
        objdump -a $chklib64 | grep 'x86-64' > /dev/null 2>& 1
        ret=$?
    else
        logmsg " file -L $chklib64 | grep '64-bit'"
        file -L $chklib64 | grep '64-bit' > /dev/null 2>& 1
        ret=$?
    fi
    logmsg " result: $ret"
    if test $ret -eq 0 ; then
        is_lib64=1
        logmsg " is a 64bit library"
    fi
}

#_____________________________________________________________________
check_library() {
    # This function will try to locate a library [$1] in the specific
    # directory [$3] or in a default path [$*].  If the second argument
    # [$2] is not "no", then shared libraries are favoured.
    # The result of the search is stored in found_lib and found_dir,
    # which should be immediately copied, since the variables value will
    # be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -lt 4 ; then
        echo "check_library: Too few arguments"
        return 1
    fi

    # Save arguments in local names
    lib=$1       ; shift
    shared=$1    ; shift
    libdirl=$1   ; shift
    libdirs="$*"

    # Write a message
    checking_msg $lib

    # check if we got a specific argument as to where the library
    # is to be found
    if test ! "x$libdirl" = "x" ; then
        libdirs=$libdirl
    fi
    found_lib=no
    found_dir=no

    # Make list of libraries to search for. The .lib extension is for
    # Windoze - note $shared is always "no" on windoze, since we need
    # the .lib export library to link.
    libs=""
    for i in $lib ; do
        for ext in .a .lib "" ; do     # lib without extension for MacOS X
            libs="$libs $i$ext"
        done
    done
    slibs=""
    for i in $lib ; do
        for ext in .so .sl .dylib .dll.a ; do      # .dll.a for cygwin gcc
            slibs="$slibs $i$ext"
        done
    done
    if test ! "x$shared" = "xno" ; then
        libs="$slibs $libs"
    else
        libs="$libs $slibs"
    fi

    logmsg "libraries to check for: $libs"
    # Loop over the list of possible directories, and see if we can
    # find any of the library files as determind above.
    for i in $libdirs ; do
        # look first in the lib32 directories
        if test "x$checklib32" = "xyes" ; then
            i32=`echo $i | sed -e 's|lib$|lib32|' -e 's|lib/|lib32/|'`
            #i="$i32 $i"
            i="$i32"
        fi
        # look first in the lib64 directories
        if test "x$checklib64" = "xyes" ; then
            i64=`echo $i | sed -e 's|lib$|lib64|' -e 's|lib/|lib64/|'`
            i="$i64 $i"
        fi
        # look only in the lib64 directories
        if test "x$checkonlylib64" = "xyes" ; then
            i64=`echo $i | sed -e 's|lib$|lib64|' -e 's|lib/|lib64/|'`
            i="$i64"
        fi
        # look only in the hpux64 directories
        if test "x$checkhpux64" = "xyes" ; then
            i64=`echo $i | sed 's|\(lib\)|\1/hpux64|'`
            i="$i64"
        fi
        # look only in the amd64 directories
        if test "x$checksolaris64" = "xyes" ; then
            i64=`echo $i | sed 's|\(lib\)|\1/amd64|'`
            i="$i64"
        fi
        logmsg " Checking in directories $i for $libs"
        for l in $i ; do
            l=`echo $l | sed 's,^//,/,'`
            if test ! -d $l ; then
                continue
            fi
            for j in ${libs} ; do
                logmsg "  Checking for library $j in directory $i"
                # if we found the file (it's readable by user), we set the
                # logical variables and are on our way, otherwise we continue
                liblist=`echo $l/$j`    # expands wildcard in $l/$j
                for n in ${liblist} ; do
                    logmsg "   Checking $n"
                    if test -f $n ; then
                        logmsg "   Found file $n"
                        if test "x$checklib64" = "xyes" ; then
                            check_lib64 $n
                            if test $is_lib64 -eq 1 ; then
                                found_dir=$l
                                found_lib=$j
                                break 4
                            fi
                        else
                            found_dir=$l
                            found_lib=$j
                            if test "x$arch" = "linux"; then
                               check_lib64 $n
                            else
                               is_lib64=0
                            fi
                            if test $is_lib64 -eq 1 ; then
                                found_dir=no
                                found_lib=no
                            else
                                # skip cygwin libraries when in pure Win32 mode
                                if test "x$platform" = "xwin32"; then
                                    case $found_dir in
                                        /lib|/lib/*|/usr/*) found_dir=no ;;
                                        *) break 4;;
                                    esac
                                else
                                    break 4
                                fi
                            fi
                        fi
                    else
                        logmsg "  $j not found in $l"
                    fi
                done
            done
        done
    done

    echo $found_dir
    unset libs
    unset libdirs

    if test "x$found_dir" = "xno" || test "x$found_lib" = "xno" ; then
        found_dir=""
        found_lib=""
        found_raw_lib=""
        logmsg " library not found"
    else
        flib=""
        maclib=""
        for i in $lib ; do
            for ext in .a .lib "" ; do     # lib without extension for MacOS X
                if test "x$found_lib" = "x$i$ext" ; then
                    flib=$i$ext
                    if test "x$ext" = "x" ; then
                        maclib="yes"
                    fi
                    break 2
                fi
            done
        done

        if (test "x$found_lib" = "x$flib" && test "x$shared" = "xno") || \
           test "x$maclib" = "xyes" ; then
                found_raw_lib=${found_lib}
            found_lib=${found_dir}/${found_lib}
            found_raw_dir=${found_dir}
            found_dir=""
        else
            found_raw_lib=${found_lib}
            found_lib=`echo $found_lib | sed 's|^lib\(.*\)\..*|-l\1|'`
            found_raw_dir=${found_dir}
            found_dir=-L${found_dir}
            # Avoid inclusion of /usr/lib, which is always included anyway
            if test "x$found_dir" = "x-L/usr/lib"   || \
               test "x$found_dir" = "x-L/usr/lib32" || \
               test "x$found_dir" = "x-L/usr/lib64" ; then
                found_dir=""
            fi
        fi

        # Correct path for win32
        if test "x$platform" = "xwin32"; then
            if test ! "x$found_lib" = "x" ; then
                found_lib=`cygpath -m $found_lib`
            fi
            if test ! "x$found_dir" = "x" ; then
               found_dir=`cygpath -m $found_dir`
            fi
        fi
    fi
    unset shared
    unset slibs
    unset lib
    unset flib
    unset maclib
    unset libdirl
}

#_____________________________________________________________________
check_header()  {
    # This function will try to locate a header [$1] in the specific
    # directory [$2] or in a default path [$*].
    # The result of the search is stored in found_hdr and found_dir,
    # which should be immediately copied, since the variables value will
    # be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -lt 3 ; then
        echo "check_header: Too few arguments"
        return 1
    fi

    # Save arguments in logical names
    hdrs=$1     ; shift
    hdrdir=$1   ; shift
    hdrdirs="$*"

    # Write a message
    checking_msg $hdrs

    # Check if we got a specific argument as to where the library
    # is to be found
    if test ! "x$hdrdir" = "x" ; then
        hdrdirs=$hdrdir
    fi
    found_hdr=no
    found_dir=no

    # Loop over the list of possible directories, and see if we can
    # find any of the library files as determind above.

    for i in $hdrdirs; do
        logmsg " Checking in directory $i"
        for j in ${hdrs} ; do
            logmsg "  Checking for $j in directory $i"
            # if we found the file (it's readable by user), we set the
            # logical variables and are on our way, otherwise we continue
            if test -r $i/$j ; then
                logmsg "  $i/$j is read-able"
                found_dir=$i
                found_hdr=$j
                # skip cygwin headers when in pure Win32 mode
                if test "x$platform" = "xwin32"; then
                    case $found_dir in
                        /usr/*) found_dir="no" ;;
                        *) break 2;;
                    esac
                else
                    break 2
                fi
            fi
        done
    done

    echo $found_dir

    if test "x$found_hdr" = "xno" || test "x$found_dir" = "xno" ; then
        found_hdr=""
        found_dir=""
    fi

    # Avoid inclusion of /usr/include, which is always included anyway
    #if test "x$found_dir" = "x/usr/include" ; then
        # found_dir="include"
    #fi

    # Correct path for win32
    if test "x$platform" = "xwin32"; then
        if test ! "x$found_hdr" = "x" ; then
           found_hdr=`cygpath -m $found_hdr`
        fi
        if test ! "x$found_dir" = "x" ; then
           found_dir=`cygpath -m $found_dir`
        fi
    fi

    unset hdrs
    unset hdrdirs
    unset hdrdir
}

#_____________________________________________________________________
check_symbol() {
    # This function will try to locate a symbol [$1] in a specific
    # library [$2] and in a given directory [$3].
    # The result of the check is stored in found_symbol, 1 if true,
    # 0 otherwise, which should be immediately copied, since the variable
    # will be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -ne 3 ; then
        echo "check_symbol: not 3 arguments"
        found_symbol=0
        return 1
    fi

    # Save arguments in logical names
    symbol=$1     ; shift
    symbollib=$1  ; shift
    symboldir=$1

    if test "x$symbollib" = "x" ; then
        found_symbol=0
        return 1
    fi

    symbollib=`echo $symbollib | sed -e 's/^-l/lib/'`

    if test ! "x$symboldir" = "x" ; then
        symboldir=`echo $symboldir | sed -e 's/^-L//'`
    fi

    # Check if we got a specific argument as to where the library
    # is to be found
    symbolfile=$symbollib
    exts=".so .lib .dylib"
    if test ! "x$shared" = "xno" ; then
        exts="$exts .a"
    else
        exts=".a $exts"
    fi

    usrlib="/usr/lib"
    # look first in the lib32 directories
    if test "x$checklib32" = "xyes" ; then
        usrlib="/usr/lib32 $usrlib"
    fi
    # look first in the lib64 directories
    if test "x$checklib64" = "xyes" ; then
        usrlib="/usr/lib64 $usrlib"
    fi
    # look only in the lib64 directories
    if test "x$checkonlylib64" = "xyes" ; then
        usrlib="/usr/lib64"
    fi
    # look only in the hpux64 directories
    if test "x$checkhpux64" = "xyes" ; then
        usrlib="/usr/lib/hpux64"
    fi
    # look only in the amd64 directories
    if test "x$checkamd64" = "xyes" ; then
        usrlib="/usr/lib/amd64"
    fi

    for d in "$symboldir" $usrlib ; do
        logmsg " Checking in $d"
        if test ! -r $d/$symbollib ; then
            logmsg "  $d/$symbollib not readable"
            for i in $exts ; do
                logmsg "   Checking extension $i with $d/$symbollib"
                if test -r $d/$symbollib$i ; then
                    logmsg "   $d/$symbollib$i readable"
                    symbolfile=$d/$symbollib$i
                    break 2
                fi
             done
        else
            logmsg "$d/$symbollib readable"
            symbolfile=$d/$symbollib
            break
        fi
    done

    if test "x$symbolfile" = "x" || test ! -r $symbolfile ; then
       found_symbol=0
       logmsg " Symbol not found"
       return 1
    fi

    checking_msg "$symbol in $symbolfile"
    nm $symbolfile 2>&1 | grep $symbol > /dev/null 2>&1
    if test $? -eq 0 ; then
        found_symbol=1
        logmsg " Symbol found"
    else
        nm $symbolfile 2>&1 | grep "no symbols" > /dev/null 2>&1
        if test $? -eq 0 ; then
            logmsg " $symbolfile is stripped, trying a link"
            # stripped library - only safe test is to link against the
            # library!  However, we do not know what compiler to use
            # so we can not do the test.  Assume the symbol is in
            cat <<EOF > conftest.mk
include config/Makefile.${arch}
conftest:conftest.c $symbolfile
	\$(CC) \$(CFLAGS) \$(LDFLAGS) $symbolfile \$< -o \$@

conftest.c:
	echo "extern int $symbol (); " > \$@
	echo "int main() { $symbol (); return 0; }" >> \$@
EOF
            $gnumake -f conftest.mk >> $logfile 2>&1
            if test $? -eq 0 ; then
                found_symbol=1
                logmsg " Link OK"
            else
                found_symbol=0
                logmsg " Failed code was"
                cat conftest.mk >> $logfile
            fi
            rm -rf conftest.c conftest.mk conftest
        else
            found_symbol=0
        fi
    fi
    if test $found_symbol -eq 1 ; then
        result "ok"
    else
        result "no"
    fi
}

#_____________________________________________________________________
check_comp() {
    # This function will try to locate the default or alt compiler
    # type [$1] in the PATH.
    # The result of the check is stored in found_comp, 1 if true,
    # 0 otherwise, which should be immediately copied, since the variable
    # will be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -ne 1 ; then
        echo "check_comp: not 1 argument"
        found_comp=0
        return 1
    fi

    comptype="$1"

    if test "x$comptype" = "xLD" ; then
       message "Checking for linker (LD)"
    else
       message "Checking for $comptype compiler"
    fi

    found_comp=0
    case $comptype in
    C)
        if test "x$altcc" = "x" ; then
            altcc=`grep '^CC ' config/Makefile.$arch | awk '{ if (NF==3) {print $3; exit 0} }'`
        fi
        altcc1=`echo "$altcc" | awk '{print $1}'`
        if `$cwhich $altcc1 > /dev/null 2>&1` ; then
            found_comp=1
            result "$altcc"
        else
            nocomp="$altcc"
        fi
        ;;
    C++)
        if test "x$altcxx" = "x" ; then
            altcxx=`grep '^CXX ' config/Makefile.$arch | awk '{ if (NF==3) {print $3; exit 0} }'`
        fi
        altcxx1=`echo "$altcxx" | awk '{print $1}'`
        if `$cwhich $altcxx1 > /dev/null 2>&1` ; then
            found_comp=1
            result "$altcxx"
        else
            nocomp="$altcxx"
        fi
        ;;
    LD)
        if test "x$altld" = "x" ; then
            altld=`grep '^LD ' config/Makefile.$arch | awk '{ if (NF==3) {print $3; exit 0} }'`
            if test "x$arch" = "xwin32" ; then
                altldorg="link"
                altldtmp="$altld"
                altld="$altldorg"
            fi
            if test "x$arch" = "xwin32gcc" ; then
                altldorg="g++"
                altldtmp="$altld"
                altld="$altldorg"
            fi
        fi
        altld1=`echo "$altld" | awk '{print $1}'`
        if `$cwhich $altld1 > /dev/null 2>&1` ; then
            found_comp=1
            if test ! "x$altldtmp" = "x" ; then
                altld="$altldtmp"
            fi
            result "$altld"
        else
            nocomp="$altld"
            altldorg=""
        fi
        ;;
    F77)
        if test "x$altf77" = "x" ; then
            altf77=`grep '^F77 ' config/Makefile.$arch | awk '{ if (NF==3) {print $3; exit 0} }'`
            if test "x$arch" = "xwin32" ; then
                altf77org="fl32"
                altf77tmp="$altf77"
                altf77="$altf77org"
            fi
        fi
        altf771=`echo "$altf77" | awk '{print $1}'`
        if `$cwhich $altf771 > /dev/null 2>&1` ; then
            found_comp=1
            if test ! "x$altf77tmp" = "x" ; then
                altf77="$altf77tmp"
            fi
            result "$altf77"
        else
            nocomp="$altf77"
            altf77org=""
        fi
        ;;
    esac

    if test $found_comp -eq 0 ; then
       result "no $comptype compiler $nocomp found"
    fi
}

#_____________________________________________________________________
check_explicit()
{
    feat=$1 ; shift
    expl=$1 ; shift
    emsg=$1 ; shift

    if test "x$fail_on_missing" = "xno" ; then return 0 ; fi
    if test ! "x$expl" = "xyes" ; then return 0 ; fi
    if test ! "x$feat" = "xyes" ; then
        result $emsg
        exit 1
    fi
}

#_____________________________________________________________________
guess_architecture() {
    # Try to guess the architecture of the host system
    # Note, that there's no attempt at guessing the compiler.
    # The `native' compiler is used in all cases.
    # If a user really want a specifific compiler, s/he better use the
    # first argument to do so.
    arch=`uname -s | tr '[A-Z]' '[a-z]'`
    chip=`uname -m | tr '[A-Z]' '[a-z]'`
    rele=`uname -r`
    logmsg "arch=$arch"
    logmsg "chip=$chip"
    logmsg "rele=$rele"
    case "$arch:$chip:$rele" in
        aix*)                  arch=aix5            ;;
        osf1*:alpha:*)         arch=alphacxx6       ;;
        freebsd*:*:7*)         arch=freebsd7        ;;
        freebsd*:*:6*)         arch=freebsd5        ;;
        freebsd*:*:5*)         arch=freebsd5        ;;
        freebsd*:*:4*)         arch=freebsd4        ;;
        freebsd*:*:*)          arch=freebsd         ;;
        hp-ux:ia64:*)          arch=hpuxia64acc     ;;
        hp-ux:*:*)             arch=hpuxacc         ;;
        hurd*:*:*)             arch=hurddeb         ;;
        linux:ia64:*)          arch=linuxia64gcc    ;;
        linux:x86_64:*)        arch=linuxx8664gcc   ;;
        linux:alpha:*)         arch=linuxalphagcc   ;;
        linux:arm*:*)          arch=linuxarm        ;;
        linux:hppa*:*)         arch=linux           ;;
        linux:mips:*)          arch=linuxmips       ;;
        linux:sparc*:*)        arch=linux           ;;
        linux:parisc*:*)       arch=linuxhppa       ;;
        linux:ppc64*:*)        arch=linuxppc64gcc   ;;
        linux:ppc*:*)          arch=linuxppcgcc     ;;
        linux:i*86:*)          arch=linux           ;;
        linux:s39*:*)          arch=linux           ;;
        openbsd*:*:*)          arch=openbsd         ;;
        lynx:*:*)              arch=lynxos          ;;
        darwin:power*:*)       arch=macosx          ;;
        darwin:*86*:*)         arch=macosx          ;;
        irix*:sgi*:*)          arch=sgicc           ;;
        sunos:sun*:6*)         arch=solarisCC5      ;;
        sunos:sun*:5*)         arch=solarisCC5      ;;
        sunos:sun*:4*)         arch=solaris         ;;
        sunos:i86pc:5*)        arch=solarisCC5      ;;
        cygwin_*:*86:*)        arch=win32           ;;
        cygwin_*:pentium:*)    arch=win32           ;;
        cygwin_*:ia64)         arch=win32           ;;
        *)
            echo "Attempts at guessing your architecture failed."
            echo "(triplet is $arch:$chip:$rele)"
            echo "Please specify the architecture as the first argument."
            echo "Do '$0 --help' for a list of avaliable architectures."
            echo "Or file a bug at https://savannah.cern.ch/projects/savroot/"
            echo "including the full config.log and a dump of"
            echo "  touch dummy_file.c; gcc -E -dM dummy_file.c"
            exit 1
            ;;
    esac
    if [ "$arch" = "macosx" ]; then
       if [ `sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2` -ge 5 ]; then
          if `sysctl machdep.cpu.extfeatures | grep "64" > /dev/null  2>&1` ; then
             arch=macosx64
          fi
       fi
    fi
    # CC in 64-bit fails on the asm in the dictionaries, disable
    # automatic detection for now (rdm)
    #if [ "$arch" = "solarisCC5" -a "$chip" = "i86pc" ]; then
    #   if `isainfo -b | grep "64" > /dev/null  2>&1` ; then
    #      arch=solaris64CC5
    #   fi
    #fi
    logmsg "$arch"
}

###################################################################
#
### echo %%% Some skeleton and config files
#
ARCHS=config/ARCHS
MAKEIN=config/Makefile.in
MAKEOUT=config/Makefile.config
MAKECOMPIN=config/Makefile-comp.in
MAKECOMPOUT=config/Makefile.comp
CONFIGUREIN=config/RConfigure.in
CONFIGUREOUT=include/RConfigure.h
CONFIGOPTIN=config/RConfigOptions.in
CONFIGOPTOUT=include/RConfigOptions.h
RCONFIN=config/root-config.in
RCONFOUT=bin/root-config
ROOTRCIN=config/rootrc.in
ROOTRCOUT=etc/system.rootrc
ROOTAUTHRCIN=config/rootauthrc.in
ROOTAUTHRCOUT=etc/system.rootauthrc
ROOTDAEMONRCIN=config/rootdaemonrc.in
ROOTDAEMONRCOUT=etc/system.rootdaemonrc
MEMPROBEIN=config/memprobe.in
MEMPROBEOUT=bin/memprobe
MIMEUNIXIN=config/mimes.unix.in
MIMEWIN32IN=config/mimes.win32.in
MIMEOUT=etc/root.mimes
ROOTDIN=config/rootd.in
ROOTDOUT=etc/daemons/rootd.rc.d
ROOTDXINETDIN=config/rootd.xinetd.in
ROOTDXINETDOUT=etc/daemons/rootd.xinetd
PROOFDIN=config/proofd.in
PROOFDOUT=etc/daemons/proofd.rc.d
PROOFDXINETDIN=config/proofd.xinetd.in
PROOFDXINETDOUT=etc/daemons/proofd.xinetd
XROOTDIN=config/xrootd.in
XROOTDOUT=etc/daemons/xrootd.rc.d
OLBDIN=config/olbd.in
OLBDOUT=etc/daemons/olbd.rc.d
ROOTHELPIN=config/root-help.el.in
ROOTHELPOUT=build/misc/root-help.el
HTMLIN=config/html.C.in
HTMLOUT=macros/html.C
THISROOTSHIN=config/thisroot.sh
THISROOTSHOUT=bin/thisroot.sh
THISROOTCSHIN=config/thisroot.csh
THISROOTCSHOUT=bin/thisroot.csh
THISROOTBATIN=config/thisroot.bat
THISROOTBATOUT=bin/thisroot.bat
GENREFLEXSHIN=config/genreflex.in
GENREFLEXSHOUT=bin/genreflex
GENREFLEXBATIN=config/genreflex.bat.in
GENREFLEXBATOUT=bin/genreflex.bat
GENREFLEXROOTCINTSHIN=config/genreflex-rootcint.in
GENREFLEXROOTCINTSHOUT=bin/genreflex-rootcint
GENREFLEXROOTCINTBATIN=config/genreflex-rootcint.bat.in
GENREFLEXROOTCINTBATOUT=bin/genreflex-rootcint.bat

# unset global command options that can cause havoc