#!/bin/sh # --------------------------------------------------------------------- # A CGAL Installation Script Prototype # --------------------------------------------------------------------- # $Id$ # --------------------------------------------------------------------- # # Copyright (c) 1998 The CGAL Consortium # # This software and related documentation is part of the # Computational Geometry Algorithms Library (CGAL). # # Every use of CGAL requires a license. Licenses come in three kinds: # # - For academic research and teaching purposes, permission to use and # copy the software and its documentation is hereby granted free of # charge, provided that # (1) it is not a component of a commercial product, and # (2) this notice appears in all copies of the software and # related documentation. # - Development licenses grant access to the source code of the library # to develop programs. These programs may be sold to other parties as # executable code. To obtain a development license, please contact # the CGAL Consortium (at cgal@cs.uu.nl). # - Commercialization licenses grant access to the source code and the # right to sell development licenses. To obtain a commercialization # license, please contact the CGAL Consortium (at cgal@cs.uu.nl). # # This software and documentation is provided "as-is" and without # warranty of any kind. In no event shall the CGAL Consortium be # liable for any damage of any kind. # # The CGAL Consortium consists of Utrecht University (The Netherlands), # ETH Zurich (Switzerland), Free University of Berlin (Germany), # INRIA Sophia-Antipolis (France), Max-Planck-Institute Saarbrucken # (Germany), RISC Linz (Austria), and Tel-Aviv University (Israel). # # --------------------------------------------------------------------- # --------------------------------------------------------------------- # some important global variables # --------------------------------------------------------------------- # --------------------------------------------- # CGAL specific: # --------------------------------------------- CGAL_VERSION='1.2' # --------------------------------------------- CGAL_INSTALL_VERSION='$Revision$' # --------------------------------------------- CGAL_INSTALL_CONF_VERSION='1.1' # --------------------------------------------- CGAL_LIB_NAME='libCGAL' # --------------------------------------------- CGAL_DIR=`pwd` # ------------------------------------------------------- # several directories depend on the setting of CGAL_DIR # we put these into a function that can be called in case # that CGAL_DIR is changed later # ------------------------------------------------------- set_dirs_dependant_on_cgal_dir() { CGAL_EXAMPLE_DIR=${CGAL_DIR}/examples CGAL_INCL_DIR=${CGAL_DIR}/include CGAL_INCL_CONF_DIR=${CGAL_INCL_DIR}/CGAL/config CGAL_LIB_DIR=${CGAL_DIR}/lib CGAL_MAKE_DIR=${CGAL_DIR}/make CGAL_SRC_DIR=${CGAL_DIR}/src CGAL_TEST_DIR=${CGAL_DIR}/test CGAL_CONF_DIR=${CGAL_DIR}/config CGAL_AUX_DIR=${CGAL_DIR}/auxiliary CGAL_INSTALL_CONF_DIR=${CGAL_CONF_DIR}/install CGAL_TEST_CONF_DIR=${CGAL_CONF_DIR}/testfiles CGAL_DIRFILE=${CGAL_MAKE_DIR}/CGAL_directories CGAL_TESTFILE=${CGAL_TEST_DIR}/run_testsuite # --------------------------------------------- # logfile for testsuite: TEST_LOGFILE=${CGAL_TEST_DIR}/error.txt # --------------------------------------------- # internal variables # --------------------------------------------- # installation logfile (verbose) INSTALL_LOGFILE="${CGAL_DIR}/install.log" # installation logfile (only completed compile/test runs) # (Really Important Stuff) INSTALL_RIS_LOGFILE=${CGAL_DIR}/install.completed # compilation logfile COMPILE_LOGFILE=${CGAL_DIR}/compile.log # logfile for temporary use (e.g. compiler tests) TMP_LOGFILE=${CGAL_DIR}/tmptmp.log # temporary file for confidence tests TMP_CXX_FILE=${CGAL_DIR}/tmp_test } # initialize once set_dirs_dependant_on_cgal_dir # --------------------------------------------- # set to non-empty, if you want to view the logs of # ALL failed tests INSTALL_VERBOSE='' # --------------------------------------------- # prefix of CGAL compiler specific configuration flags CGAL_CONFIG_PREFIX='CGAL_CFG_' # --------------------------------------------- # set to empty string, if you want to disable testsuite CGAL_TESTSUITE='y' # --------------------------------------------- # set to non-empty string, if MIPSPRO 64 compiler # is to be supported SUPPORT_MIPSPRO_64='y' # --------------------------------------------- # LEDA specific: # suffix for include makefile: # toggles the use of LEDA: ('' - no LEDA, '_LEDA' - LEDA) LEDA_SUPPORT='' # directories for LEDA LEDA_INCL_DIR='' LEDA_LIB_DIR='' # do we have to provide extra incl/lib flags for LEDA('y') # is it installed in standard system dirs(''), # or do we want to provide extra incl/lib flags, although it is # installed in sysdirs ('x')? # set to 'n', if this has not been tested yet NEED_EXTRA_LEDA_IDIR='y' NEED_EXTRA_LEDA_LDIR='y' # did LEDA tests succeed ('' - no, 'y' - yep) LEDA_TEST_PASSED='' # --------------------------------------------- # STL specific: # # specifies STL setting (since this is compiler specific, # it will be updated each time a compiler is chosen) # 'e' means an extra STL is needed and # 'b' means compiler is shipped with an STL (and it should be used) # while 'x' means to use an extra STL anyway STL_STATUS='b' STL_DIR='' # type of STL: (see test_stl_version below) CGAL_STL_VERSION='CGAL_STL_UNKNOWN' # did STL tests succeed ('' - no, 'y' - yep) STL_TEST_PASSED='' # --------------------------------------------- # GMP specific: # # version of gmp shipped with CGAL: GMP_VERSION='gmp-2.0.2' # toggles use of GMP ('' - no, '_GMP' - use it) GMP_SUPPORT='' # indicate whether GMP is installed # ('' - didn't try, # 's' - in sysdirs, no flags necessary, # 'e' - we need compiler/linker flags and GMP_INCL_DIR/GMP_LIB_DIR for this, # 'x' - in sysdirs, but specify GMP_INCL_DIR/GMP_LIB_DIR anyway # 'c' - in the cgal tree, # 'z' - in the cgal tree, but specify GMP_INCL_DIR/GMP_LIB_DIR anyway) GMP_INSTALLATION='' GMP_INCL_DIR='' GMP_LIB_DIR='' # did GMP tests succeed ('' - no, 'y' - yep) GMP_TEST_PASSED='' # --------------------------------------------------------------------- # internal variables # --------------------------------------------------------------------- # width of menu screen / 10 (in characters) _MENU_WIDTH=6 # left indentation of menu _LEFTSPACE=' ' # installation logfile (verbose) INSTALL_LOGFILE_REDIRECTION='>/dev/null' # compiler to be used # This is a string defined as follows: # @@@@ # The components can be accessed using the functions: # compiler_basename, (extended_)compiler_description, # c_compiler_bin, compiler_bin and compiler_version # The strings are set in search_for_compilers resp. compiler_absolute COMPILER='' # string defining OS and compiler # (used for naming makefiles and lib directories) CGAL_OS_COMPILER='' # can we start building the libs? SETUP_COMPLETE='' # does there exist a CGALlib for this compiler? LIB_COMPILED='' # Was there any successfull compile run during this session? ANY_LIB_COMPILED='' # custom options for compiler/linker: CUSTOM_CXXFLAGS='' CUSTOM_LDFLAGS='' # --------------------------------------------------------------------- # How to use this script # --------------------------------------------------------------------- print_general_information() { ${_printf} "%s\n\n" \ "You can get a list of all options with \"`basename $0` --help\" First-time-installers: ---------------------- Just type \"`basename $0` -i\" and follow the menus. If you get stuck, please read the documentation." } print_usage_information() { ${_printf} "%s\n\n" \ "usage: `basename $0` [--help | --version | -i | --interactive | -ni | --non-interactive | -os | --build-all | --rebuild-all] [-leda] [-gmp] [--verbose] [--CGAL_DIR ] [--STL_DIR ] [--leda-sys-incl] [--leda-sys-lib] [--LEDA_INCL_DIR ] [--LEDA_LIB_DIR ] [--GMP_INCL_DIR ] [--GMP_LIB_DIR ] -leda enables LEDA support -gmp enables support for GNU GMP --verbose give report for each test that fails (not generally recommended) --help gives this message --version prints `basename $0` version number --interactive runs the script in interactive mode (other options - except for --CGAL_DIR - are ignored) --non-interactive runs the script in non-interactive mode i.e. makefiles are generated for C++ compiler specified by . For the rest you are on your own. (Have a look at the README file.) -os prints architecture/os/compiler spec" } # --------------------------------------------------------------------- # exit with error message "$*" # --------------------------------------------------------------------- exit_on_error() { ${_printf} "\n%s\n" \ "===================================================" ${_printf} "%s" "ERROR: ${1}" shift while [ ${#} -gt 0 ]; do ${_printf} "\n\t%s" "${1}" shift done ${_printf} "%s\n" ", exiting." ${_printf} "%s\n" \ "===================================================" exit 1 } # --------------------------------------------------------------------- # system related functions: # --------------------------------------------------------------------- # print the value of variable $1 value_of() { _value=`eval "${_printf} '$'$1"` eval "${_printf} \"%s\" \"${_value}\"" } # print the value of variable $1, except for the first occurrence # of the regexps $2 - $n value_of_without() { _tmp=`value_of "$1"` while [ $# -gt 1 ]; do _tmp=`${_printf} "${_tmp}\n" | ${_sed} "s/${2}//1"` shift done ${_printf} "%s" "${_tmp}" } # (/usr)/bin/which is completely STUPID # it looks at ~/.cshrc and reports aliases # that do not exist, if you run a shell other than csh # so it's us who have to do the work again :) # needs awk! real_which() { _t=0 for i in `echo ${PATH} | ${_awk} 'BEGIN {RS=":"}{print $0}'`; do if [ ${_t} = 0 -a -x ${i}/$1 ]; then echo ${i}/$1 _t=1 fi done } # basename/dirname is somewhat nasty when having options like: # // - ... - _real_basename() { ${_basename} `${_printf} "${*}" | ${_awk} '{ printf "%s",$1 }'` } _real_dirname() { ${_dirname} `${_printf} "${*}" | ${_awk} '{ printf "%s",$1 }'` } _real_options() { ${_printf} "${*}" | \ ${_awk} '{ for (i=2; i<=NF; ++i) printf "%s",$i }' } # print to logfile log_print() { eval "${_printf} \"%s\n\" \"$*\" ${INSTALL_LOGFILE_REDIRECTION}" } # checks for existency of program $1 # and set variable _$3 to its full path # ($3 defaults to $1 if not specified) # (if $2 is 'y', exit if it is not existent, # otherwise return 0, iff it exists) _check_for_util() { _tmp=`${_which} $1` if [ -x "${_tmp}" ]; then eval "_${3:-$1}=${_tmp}" elif [ "$2" = "y" ]; then exit_on_error "Couldn't find \"${1}\"" else log_print "WARNING: Couldn't find $1." return 1 fi _tmp="echo $\_`echo ${3:-$1}`" _tmp=`eval "${_tmp}"` _tmp=`eval "echo ${_tmp}"` log_print "$1 is ${_tmp}." return 0 } # same as _check_for_util above except that it searches # in /bin and /usr/bin first _check_for_sysutil() { if [ -x /bin/$1 ]; then eval "_$1=/bin/$1" elif [ -x /usr/bin/$1 ]; then eval "_$1=/usr/bin/$1" else _check_for_util $* return $? fi _tmp="echo $\_`echo ${3:-$1}`" _tmp=`eval "${_tmp}"` _tmp=`eval "echo ${_tmp}"` log_print "$1 is ${_tmp}." return 0 } # exit, if we have no read permission for $1 _check_read() { if [ ! -r "$1" ]; then exit_on_error "Cannot read \"$1\"" fi } # exit, if we have no execute permission for $1 _check_execute() { if [ ! -x "$1" ]; then exit_on_error "Cannot execute \"$1\"" fi } # exit, if we have no write permission for $1 _check_write() { if [ ! -w "$1" ]; then exit_on_error "Cannot write to \"$1\"" fi } # exit, if there is no directory $1 or it is not readable and executable _check_dir_exists() { if [ ! -d "$1" ]; then exit_on_error "Directory \"$1\" does not exist" fi _check_read ${1} _check_execute ${1} } # check, whether there is a directory $1 (if not create it) # and make sure, you have read/write/execute permission _check_dir_exists_create() { if [ ! -d "${1}" ]; then log_print \ "WARNING: Directory ${1} does not exist, it will be created." ${_mkdir} ${1} fi _check_read ${1} _check_write ${1} _check_execute ${1} } # check some very basic stuff initial_check() { _check_dir_exists ${CGAL_DIR} _check_write ${CGAL_DIR} for i in ${TMP_LOGFILE} ${TMP_CXX_FILE} ${INSTALL_RIS_LOGFILE} \ ${INSTALL_LOGFILE}; do if [ -f "${i}" ]; then ${_rm} -f ${i} fi done } # fetch CGAL version id from ${CGAL_INCL_DIR}/CGAL/config.h # and compiler-testsuite version id # from ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_TYPENAME.C get_cgal_version() { # this file is assumed to contain one line matching "CGAL_VERSION " # where the third field describes the CGAL version FILE="${CGAL_INCL_DIR}/CGAL/config.h" _check_read ${FILE} CGAL_VERSION=`${_fgrep} "CGAL_VERSION " ${FILE} | \ ${_awk} '{printf "%s",$3}'` # this file is assumed to contain one line matching "revision " # where the fourth field describes the compiler-testsuite version FILE="${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_BUILTIN_BOOL.C" _check_read ${FILE} CGAL_INSTALL_CONF_VERSION=`${_fgrep} 'revision ' ${FILE} | \ ${_awk} '{printf "%s",$4}'` log_print "CGAL version is ${CGAL_VERSION}." log_print \ "Install Testsuite version is ${CGAL_INSTALL_CONF_VERSION}." } # initialize the logfiles init_logfiles() { ${_printf} "%s\n" \ "----------------------------------------------------------" \ >${INSTALL_LOGFILE} log_print "log of $0 $*" log_print "called by $LOGNAME on `date`" log_print "CGAL_DIR is ${CGAL_DIR}" log_print "----------------------------------------------------------" ${_printf} "${_LEFTSPACE}%s\n" \ "----------------------------------------------------------" \ >${INSTALL_RIS_LOGFILE} ${_printf} "%s\n" \ "${_LEFTSPACE}You built CGAL ${CGAL_VERSION} on:" \ >>${INSTALL_RIS_LOGFILE} ${_printf} "${_LEFTSPACE}%s\n" \ "----------------------------------------------------------" \ >>${INSTALL_RIS_LOGFILE} } # first do a confidence test, if ${CGAL_DIR} is really # the CGAL directory # check ${CGAL_CONF_DIR}: create it, if not existent check_conf_dir() { # confidence tests case `${_basename} ${CGAL_DIR}` in CGAL*) log_print "Confidence test passed." ;; *) exit_on_error "The name of this directory" \ "does not start with \"CGAL\"" ;; esac _check_dir_exists ${CGAL_MAKE_DIR} _check_dir_exists ${CGAL_SRC_DIR} _check_dir_exists ${CGAL_INCL_DIR} _check_dir_exists ${CGAL_LIB_DIR} _check_dir_exists ${CGAL_CONF_DIR} _check_dir_exists ${CGAL_TEST_CONF_DIR} _check_dir_exists_create ${CGAL_INSTALL_CONF_DIR} } # print the version number of this file # (in an RCS Revision string this is field nr two) _install_version_number() { ${_printf} "%s\n" "${CGAL_INSTALL_VERSION}" | ${_awk} '{print $2}' } # check, if all needed utility programs are available # (they should be on a unix system, but ...) check_for_utils() { _which='which' _check_for_sysutil basename y _check_for_sysutil dirname y _which=real_which _check_for_sysutil uname y _check_for_sysutil printf y _check_for_sysutil cat y _check_for_sysutil cp y _check_for_sysutil mv y _check_for_sysutil rm y _check_for_sysutil ln y _check_for_sysutil ls y _check_for_sysutil chmod y _check_for_sysutil mkdir y _check_for_sysutil tput y _check_for_sysutil fgrep y _check_for_sysutil sed y _check_for_sysutil awk y if [ -n "${PAGER}" -a ! -x "${PAGER}" ]; then _check_for_sysutil `$_basename ${PAGER}` y PAGER=`eval "echo \$\_$PAGER"` PAGER=`eval "echo ${PAGER}"` fi CGAL_INSTALL_VERSION=`_install_version_number` log_print "This is `basename $0` version ${CGAL_INSTALL_VERSION}." } # guess operating system, write logs via $1 # set SYST to [architecture]_[os][os-version] # try to get architecture from uname -p, # if this fails (e.g. on some linux systems), try uname -m # if this also fails, leave architecture blank guess_os() { _tmp=`${_uname} -p 2>/dev/null` if [ -z "${_tmp}" ]; then _tmp=`${_uname} -m 2>/dev/null` fi if [ -n "${_tmp}" ]; then _tmp=${_tmp}"_" else $1 "WARNING: Could not determine architecture." fi SYST="${_tmp}`${_uname} -s`-`${_uname} -r`" $1 "OS is \"${SYST}\"." } # ------------------------------------------------------------------- # compiler related functions: # ------------------------------------------------------------------- # this header is used to disable the STL-in-std-namespace # for MIPSPRO later than 7.2 write_sgi_no_namespace_header() { ${_printf} "%s\n" ' #if defined(__sgi) && !defined(__GNUC__) && defined(_COMPILER_VERSION) #if (_COMPILER_VERSION >= 721) && defined(_NAMESPACES) #define __STL_NO_NAMESPACES #include #undef __STL_USE_NAMESPACES #endif #endif ' } # give version numbers for GNU GCC # NB: truncated to *.*.* (three numbers) # since we don't want to make a difference between 2.7.2.* # ($* is full path to executable) _gpp_version() { ${_printf} "%s" \ "`${*} --version 2>&1 | ${_awk} '{print $1}' | \ ${_awk} 'BEGIN {FS=\".\"} {print $1\".\"$2\".\"$3}'`" } # give version numbers for SUNPRO CC # ($* is full path to executable) _sunpro_version() { _tmp="`$* -V 2>&1 | ${_fgrep} \"C++\" | ${_awk} '{print $9}'`" if [ -n "${_tmp}" ]; then # sunpro 4.2 ${_printf} "%s" "${_tmp}" else # sunpro 4.1 $* -V 2>&1 | ${_fgrep} "C++" | ${_awk} '{print $NF}' fi } # give version numbers for IRIX MIPSPRO CC # ($* is full path to executable) _sgi_version() { case ${SYST} in *IRIX*5.*) ${_printf} "%s" \ "`${_versions} -b c++_dev | ${_fgrep} c++_dev | \ ${_awk} '{print $5}'`" ;; *IRIX*6.*) # CC -version should be fine if ${*} -version >/dev/null 2>&1; then ${*} -version 2>&1 | ${_awk} '{print $(NF)}' else # ... but not for CC -32 # use versions - looks either like this: # I c++_dev 03/11/97 C++, 7.1 # (version nr on position 5) # or like that: # I c++_dev 11/27/97 C++ Headers and Libraries, 7.2 on irix 6.2 # (version nr on position 8) _tmp="`${_versions} -b c++_dev | ${_fgrep} c++_dev | \ ${_awk} '{print $5}'`" if [ "${_tmp}" = "Headers" ]; then ${_versions} -b c++_dev | ${_fgrep} c++_dev | \ ${_awk} '{print $8}' else ${_printf} "%s" "${_tmp}" fi fi ;; esac } # return the cmdline-switch to add directory variable $1 # to the runtime linker path of current compiler rpath_directive() { if [ -n "${RUNTIME_LINKER_FLAG}" ]; then ${_printf} "%s" "${RUNTIME_LINKER_FLAG}" _where_is "${1}" fi } # -------------------------------------------------------------------- # Now the new function to create the include makefile # for compiler/os combination CGAL_OS_COMPILER set_compiler_flags() { # first, set some compiler/os specific variables CGAL_CXX="`compiler_bin`" case ${CGAL_OS_COMPILER} in *IRIX*5.*CC*) #### settings for sgi mipspro compiler on irix5 ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS= CGAL_SHARED_LIB_LDFLAGS="-lm" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared" WINDOW_DIR="/usr/lib/X11" RUNTIME_LINKER_FLAG="-rpath " LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="dbx" ;; *IRIX*6.*CC*) #### settings for sgi mipspro compiler on irix6 ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS= CGAL_SHARED_LIB_LDFLAGS= CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared" WINDOW_DIR="/usr/lib/X11" RUNTIME_LINKER_FLAG="-rpath " LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="dbx" ;; *IRIX*g++-egcs*|*IRIX*g++-2.8*) #### settings for egcs/gcc2.8 on irix ADDITIONAL_CXXFLAGS="-Wall -ftemplate-depth-25" CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="-lm" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared" WINDOW_DIR="/usr/lib/X11" RUNTIME_LINKER_FLAG="-rpath " LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="" ;; *IRIX*g++-2*) #### settings for GCC2 on irix ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="-lm" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared" WINDOW_DIR="/usr/lib/X11" RUNTIME_LINKER_FLAG='' LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="" ;; *SunOS*5.*CC*) #### settings for sunpro compiler on solaris ADDITIONAL_CXXFLAGS="-pto" CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="\$(CGAL_CXX) -xar -o" CGAL_SHARED_LIB_CXXFLAGS="-pic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -G" WINDOW_DIR="/usr/openwin/lib" RUNTIME_LINKER_FLAG="-R " LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="dbx" ;; *SunOS*5.*g++-egcs*|*SunOS*5.*g++-2.8*) #### settings for egcs/gcc2.8 on solaris ADDITIONAL_CXXFLAGS="-Wall -ftemplate-depth-25" CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -G" WINDOW_DIR="/usr/openwin/lib" RUNTIME_LINKER_FLAG="-R " LONG_NAME_PROBLEM_CXXFLAGS="-g" LONG_NAME_PROBLEM_LDFLAGS="-z nodefs -s" PRINT_STACKTRACE_PROGRAM="gdb" ;; *SunOS*5.*g++*) #### settings for GNU compiler on solaris ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -G" WINDOW_DIR="/usr/openwin/lib" RUNTIME_LINKER_FLAG="-R " LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="gdb" ;; *Linux*g++-egcs*|*Linux*g++-2.8*) #### settings for egcs/gcc2.8 on linux ADDITIONAL_CXXFLAGS="-Wall -ftemplate-depth-25" CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -Xlinker -shared" WINDOW_DIR="/usr/X11R6/lib" RUNTIME_LINKER_FLAG='-Wl,-R' LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="gdb" ;; *Linux*g++*) #### settings for GNU compiler on linux ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -Xlinker -shared" WINDOW_DIR="/usr/X11R6/lib" RUNTIME_LINKER_FLAG='-Wl,-R' LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="gdb" ;; *) #### settings for unknown compiler ADDITIONAL_CXXFLAGS= CGAL_LIB_CXXFLAGS= CGAL_LIB_LDFLAGS= CGAL_LIB_CREATE="ar cr" CGAL_SHARED_LIB_CXXFLAGS="-fpic" CGAL_SHARED_LIB_LDFLAGS="" CGAL_SHARED_LIB_CREATE="`compiler_bin` -G" WINDOW_DIR="/usr/lib/X11" RUNTIME_LINKER_FLAG='' LONG_NAME_PROBLEM_CXXFLAGS="" LONG_NAME_PROBLEM_LDFLAGS="" PRINT_STACKTRACE_PROGRAM="" ;; esac } # -------------------------------------------------------------------------- # Following code is taken from make_redirection_headers # (by Geert-Jan ) # # internal variables from make_redirection_headers # tmp_code_file=redirect_tmpfile.C tmp_header_file=redirect_tmpfile create_replacement_header() # # Create one header as a replacement for a standard header, if necessary. # Should be invoked as # create_replacement_header standard_header_name suffix replacements... # { replacement_header=rh header_name=$1 header_suffix=$2 shift 2 # # Test if the standard header exists. Return if it does. # ${_printf} "%s\n" "#include <$header_name>" > ${tmp_code_file} ${_printf} "%s\n" "int main() {return 0;}" >> ${tmp_code_file} if `compiler_bin` ${tmp_code_file} >/dev/null 2>&1; then return; fi # # The standard header does not exist. # If some of the replacement headers do exist, they included in a # newly created replacement header. # rm -f ${replacement_header} touch ${replacement_header} for arg in $* ; do ${_printf} "%s\n" "#include <$arg>" > ${tmp_code_file} ${_printf} "%s\n" "int main() {return 0;}" >> ${tmp_code_file} if `compiler_bin` ${tmp_code_file} >/dev/null 2>&1; then ${_printf} "%s\n" "#include <$arg>" >> ${replacement_header} fi done # # Move the replacement header to the platform specific config directory. # This directory should be created first. # if [ -s ${replacement_header} ] then mv ${replacement_header} "${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}/CGAL/${header_name}${header_suffix}" fi } create_standard_header_replacements() { ${_printf} "%s\n" "${_LEFTSPACE}Checking for standard header files" # # Decide if a .h suffix is needed for header files. # ${_printf} "%s\n" "typedef int CGAL_nt;" > ${tmp_header_file} ${_printf} "%s\n" "#include <${tmp_header_file}>" > ${tmp_code_file} ${_printf} "%s\n" \ "int main() { CGAL_nt result = 0; return result;}" >> ${tmp_code_file} if `compiler_bin` -I . ${tmp_code_file} >/dev/null 2>&1 then header_suffix="" else header_suffix=".h" fi # # Now create the necessary replacement files from the list below. # while read a b; do ${_printf} "%s" "${_LEFTSPACE}$a ..." create_replacement_header $a "$header_suffix" $b ${_printf} "%s\n" " done." done < ${_file} ${_printf} "%s\n" \ "//" \ >> ${_file} ${_printf} "%s\n" \ "// This software and related documentation is part of the" \ >> ${_file} ${_printf} "%s\n" \ "// Computational Geometry Algorithms Library (CGAL)." \ >> ${_file} ${_printf} "%s\n" \ "//" \ >> ${_file} ${_printf} "%s\n" \ "// release : CGAL-${CGAL_VERSION}" \ >> ${_file} ${_printf} "%s\n" \ "// file : include/CGAL/config/${CGAL_OS_COMPILER}/CGAL/compiler_config.h" \ >> ${_file} ${_printf} "%s\n" \ "// package : Installation (${CGAL_INSTALL_VERSION})" \ >> ${_file} ${_printf} "%s\n" \ "//" \ >> ${_file} ${_printf} "%s\n" \ "// Compiler specific configuration file for CGAL ${CGAL_VERSION}" \ >> ${_file} ${_printf} "%s\n" \ "// System: ${CGAL_OS_COMPILER}" \ >> ${_file} ${_printf} "%s\n" \ "// generated by `${_basename} $0` ${CGAL_INSTALL_VERSION}" \ >> ${_file} ${_printf} "%s\n" \ "// with install testsuite ${CGAL_INSTALL_CONF_VERSION}" \ >> ${_file} ${_printf} "%s\n\n" \ "//" \ >> ${_file} set_stl_version "${INSTALL_VERBOSE}" ${_printf} "%s\n" \ "// CGAL STL version id:" \ >> ${_file} ${_printf} "%s\n\n" \ "#define ${CGAL_STL_VERSION} 1" \ >> ${_file} cd ${CGAL_TEST_CONF_DIR} for i in ${CGAL_TEST_CONF_DIR}/CGAL*.C; do ${_cat} ${i} > ${TMP_CXX_FILE}.C ${_printf} "%s%s\n" \ "//+----------------------------------------------------------" \ "----------------" \ >> ${_file} ${_cat} ${i} | ${_awk} '/\/\/\|/ {print $0}' >> ${_file} ${_printf} "%s%s\n" \ "//+----------------------------------------------------------" \ "----------------" \ >> ${_file} _test_name="`value_of_without \ \"${i}\" \"${CGAL_CONFIG_PREFIX}\" \"\.C\"`" _test_name=`${_basename} "${_test_name}"` _tmp_name="`value_of_without \"_test_name\" \"^NO_\"`" if [ "${_tmp_name}" = "${_test_name}" ]; then _NO='unfortunately.' else _NO='no.' fi if _compile_test \ "${_tmp_name}" \ "${CUSTOM_CXXFLAGS} `stl_cxxflags`" \ "$1" \ "${_NO}" \ && _link_run_test \ "${_tmp_name}" \ "${CUSTOM_LDFLAGS} " \ "$1" \ "${_NO}" then ${_printf} "%s" "//" >> ${_file} fi ${_printf} "%s\n\n" \ "#define ${CGAL_CONFIG_PREFIX}${_test_name} 1" \ >> ${_file} cleanup_after_compile cleanup_after_link_run done create_standard_header_replacements cd ${CGAL_DIR} } #--------------------------------------------------------- # flags for CGAL # print message used to remind the user of setting # his DIR variables correctly _where_is() { if [ -z "`value_of \"${1}\"`" ]; then ${_printf} "%s" "WHERE_IS_YOUR_${1}" else value_of "${1}" fi } cgal_cxxflags() { ${_printf} "%s" "-I`_where_is 'CGAL_INCL_DIR'` " } cgal_ldflags() { ${_printf} "%s" "-L`_where_is 'CGAL_LIB_DIR'`/`full_ostype` " ${_printf} "%s" "`rpath_directive 'CGAL_LIB_DIR'`" if [ -n "${RUNTIME_LINKER_FLAG}" ]; then ${_printf} "%s" "/`full_ostype` " fi } #--------------------------------------------------------- # flags for GMP gmp_cxxflags() { if [ -n "${GMP_SUPPORT}" -a \ "${GMP_INSTALLATION}" != 'c' -a \ "${GMP_INSTALLATION}" != 's' ]; then ${_printf} "%s" "-I`_where_is 'GMP_INCL_DIR'` " fi } gmp_ldflags() { if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" != 'c' -a \ "${GMP_INSTALLATION}" != 's' ]; then ${_printf} "%s" "-L`_where_is 'GMP_LIB_DIR'` " ${_printf} "%s" "`rpath_directive 'GMP_LIB_DIR'` " fi ${_printf} "%s" "-lgmp " fi } gmp_test_cxxflags() { ${_printf} "%s" "${CUSTOM_CXXFLAGS} " if [ -n "${GMP_SUPPORT}" -a "${GMP_INSTALLATION}" = 'c' ]; then cgal_cxxflags fi gmp_cxxflags } gmp_test_ldflags() { ${_printf} "%s" "${CUSTOM_LDFLAGS} " if [ -n "${GMP_SUPPORT}" -a "${GMP_INSTALLATION}" = 'c' ]; then cgal_ldflags fi gmp_ldflags } #--------------------------------------------------------- # flags for STL stl_cxxflags() { if [ "${STL_STATUS}" != "b" ]; then ${_printf} "%s" "-I`_where_is 'STL_DIR'` " fi } stl_test_cxxflags() { ${_printf} "%s" "${CUSTOM_CXXFLAGS} `stl_cxxflags`" } stl_test_ldflags() { ${_printf} "%s" "${CUSTOM_LDFLAGS} -lm" } #--------------------------------------------------------- # flags for LEDA leda_cxxflags() { if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_IDIR}" ]; then ${_printf} "%s" "-I`_where_is 'LEDA_INCL_DIR'` " fi } leda_ldflags() { if [ -n "${LEDA_SUPPORT}" ]; then if [ -n "${NEED_EXTRA_LEDA_LDIR}" ]; then ${_printf} "%s" "-L`_where_is 'LEDA_LIB_DIR'` " ${_printf} "%s" "`rpath_directive 'LEDA_LIB_DIR'` " fi ${_printf} "%s" "-lP -lG -lL " fi } leda_test_cxxflags() { ${_printf} "%s" "${CUSTOM_CXXFLAGS} " leda_cxxflags } leda_test_ldflags() { ${_printf} "%s" "${CUSTOM_LDFLAGS} " leda_ldflags ${_printf} "%s" "-lm " } #--------------------------------------------------------- # all flags # print cxxflags for current setting compiler_flags() { ${_printf} "%s" "${CUSTOM_CXXFLAGS} `cgal_cxxflags``stl_cxxflags``leda_cxxflags``gmp_cxxflags`" } # print ldflags for current setting linker_flags() { ${_printf} "%s" "${CUSTOM_LDFLAGS} `cgal_ldflags`-lCGAL `leda_ldflags``gmp_ldflags`-lm" } # print ldflags for current setting (do not link with cgal lib, # used for test before lib is compiled) linker_flags_no_cgal_lib() { ${_printf} "%s" "${CUSTOM_LDFLAGS} `cgal_ldflags``leda_ldflags``gmp_ldflags`-lm" } # print version number of compiler $1 # (full path to executable) get_compiler_version() { case `_real_basename ${1:-${COMPILER}}` in *CC*) case ${SYST} in *IRIX*) _check_for_sysutil versions y _sgi_version "$*" ;; *SunOS*) _sunpro_version "$*" ;; *) ${_printf} "%s" "UnknownVersion";; esac;; *g++*) _gpp_version "$*";; *) ${_printf} "%s" "UnknownVersion";; esac } # print compiler description of compiler $1 # (executable) get_compiler_description() { case ${1:-${COMPILER}} in *CC*-32*) ${_printf} "%s" "MIPSPRO (o32)";; *CC*-n32*) ${_printf} "%s" "MIPSPRO (n32)";; *CC*-64*) ${_printf} "%s" "MIPSPRO (64)";; *CC*) case ${SYST} in *IRIX*) ${_printf} "%s" "MIPSPRO";; *SunOS*) ${_printf} "%s" "SUNPRO";; *) ${_printf} "%s" "UnknownCompiler";; esac;; *g++*) ${_printf} "%s" "GNU";; *xlC*) ${_printf} "%s" "IBM CSet";; *) ${_printf} "%s" "UnknownCompiler";; esac } # $1 is a compiler string # print compiler basenam compiler_basename() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s",$1}' } # $1 is a compiler string # print compiler description compiler_description() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s",$2}' } # $1 is a compiler string # print compiler executable c_compiler_bin() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s",$3}' } # $1 is a compiler string # print compiler executable compiler_bin() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s",$4}' } # $1 is a compiler string # print compiler executable compiler_version() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s",$5}' } # $1 is a compiler string # print extended compiler description extended_compiler_description() { ${_printf} "%s\n" "${*:-${COMPILER}}" | \ ${_awk} 'BEGIN {FS="@"} {printf "%s %s\n",$2,$5}' } # register compiler with description $*, # iff there is no corresponding config file in CGAL_INSTALL_CONF_DIR # (since in this case it already has been registered) _check_and_register_compiler() { _ORIG_COMPILER="${COMPILER}" COMPILER="${*}" set_ostype file="${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}" if [ -r ${file} ]; then try_to_get_var_from_file COMPILER ${file} if [ ${?} != 0 ]; then log_print "${CGAL_OS_COMPILER} has already been registered." else _register_compiler "${*}" fi else _register_compiler "${*}" fi COMPILER="${_ORIG_COMPILER}" } # register compiler with description $* _register_compiler() { log_print \ "found compiler `extended_compiler_description \"${*}\"`." eval "_COMPILER_${_COMPILER_NUMBER}=\"${*}\"" eval "${_EXPR} ${_COMPILER_NUMBER} + 1" _COMPILER_NUMBER=${_result} } # search for compiler and set COMPILER correspondingly # $1 is the basename of the C compiler executable (e.g. cc) # $2 is the basename of the C++ compiler executable (e.g. CC) # if $3 is non-zero, don't register compiler # return 0, iff found _search_compiler() { if _check_for_util "$2" n tmp1; then _check_for_util "$1" n tmp2 COMPILER="$2@`get_compiler_description \"$2\"`@${_tmp2}@${_tmp1}@`get_compiler_version \"${_tmp1}\"`" if [ -z "$3" ]; then _check_and_register_compiler "${COMPILER}" fi return 0 fi return 1 } # $1 is a compiler string # append $2 to basename $3 to the description field # and $4 to the executable fields _add_flags() { compiler_basename "$1" ${_printf} "%s" "$2@" compiler_description "$1" ${_printf} "%s" "$3@" c_compiler_bin "$1" ${_printf} "%s" "$4@" compiler_bin "$1" ${_printf} "%s" "$4@" compiler_version "$1" } # search for supported compilers search_for_compilers() { guess_os log_print _COMPILER_NUMBER=1 # first check, which config files exist for i in `${_ls} ${CGAL_INSTALL_CONF_DIR}/${SYST}* 2>/dev/null` do try_to_get_var_from_file COMPILER ${i} if [ ${?} != 0 ]; then _register_compiler "${COMPILER}" fi done case ${SYST} in *IRIX64*) if _search_compiler cc CC 'n'; then _check_and_register_compiler \ "`_add_flags \"${COMPILER}\" '-n32' ' (n32)' ' -n32'`" _check_and_register_compiler \ "`_add_flags \"${COMPILER}\" '-32' ' (o32)' ' -32'`" if [ -n "${SUPPORT_MIPSPRO_64}" ]; then _check_and_register_compiler \ "`_add_flags \"${COMPILER}\" '-64' ' (64)' ' -64'`" fi fi _search_compiler gcc g++ '' ;; *IRIX*-6*) if _search_compiler cc CC 'n'; then _check_and_register_compiler \ "`_add_flags \"${COMPILER}\" '-n32' ' (n32)' ' -n32'`" _check_and_register_compiler \ "`_add_flags \"${COMPILER}\" '-32' ' (o32)' ' -32'`" fi _search_compiler gcc g++ '' ;; *IRIX*|*SunOS*) _search_compiler cc CC '' _search_compiler gcc g++ '' ;; *) _search_compiler gcc g++ '' ;; esac if [ ${_COMPILER_NUMBER} = 1 ]; then exit_on_error "Couldn't find any compiler" fi _set_compiler 1 write_buffer "\n\n${_LEFTSPACE}Choosing compiler `extended_compiler_description`.\n" flush_buffer _choose_compiler } # our compiler shall be ${*} (absolute path) # (used in non-interactive mode) compiler_absolute() { _args="${*}" _tmp="`_real_basename \"${*}\"`" shift ${_printf} "%s" "${_tmp}" # concat options - replace space by "-": _tmp1=`${_printf} "%s\n" "${*}" | ${_sed} 's/"//g;s/ -/-/g' | \ ${_sed} "s/'//g;s/ /-/g"` if [ -n "${_tmp1}" ]; then ${_printf} "%s" "${_tmp1}" fi ${_printf} "%s" "@" get_compiler_description "${_args}" ${_printf} "%s" "@" _tmp1=`_real_dirname "${_args}"` if [ "${_tmp1}" != "." ]; then ${_printf} "%s" "${_tmp1}/" fi # guess C compiler: case ${_tmp} in g++) ${_printf} "%s" "gcc";; xlC) ${_printf} "%s" "xlc";; *) ${_printf} "%s" "cc";; esac _tmp1=`_real_options "${_args}"` if [ -n "${_tmp1}" ]; then ${_printf} "%s" " ${_tmp1}" fi ${_printf} "%s" "@${_args}@" get_compiler_version "${_args}" } # --------------------------------------------------------------------- # arithmetic functions # --------------------------------------------------------------------- # since this great shell does not generally support # arithmetics, we have to use a supplement in some cases. # this may be expr or bc. # evaluate expression $1 $2 $3 using shell let # and store result in _result _let_expr() { if ! eval "let _result=${1}${2}${3}"; then exit_on_error "Cannot evaluate \"${1}${2}${3}\" in _let_expr()" fi } # evaluate expression $1 $2 $3 using expr # and store result in _result _expr_expr() { # we have to do the indirection in three steps # (since there can be only one `...` expression level) eval "_result=`/bin/expr ${1} \"${2}\" ${3}`" if [ $? != 0 ]; then exit_on_error "Cannot evaluate \"${1}\" in _expr_expr()" fi } # evaluate expression $1 $2 $3 using bc # and store result in _result _bc_expr() { # we have to do the indirection in three steps # (since there can be only one `...` expression level) eval "_result=`echo $1 \"$2\" $3 | /bin/bc`" if [ $? != 0 ]; then exit_on_error "Cannot evaluate \"${1}\" in _bc_expr()" fi } # set _EXPR such that eval "$_EXPR op1 op op2" evaluates # the expression and stores the result in _result set_expr() { # first try shell let, then expr, bc, dc and csh if /bin/sh -tc 'e=0; let e+=1' 2>/dev/null; then _EXPR=_let_expr elif [ -x /bin/expr ]; then _EXPR=_expr_expr elif [ -x /bin/bc ]; then _EXPR=_bc_expr else exit_on_error "Cannot find either of \"expr\" or \"bc\"" \ "nor does /bin/sh support \"let\"" fi log_print "use $_EXPR() for evaluating arithmetic expressions." } # --------------------------------------------------------------------- # terminal related functions # --------------------------------------------------------------------- # --------------------------------------------------------------------- # read an input string # (since 'read' breaks its input according to field separator IFS # (normally including space), we have to change IFS to be able # to read multiword strings like needed for the custom compiler options) _read() { _tmp=${IFS} IFS='\n' read KEY IFS=${_tmp} } # --------------------------------------------------------------------- # BUFFERED OUTPUT: # for the sake of efficiency we buffer all output clear_buffer() { _BUF='' } # print buffer flush_buffer() { ${_printf} "${_BUF}" clear_buffer } # write $* to buffer write_buffer() { _BUF="$_BUF$*" } # --------------------------------------------------------------------- # STRING FUNCTIONS: print_with_indent() { if [ -z "$*" ]; then _read ${_printf} "${_LEFTSPACE}${KEY}\n" else ${_printf} "${_LEFTSPACE}${*}\n" fi } print_as_shell_comment() { if [ -z "$*" ]; then _read ${_printf} "# ${KEY}\n" else ${_printf} "# ${*}\n" fi } # print $2 times string $1 ($1 must not contain '@'!) string_n_print() { _tmp=`eval "printf \"\`${_printf} \"$1@$2\" | ${_awk} 'BEGIN {FS=\"@\"} { for ( i=0; i<$2; ++i) printf $1}'\`\""` write_buffer "${_tmp}" } # count length of variable $1 (in characters) length() { # first try ${#var} substitution, if that fails wc # if neither succeeds, we just return 30 # (this function is used to layout the menus, # so worst case it just looks a little bit ugly ;) if /bin/sh -tc 'echo ${#1} >/dev/null' 2>/dev/null then return ${#1} elif [ -x /bin/wc ]; then return `${_printf} "%s" "$1" | /bin/wc -c` else return 30 fi } # --------------------------------------------------------------------- # FUNCTIONS FOR MENUS: clear_screen() { write_buffer "$_clear_screen\n" } # moves cursor up $1 lines go_up_lines() { string_n_print '${_line_up}' $1 write_buffer "\r" } # moves cursor down $1 lines go_down_lines() { string_n_print '\\\\\\n' $1 } # print a line containing string $1 # bounded by two stars on each side print_line() { write_buffer "$_MENU_LINE_EMPTY\r${_LEFTSPACE}** $1\n" } # print string $1 on possibly several lines # bounded by two stars on each side # (the lines are indented by 5 more chars, since this # is only used for displaying the custom options) print_multi_line() { _tmp=`${_printf} "%s" "$1" | \ eval "${_awk} \`${_printf} \"${_MULTILINE_LAYOUT_AWK_PROG}\" dummy\`"` write_buffer "${_tmp}" } # print an empty line bounded by two stars on each side print_empty_line() { write_buffer "$_MENU_LINE_EMPTY\n" } # print a line filled with stars print_filled_line() { write_buffer "$_MENU_LINE_FILLED\n" } # give a prompt with text $1 print_prompt() { write_buffer "$_MENU_LINE_EMPTY\r${_LEFTSPACE}** $1" flush_buffer } # print a centered line with text $1 print_center_line() { length "`echo "$1"`" l=$? eval "$_EXPR $_MENU_WIDTH \* 10" eval "$_EXPR $_result - $l" eval "$_EXPR $_result / 2" write_buffer "$_MENU_LINE_EMPTY\r${_LEFTSPACE}**" string_n_print " " $_result write_buffer "$1\n" } # print a headline with text $1 print_headline() { length "`echo "$1"`" l=$? eval "$_EXPR $_MENU_WIDTH \* 10" eval "$_EXPR $_result - $l" eval "$_EXPR $_result / 2" write_buffer "$_MENU_LINE_EMPTY\r${_LEFTSPACE}**" string_n_print " " $_result write_buffer "$1\n" write_buffer "$_MENU_LINE_EMPTY\r${_LEFTSPACE}**" string_n_print " " $_result string_n_print "=" $l write_buffer "\n" print_empty_line } # wait until enter is pressed wait_for_enter() { if [ -n "${INSTALL_INTERACTIVE}" ]; then print_center_line "Please press to continue." print_filled_line flush_buffer read dummy else print_center_line "D O N E" print_filled_line flush_buffer fi } # setup two strings for printing the menu set_menu_lines() { _MENU_LINE_FILLED="${_LEFTSPACE}**" _MENU_LINE_EMPTY="${_LEFTSPACE}**" clear_buffer string_n_print "**********" ${_MENU_WIDTH} _MENU_LINE_FILLED=${_MENU_LINE_FILLED}${_BUF}"**" clear_buffer string_n_print " " ${_MENU_WIDTH} _MENU_LINE_EMPTY=${_MENU_LINE_EMPTY}${_BUF}"**" clear_buffer eval "${_EXPR} ${_MENU_WIDTH} \* 10" eval "${_EXPR} ${_result} - 10" _MULTILINE_LAYOUT_AWK_PROG="'{ for (i=1; i <= length(\$0); i+=${_result}) printf \"${_MENU_LINE_EMPTY}"'\\r'"${_LEFTSPACE}** "'%%s''\\''\\n'"\",substr(\$0,i,${_result})}'" } # set some variables for output set_terminal_variables() { ${_tput} smcup # turn on cup (see man terminfo) _line_up=`${_tput} cuu1`"\r" _bold_on=`${_tput} bold` _bold_off=`${_tput} sgr0` _clear_screen=`${_tput} clear` _clear_end_of_display=`${_tput} ed` eval "${_EXPR} ${_MENU_WIDTH} \* 10" length "${_LEFTSPACE}" eval "${_EXPR} ${_result} + $?" # for two-star('**') border eval "${_EXPR} ${_result} + 4" if [ `${_tput} cols` -lt ${_result} ]; then print_filled_line print_line \ "${_bold_on}WARNING${_bold_off}: Your terminal screen is too narrow." print_line "It should have at least ${_result} columns." print_filled_line wait_for_enter fi } # --------------------------------------------------------------------- # FILE / DIR FUNCTIONS: # some confidence test for the directories # (return 0, iff problem - output with command $1) check_GMP_SUPPORT() { if [ "${GMP_SUPPORT}" != "" -a "${GMP_SUPPORT}" != "_GMP" ]; then $1 "WARNING: GMP_SUPPORT is not set correctly." return 0 fi return 1 } check_GMP_INSTALLATION() { if [ -n "${GMP_INSTALLATION}" -a \ "${GMP_INSTALLATION}" != 'x' -a \ "${GMP_INSTALLATION}" != 'c' -a \ "${GMP_INSTALLATION}" != 'z' -a \ "${GMP_INSTALLATION}" != 'e' -a \ "${GMP_INSTALLATION}" != 's' ]; then $1 "WARNING: GMP_INSTALLATION should be \"e\", \"z\"," $1 " \"c\", \"x\", \"s\" or empty." return 0 fi return 1 } check_GMP_INCL_DIR() { if [ -n "${GMP_INCL_DIR}" ]; then if [ ! -r ${GMP_INCL_DIR}/gmp.h ]; then $1 "WARNING: GMP_INCL_DIR should contain" $1 " gmp.h." else return 1 fi fi return 0 } check_GMP_LIB_DIR() { if [ -n "${GMP_LIB_DIR}" ]; then if [ ! -r ${GMP_LIB_DIR}/libgmp.a -a \ ! -r ${GMP_LIB_DIR}/libgmp.so ]; then $1 "WARNING: GMP_LIB_DIR should contain" $1 " libgmp.a or libgmp.so." else return 1 fi fi return 0 } # user's business check_CUSTOM_CXXFLAGS() { return 1 } # user's business check_CUSTOM_LDFLAGS() { return 1 } check_NEED_EXTRA_LEDA_IDIR() { if [ -n "${NEED_EXTRA_LEDA_IDIR}" -a \ "${NEED_EXTRA_LEDA_IDIR}" != 'y' -a \ "${NEED_EXTRA_LEDA_IDIR}" != 'x' ]; then $1 "WARNING: NEED_EXTRA_LEDA_IDIR should be \"x\", \"y\" or empty." return 0 fi return 1 } check_NEED_EXTRA_LEDA_LDIR() { if [ -n "${NEED_EXTRA_LEDA_LDIR}" -a \ "${NEED_EXTRA_LEDA_LDIR}" != 'y' -a \ "${NEED_EXTRA_LEDA_LDIR}" != 'x' ]; then $1 "WARNING: NEED_EXTRA_LEDA_LDIR should be \"x\", \"y\" or empty." return 0 fi return 1 } check_LEDA_INCL_DIR() { if [ -n "${LEDA_INCL_DIR}" ]; then if [ ! -d $LEDA_INCL_DIR/LEDA ]; then $1 "WARNING: LEDA_INCL_DIR should contain" $1 " a subdirectory LEDA." elif [ ! -r $LEDA_INCL_DIR/LEDA/basic.h ]; then $1 "WARNING: LEDA_INCL_DIR should contain" $1 " LEDA/basic.h." else return 1 fi fi return 0 } check_LEDA_LIB_DIR() { if [ -n "${LEDA_LIB_DIR}" ]; then if [ ! -r $LEDA_LIB_DIR/libL.a -a ! -r $LEDA_LIB_DIR/libL.so ]; then $1 "WARNING: LEDA_LIB_DIR should contain libL.a or libL.so." else return 1 fi fi return 0 } check_STL_DIR() { if [ -n "${STL_DIR}" ]; then if [ ! -r $STL_DIR/iterator.h ]; then $1 "WARNING: STL_DIR should contain iterator.h." else return 1 fi fi return 0 } check_LEDA_SUPPORT() { if [ "${LEDA_SUPPORT}" != "" -a "${LEDA_SUPPORT}" != "_LEDA" ]; then $1 "WARNING: LEDA_SUPPORT is not set correctly." return 0 fi return 1 } check_STL_STATUS() { if [ "${STL_STATUS}" != "b" -a "${STL_STATUS}" != "x" \ -a "${STL_STATUS}" != "e" ]; then $1 "WARNING: STL_STATUS is not set correctly." return 0 fi return 1 } check_CGAL_STL_VERSION() { case ${CGAL_STL_VERSION} in CGAL_STL_GCC|CGAL_STL_HP|CGAL_STL_SGI_WWW|CGAL_STL_SGI_3_0|\ CGAL_STL_SGI_WWW_OLD|CGAL_STL_SGI_CC|CGAL_STL_UNKNOWN) return 1;; *) $1 "WARNING: CGAL_STL_VERSION is not set correctly." return 0;; esac } check_CGAL_INSTALL_VERSION() { case ${CGAL_INSTALL_VERSION} in *.*) return 1;; *) $1 "WARNING: CGAL_INSTALL_VERSION is not set correctly." return 0;; esac } check_COMPILER() { _check_comp_executable `compiler_bin` return 1 } # try to read variable $1 from file $2 # (usually this is $CGAL_DIRECTORY_FILE) # (and run "check_$1", if you got it) # return 0, iff something went wrong try_to_get_var_from_file() { if [ -r ${2} ]; then _awkprg="/${1}/"'{print $0}' _tmp2=`${_awk} "${_awkprg}" ${2}` if [ -n "${_tmp2}" ]; then _tmp2=`${_printf} "%s\n" "${_tmp2}" | \ ${_awk} '{for (i=4; i." eval $1="${_tmp2}" eval "check_${1} log_print" return ${?} else log_print \ "WARNING: cannot find field ${1} in file `${_basename} ${2}`." fi else log_print "WARNING: cannot find file ${2}." fi # delete previous value of ${1} eval ${1}='' return 0 } # --------------------------------------------------------------------- # THE MENUS: # --------------------------------------------------------------------- # --------------------------------------------------------------------- # compiler menu # # cleanup after compilation # (this is not called by _compile_test but has to be called # by the caller of _compile_test, # since it is not clear whether the files are still needed # for linking or not) cleanup_after_compile() { # remove tmp C++ file ${_rm} -f ${TMP_CXX_FILE}.C # remove sunpro template database ${_rm} -rf Templates.DB # remove irix mipspro template database ${_rm} -rf ii_files # remove tmp object file ${_rm} -f ${TMP_CXX_FILE}.o # remove log file ${_rm} -f ${TMP_LOGFILE} } # run a compiler test named $1, return 0, iff ok # if $2 is empty, use standard compiler flags # if $2 is non-empty, use it as compiler flags # if $3 is non-empty, inform about eventually occurring problems # if $4 is non-empty, it is the message to give # in case compilation fails (defaults to 'no.') _compile_test() { # add newlines to ${TMP_CXX_FILE}.C (ANSI) ${_printf} "\n\n" >> ${TMP_CXX_FILE}.C ${_printf} "%s" "${_LEFTSPACE}Testing for $1 ..." # set flags if [ -z "$2" ]; then _flags="`compiler_flags`" else _flags="$2" fi _flags="${_flags} -c ${TMP_CXX_FILE}.C -o ${TMP_CXX_FILE}.o" # compile ${_printf} "%s\n%s\n" \ "Compiler call:" "--------------" >${TMP_LOGFILE} ${_printf} "%s" \ "`compiler_bin` ${_flags}" >>${TMP_LOGFILE} ${_printf} "\n\n%s\n" \ "Got the following error messages:" >>${TMP_LOGFILE} ${_printf} "%s\n" \ "---------------------------------" >>${TMP_LOGFILE} eval "`compiler_bin` ${_flags} >>${TMP_LOGFILE} 2>&1" if [ $? = 0 ]; then log_print "$1 test compiled." return 0 else if [ -n "$3" ]; then if [ -n "${INSTALL_INTERACTIVE}" ]; then log_print "ERROR: $1 test did NOT compile." write_buffer "\n" print_filled_line print_empty_line print_headline "Compilation failed" print_center_line "You will be shown a log now ..." wait_for_enter ${_cat} ${TMP_LOGFILE} | ${PAGER:-${_cat}} write_buffer "\n" print_filled_line wait_for_enter else ${_printf} "%s\n\n" " compilation failed." ${_cat} ${TMP_LOGFILE} ${_printf} "%s\n\n" \ "--------------------------------------------------------" fi else log_print "remark: $1 test did not compile." ${_printf} "%s\n" " ${4:-no.}" fi return 1 fi } # cleanup after compilation cleanup_after_link_run() { cleanup_after_compile # remove executable and core ${_rm} -f ${TMP_CXX_FILE} core } # run a link&run test named $1, return 0, iff ok # if $2 is empty, use standard linker flags # if $2 is non-empty, use it as linker flags # if $3 is non-zero, inform about eventually occurring problems _link_run_test() { # set flags if [ -z "$2" ]; then _flags="`linker_flags_no_cgal_lib`" else _flags="$2" fi _flags="-o ${TMP_CXX_FILE} ${TMP_CXX_FILE}.o ${_flags}" # link ${_printf} "%s\n%s\n" "Linker call:" "--------------" >${TMP_LOGFILE} ${_printf} "%s\n\n" "`compiler_bin` ${_flags}" >>${TMP_LOGFILE} ${_printf} "%s\n" "Got the following error messages:" >>${TMP_LOGFILE} ${_printf} "%s\n" "---------------------------------" >>${TMP_LOGFILE} eval "`compiler_bin` ${_flags} >>${TMP_LOGFILE} 2>&1" i=$? j=1 if [ $i = 0 ]; then log_print "$1 test linking succeeded." # run ${_printf} "%s\n" \ "Run program `${_basename} ${TMP_CXX_FILE}`:" >>${TMP_LOGFILE} ${_printf} "%s\n\n" \ "----------------------" >>${TMP_LOGFILE} ${_printf} "%s\n" "Got the following output:" >>${TMP_LOGFILE} ${_printf} "%s\n" "---------------------------------" >>${TMP_LOGFILE} eval "${TMP_CXX_FILE} >>${TMP_LOGFILE} 2>&1" j=$? if [ $j = 0 ]; then log_print "$1 test execution succeeded." else if [ -n "$3" ]; then log_print "ERROR: $1 test execution FAILED." else log_print "remark: $1 test execution failed." fi fi else if [ -n "$3" ]; then log_print "ERROR: $1 test linking FAILED." else log_print "remark: $1 test linking failed." fi fi if [ $j = 0 -a $i = 0 ]; then ${_printf} "%s\n" " ok." cleanup_after_link_run return 0 else if [ -n "$3" ]; then if [ -n "${INSTALL_INTERACTIVE}" ]; then log_print "ERROR: $1 test FAILED." write_buffer "\n" print_filled_line print_empty_line print_headline "Linking or execution failed" print_center_line "You will be shown a log now ..." wait_for_enter $_cat ${TMP_LOGFILE} | ${PAGER:-${_cat}} write_buffer "\n" print_filled_line wait_for_enter else ${_printf} "%s\n\n" " linking or execution failed." ${_cat} ${TMP_LOGFILE} printf "%s\n\n" \ "--------------------------------------------------------" fi else ${_printf} "%s\n" " no." fi cleanup_after_link_run return 1 fi } # --------------------------------------------------------------------- # LEDA TEST: # test if leda header files are in some sys include dir # and sets NEED_EXTRA_LEDA_IDIR correspondingly # ($1 nonzero indicates verbosity) # [ checks for the existence of , since this # is a file where no LEDA lib has to be linked in order to # produce an executable; needs some # mem_manager stuff ... ] test_for_leda_incl_in_sys_incl() { ${_printf} "%s\n" " #include int main() { return 0; }" > ${TMP_CXX_FILE}.C if _compile_test "LEDA sysincl" "${CUSTOM_CXXFLAGS} " "$1"; then cleanup_after_compile ${_printf} "%s\n" " ok." NEED_EXTRA_LEDA_IDIR='' return 0 fi cleanup_after_compile NEED_EXTRA_LEDA_IDIR='y' return 1 } # test if leda libs are in some sys lib dir # and sets NEED_EXTRA_LEDA_LDIR correspondingly # ($1 nonzero indicates verbosity) test_for_leda_lib_in_sys_lib() { ${_printf} "%s\n" " int main() { return 0; }" > ${TMP_CXX_FILE}.C if _compile_test "LEDA syslibs" "${CUSTOM_CXXFLAGS} " "$1"; then if _link_run_test "LEDA syslibs" \ "${CUSTOM_LDFLAGS} -lP -lG -lL -lm" "$1"; then NEED_EXTRA_LEDA_LDIR='' return 0 fi fi NEED_EXTRA_LEDA_LDIR='y' return 1 } # test if LEDA setting works (return 0, iff ok) # ($1 nonzero indicates verbosity) test_leda() { if [ -n "${LEDA_SUPPORT}" ]; then write_sgi_no_namespace_header > ${TMP_CXX_FILE}.C ${_printf} "%s\n" ' #include #include #include #include typedef integer I; #include int main() { I a( 123456); I b( 456789); assert( a + b == I( 580245)); assert( a - b == I( -333333)); return 0; }' >> ${TMP_CXX_FILE}.C if _compile_test LEDA "`leda_test_cxxflags`" $1 && \ _link_run_test LEDA "`leda_test_ldflags`" $1 then LEDA_TEST_PASSED='y' return 0 else LEDA_TEST_PASSED='' return 1 fi else return 0 fi } # --------------------------------------------------------------------- # STL TESTS: # (I use "@error" instead of "#error" to indicate an error, # since sunpro CC treats the latter as warnings ...) # test, if STL is original HP from 1994 (or compatible?) # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) _test_hp_1994_stl() { ${_printf} "%s\n" ' #include #include #include #define Allocator allocator #include #ifndef LIST_H @error Program does not use the HP STL from 1994. #endif #ifdef Allocator @error Program does not use the HP STL from 1994. #endif int main() { list l; l.push_back(42); assert( 42 == *(l.begin())); return 0; }' > ${TMP_CXX_FILE}.C _compile_test "HP STL" "`stl_test_cxxflags` " $1 && \ _link_run_test "HP STL" "`stl_test_ldflags` " $1 return $? } # test, if STL is SGI STL from 1996 (or compatible?) # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) _test_sgi_1996_stl() { ${_printf} "%s\n" ' #include #include #include #define Allocator allocator #include #ifndef __SGI_STL_LIST_H @error Program does not use the old SGI STL from the web from 1996. #endif #ifndef Allocator @error Program does not use the old SGI STL from the web from 1996. #endif template< class T> inline int check( const __list_const_iterator&){ return 1; } int main() { const list l; assert( check( l.begin())); return 0; }' > ${TMP_CXX_FILE}.C _compile_test "SGI 1996 STL" "`stl_test_cxxflags` " $1 && \ _link_run_test "SGI 1996 STL" "`stl_test_ldflags` " $1 return $? } # test, if STL is SGI STL supplied with compiler (or compatible?) # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) _test_sgi_cc_stl() { ${_printf} "%s\n" ' #include #include #include #define Allocator allocator #include #ifndef LIST_H @error Program does not use the SGI STL shipped with C++ from 1996. #endif #ifndef Allocator @error Program does not use the SGI STL shipped with C++ from 1996. #endif int main() { list l; l.push_back(42); assert( 42 == *(l.begin())); return 0; }' > ${TMP_CXX_FILE}.C _compile_test "SGI CC STL" "`stl_test_cxxflags` " $1 && \ _link_run_test "SGI CC STL" "`stl_test_ldflags` " $1 return $? } # test, if STL is SGI STL from June 1997 (or compatible?) # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) _test_sgi_june_1997_stl() { ${_printf} "%s\n" ' #include #include #include #define Allocator allocator #include #ifndef __SGI_STL_LIST_H @error Program does not use the SGI STL from June 13, 1997. #endif #ifndef Allocator @error Program does not use the SGI STL from June 13, 1997. #endif template< class T, class Ref> inline int check( const __list_iterator&){ return 1; } int main() { list l; assert( check( l.begin())); return 0; }' > ${TMP_CXX_FILE}.C _compile_test "SGI 6/97 STL" "`stl_test_cxxflags` " $1 && \ _link_run_test "SGI 6/97 STL" "`stl_test_ldflags` " $1 return $? } # test, if STL is SGI STL 3.0 (or compatible?) # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) _test_sgi_3_0_stl() { write_sgi_no_namespace_header > ${TMP_CXX_FILE}.C ${_printf} "%s\n" ' #include #include #include #define Allocator allocator #include #ifndef __SGI_STL_LIST_H #error Program does not use the SGI STL 3.0. #endif #ifndef Allocator #error Program does not use the SGI STL 3.0. #endif template< class T, class Ref, class Ptr> inline int check( const __list_iterator&){ return 1; } int main() { list l; assert( check( l.begin())); return 0; }' >> ${TMP_CXX_FILE}.C _compile_test "SGI STL 3.0" "`stl_test_cxxflags` " $1 && \ _link_run_test "SGI STL 3.0" "`stl_test_ldflags` " $1 return $? } # test, if STL works # (return 0, iff it is) # (test program due to Lutz Kettner) # ($1 nonzero indicates verbosity) # ($2 gives comment for _compile_test) test_stl_general() { write_sgi_no_namespace_header > ${TMP_CXX_FILE}.C ${_printf} "%s\n" ' #include #include #include #include #include #include list lst( char* s) { list x; while (*s != '\0') x.push_back( *s++); return x; } int main() { list list1 = lst( "mark twain"); reverse( list1.begin(), list1.end()); assert( list1 == lst( "niawt kram")); return 0; }' >> ${TMP_CXX_FILE}.C if [ -z "$1" ]; then _compile_test "${2}" "${CUSTOM_CXXFLAGS} " '' && \ _link_run_test "${2}" "${CUSTOM_LDFLAGS} " '' else _compile_test "${2}" "`stl_test_cxxflags` " $1 && \ _link_run_test "${2}" "`stl_test_ldflags` " $1 fi return $? } # determine which STL version is used # ($1 nonzero indicates verbosity) # we have the following different types: # CGAL_STL_GCC # CGAL_STL_HP # CGAL_STL_SGI_3_0 # CGAL_STL_SGI_WWW # CGAL_STL_SGI_WWW_OLD # CGAL_STL_SGI_CC # CGAL_STL_UNKNOWN set_stl_version() { if [ "`compiler_basename`" = "g++" -a \ "`compiler_version`" = "2.7.2" -a \ "${STL_STATUS}" = "b" ] then CGAL_STL_VERSION='CGAL_STL_GCC' elif _test_sgi_3_0_stl $1; then CGAL_STL_VERSION='CGAL_STL_SGI_3_0' elif _test_sgi_june_1997_stl $1; then CGAL_STL_VERSION='CGAL_STL_SGI_WWW' elif _test_sgi_1996_stl $1; then CGAL_STL_VERSION='CGAL_STL_SGI_WWW_OLD' elif _test_sgi_cc_stl $1; then CGAL_STL_VERSION='CGAL_STL_SGI_CC' elif _test_hp_1994_stl $1; then CGAL_STL_VERSION='CGAL_STL_HP' else CGAL_STL_VERSION='CGAL_STL_UNKNOWN' fi log_print "STL type seems to be ${CGAL_STL_VERSION}." } # checks, if current compiler has a builtin STL # (iff so, return 0) and sets STL_STATUS # (and CGAL_STL_VERSION) correspondingly test_for_builtin_stl() { _OLD_STL_STATUS=${STL_STATUS} STL_STATUS='b' if test_stl_general "${INSTALL_VERBOSE}" 'builtin STL'; then log_print "`extended_compiler_description` seems to have builtin STL." if [ "${_OLD_STL_STATUS}" = "x" ]; then log_print "... but we do not use it." STL_STATUS="x" fi test_compiler_specifica "${INSTALL_VERBOSE}" STL_TEST_PASSED='y' return 0 else log_print "`extended_compiler_description` seems NOT to have builtin STL." STL_STATUS='e' STL_TEST_PASSED='' return 1 fi } # test, if STL works # return 0, if it does, return 1 otherwise test_stl() { if test_stl_general 'v' 'STL'; then test_compiler_specifica "${INSTALL_VERBOSE}" STL_TEST_PASSED='y' return 0 fi STL_TEST_PASSED='' return 1 } # --------------------------------------------------------------------- # GNU GMP TEST: # gmp test from the gmp/README # (return 0, iff it works) # ($1 is either 'GMP' or 'GMP syslib') # ($2 nonzero indicates verbosity) test_gmp() { if [ -n "${GMP_SUPPORT}" ]; then ${_printf} "%s\n" ' #include #include "gmp.h" int main () { mpz_t b, p; mpz_init (p); mpz_init_set_str (b, "31", 0); mpz_mul_ui (p, b, 75); /* generate product */ mpz_out_str (stdout, 10, p); /* print number without newline */ puts (""); /* print newline */ return 0; }' > ${TMP_CXX_FILE}.C if _compile_test "$1" "`gmp_test_cxxflags`" "$2" && \ _link_run_test "$1" "`gmp_test_ldflags`" "$2" then GMP_TEST_PASSED='y' return 0 else GMP_TEST_PASSED='' return 1 fi else return 0 fi } # set variable CGAL_OS_COMPILER according to the current # compiler settings set_ostype() { if [ -n "`compiler_version`" ]; then CGAL_OS_COMPILER="${SYST}_`compiler_basename`-`compiler_version`" else CGAL_OS_COMPILER="${SYST}_`compiler_basename`" fi } # return the full os/compiler string # (i.e. including LEDA extension) full_ostype() { ${_printf} "%s" "${CGAL_OS_COMPILER}${LEDA_SUPPORT}" } # print the current os/compiler in a readable fashion # $1 is the print command print_os_setting() { ${1} "OS:\t\t${SYST}" ${1} "COMPILER:\t`extended_compiler_description`" ${1} "STL:\t\t${CGAL_STL_VERSION}" _set_tmp_to_not_or_not "${LEDA_SUPPORT}" ${1} "LEDA:\t\t${_tmp}supported" _set_tmp_to_not_or_not "${GMP_SUPPORT}" ${1} "GMP:\t\t${_tmp}supported" } set_lib_compiled_flag() { # does there exist a lib for this os/compiler? if [ -r ${CGAL_LIB_DIR}/`full_ostype`/${CGAL_LIB_NAME}.a ]; then LIB_COMPILED='ok' else LIB_COMPILED='' fi } # set GMP_INSTALLATION # first check for sysdir installation, then in CGAL tree, # finally an external installation # return 0, iff one of these test succeeded # ($1 non-empty indicates verbosity) search_gmp() { GMP_INSTALLATION='s' if test_gmp 'GMP syslib' "$1"; then log_print "remark: GMP is installed in sysdirs." else make_lib_dir GMP_INSTALLATION='c' if test_gmp 'GMP CGAL' "$1"; then log_print "remark: GMP is installed in CGAL tree." else GMP_INSTALLATION='e' log_print "remark: GMP is not installed." return 1 fi fi return 0 } # --------------------------------------------------------------------- # compiler related functions # # try to retrieve the compiler specific settings from # file ${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER} retrieve_compiler_settings() { _file="${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}" _tmp_version=${CGAL_INSTALL_VERSION} if try_to_get_var_from_file CGAL_INSTALL_VERSION "${_file}"; then SETUP_COMPLETE='' CGAL_INSTALL_VERSION=${_tmp_version} elif [ "${_tmp_version}" != "${CGAL_INSTALL_VERSION}" ]; then # this config file was generated by an older install log_print "WARNING: config file `$_basename ${_file}`" log_print " was generated by another `$_basename $0` version." SETUP_COMPLETE='' CGAL_INSTALL_VERSION=${_tmp_version} else SETUP_COMPLETE='y' fi # these two have to be ok: if try_to_get_var_from_file LEDA_SUPPORT "${_file}"; then LEDA_SUPPORT='' fi # LEDA specific stuff: if try_to_get_var_from_file NEED_EXTRA_LEDA_IDIR "${_file}" || \ try_to_get_var_from_file NEED_EXTRA_LEDA_LDIR "${_file}"; then if [ -n "${LEDA_SUPPORT}" ]; then LEDA_SUPPORT='' SETUP_COMPLETE='' fi NEED_EXTRA_LEDA_IDIR='n' NEED_EXTRA_LEDA_LDIR='n' fi if try_to_get_var_from_file LEDA_INCL_DIR "${_file}"; then if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_IDIR}" ]; then SETUP_COMPLETE='' fi fi if try_to_get_var_from_file LEDA_LIB_DIR "${_file}"; then if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_LDIR}" ]; then SETUP_COMPLETE='' fi fi # STL specific stuff: if try_to_get_var_from_file STL_STATUS "${_file}"; then # couldn't get STL_STATUS SETUP_COMPLETE='' fi if try_to_get_var_from_file STL_DIR "${_file}"; then if [ "${STL_STATUS}" != "b" ]; then SETUP_COMPLETE='' fi fi if try_to_get_var_from_file CGAL_STL_VERSION "${_file}"; then # couldn't get CGAL_STL_VERSION CGAL_STL_VERSION='CGAL_STL_UNKNOWN' SETUP_COMPLETE='' fi if try_to_get_var_from_file CUSTOM_CXXFLAGS "${_file}"; then CUSTOM_CXXFLAGS='' fi if try_to_get_var_from_file CUSTOM_LDFLAGS "${_file}"; then CUSTOM_LDFLAGS='' fi # GMP specific stuff: if try_to_get_var_from_file GMP_SUPPORT "${_file}" ||\ try_to_get_var_from_file GMP_INSTALLATION "${_file}"; then GMP_INSTALLATION='' GMP_SUPPORT='' SETUP_COMPLETE='' fi if try_to_get_var_from_file GMP_INCL_DIR "${_file}"; then if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then SETUP_COMPLETE='' fi fi fi if try_to_get_var_from_file GMP_LIB_DIR "${_file}"; then if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then SETUP_COMPLETE='' fi fi fi set_lib_compiled_flag } # used by store_compiler_settings to store variable $1 # into the config file _store_install_config_variable() { ${_printf} "%s\n" "/* $1 = '`value_of $1`' */" } # store the actual compiler specific settings to the # file ${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER} store_compiler_settings() { _file="${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}" ${_printf} "%s\n" \ "/*" \ >${_file} ${_printf} "%s\n" \ "** file: `$_basename ${_file}`" \ >>${_file} ${_printf} "%s\n" \ "** Configuration file for CGAL ${CGAL_VERSION}" \ >>${_file} ${_printf} "%s\n" \ "** on `extended_compiler_description`" \ >>${_file} ${_printf} "%s%s\n" \ "** Automatically created by " \ "`${_basename} $0` ${CGAL_INSTALL_VERSION}." \ >>${_file} ${_printf} "%s\n" \ "** Please do not edit." \ >>${_file} ${_printf} "%s\n\n" \ "*/" \ >>${_file} _store_install_config_variable COMPILER >>${_file} _store_install_config_variable CGAL_INSTALL_VERSION >>${_file} _store_install_config_variable STL_STATUS >>${_file} _store_install_config_variable STL_DIR >>${_file} _store_install_config_variable LEDA_SUPPORT >>${_file} _store_install_config_variable NEED_EXTRA_LEDA_IDIR >>${_file} _store_install_config_variable LEDA_INCL_DIR >>${_file} _store_install_config_variable NEED_EXTRA_LEDA_LDIR >>${_file} _store_install_config_variable LEDA_LIB_DIR >>${_file} _store_install_config_variable GMP_SUPPORT >>${_file} _store_install_config_variable GMP_INSTALLATION >>${_file} _store_install_config_variable GMP_INCL_DIR >>${_file} _store_install_config_variable GMP_LIB_DIR >>${_file} _store_install_config_variable CUSTOM_CXXFLAGS >>${_file} _store_install_config_variable CUSTOM_LDFLAGS >>${_file} _store_install_config_variable CGAL_STL_VERSION >>${_file} ${_printf} "\n%s\n" \ "/* EOF */" \ >>${_file} log_print "Settings stored in ${_file}." } # just a tiny message template for test_setup _passed_message() { ${_printf} "%s\n" \ "${_LEFTSPACE}$1 test has already been passed." } # test current setup and set SETUP_COMPLETE # return 0, iff setup is ok test_setup() { SETUP_COMPLETE='' make_lib_dir link_gmp # STL if [ -z "${STL_TEST_PASSED}" ]; then test_stl if [ $? = 1 ]; then return 1 fi else _passed_message 'STL' fi # LEDA if [ -z "${LEDA_TEST_PASSED}" ]; then test_leda 'v' if [ $? = 1 ]; then return 1 fi else _passed_message 'LEDA' fi # GMP if [ -z "${GMP_TEST_PASSED}" ]; then test_gmp 'GMP' 'v' if [ $? = 1 ]; then return 1 fi else _passed_message 'GMP' fi SETUP_COMPLETE='y' ${_printf} "%s" "${_LEFTSPACE}Saving current setup ..." store_compiler_settings ${_printf} "%s\n" " done." return 0 } # called when the setup has been changed dramatically # such that all previous test results are invalidated reset_all_test_variables() { STL_TEST_PASSED='' LEDA_TEST_PASSED='' GMP_TEST_PASSED='' } # load the settings for ${COMPILER}, # if a config file exists, otherwise check for "builtin" STL # and set STL_STATUS accordingly _choose_compiler() { log_print \ "Choosing `extended_compiler_description` as compiler." set_ostype retrieve_compiler_settings set_compiler_flags if [ -z "${SETUP_COMPLETE}" ]; then # reset all TEST_PASSED variables reset_all_test_variables test_for_builtin_stl if [ "${STL_STATUS}" = "b" -o -n "${STL_DIR}" ]; then test_setup else SETUP_COMPLETE='' fi else # reset all TEST_PASSED variables STL_TEST_PASSED='y' if [ -n "${LEDA_SUPPORT}" ]; then LEDA_TEST_PASSED='y' else LEDA_TEST_PASSED='' fi if [ -n "${GMP_SUPPORT}" ]; then GMP_TEST_PASSED='y' else GMP_TEST_PASSED='' fi fi } # set COMPILER to ${COMPILER}_$1 (for $1 in {1..${_COMPILER_NUMBER}-1}) _set_compiler() { if [ $1 -ge ${_COMPILER_NUMBER} ]; then exit_on_error "Argument greater than expected" \ "(${1} >= ${_COMPILER_NUMBER}) in _set_compiler" fi _tmp=`eval "echo '$'_COMPILER_$1"` _tmp=`eval "echo ${_tmp}"` COMPILER=${_tmp} } # --------------------------------------------------------------------- # functions common to all menus # # print current setup status, $1 is menu-name menu_header() { clear_screen print_filled_line print_headline "CGAL $CGAL_VERSION Installation ${1} Menu" print_line "OS: ${SYST}" print_line \ "Compiler: `extended_compiler_description`" if [ "${STL_STATUS}" = "x" ]; then print_line "Builtin STL: not used." elif [ "${STL_STATUS}" = "b" ]; then print_line "Builtin STL: used." fi if [ "${STL_STATUS}" != 'b' -a -z "${STL_DIR}" ]; then print_line "STL_DIR: please configure!!!" else print_line "STL_VERSION: ${CGAL_STL_VERSION}" fi _set_tmp_to_not_or_not "${LEDA_SUPPORT}" print_line "LEDA: ${_tmp}supported." _set_tmp_to_not_or_not "${GMP_SUPPORT}" print_line "GMP: ${_tmp}supported." print_empty_line if [ -z "${SETUP_COMPLETE}" ]; then print_line "The setup has ${_bold_on}not${_bold_off} been tested." else print_line "The setup has been tested ${_bold_on}ok${_bold_off}." fi print_empty_line } # bottom lines for all menus, $1 is name of next-top menu menu_tailer() { print_empty_line print_line "${_bold_on}${_bold_off} Back to ${1}" print_empty_line print_empty_line print_empty_line print_filled_line go_up_lines 3 print_prompt "Your Choice: " _read } # read a new value for variable $1 # and store old value in _tmp change_value() { go_up_lines 1 print_prompt "New $1: " _read # store old value _oldvalue=`eval "echo '$'$1"` _oldvalue=\'`eval "echo $_oldvalue"`\' eval "$1=\"${KEY}\"" } # read a new value for variable $1 # if $2 == "dir", it has to denote a directory # if $2 == "exe", it has to denote an executable file # check input for # 1) no whitespaces # 2) existence of the directory # and run the corresponding check function (check_$1) # return 0, if successful and return 1, if not change_dir() { change_value $1 if [ "${_oldvalue}" = "`value_of $1`" ]; then return 1 else # make sure $1 is just one word: go_down_lines 1 if [ -n "`${_printf} \"%s\" \"\`value_of $1\`\" | \ ${_awk} '{printf $2}'`" ] then print_filled_line print_center_line "ERROR: String contains whitespaces." else print_filled_line if [ "${2}" = "dir" -a ! -d "`value_of $1`" ]; then print_center_line "ERROR: Directory does not exist." elif [ "${2}" = "exe" -a ! -x "`value_of $1`" ]; then print_center_line \ "ERROR: File does not exist or is not executable." else eval "check_$1 print_line" if [ $? != 0 ]; then return 0 fi fi fi fi # restore old value eval $1="$_oldvalue" wait_for_enter return 1 } # set _tmp to 'not', if $1 is an empty string # otherwise set _tmp to '' _set_tmp_to_not_or_not() { if [ -z "$1" ]; then _tmp='not ' else _tmp='' fi } # --------------------------------------------------------------------- # compiler_menu to setup compiler and STL options # compiler_choose_menu() { _OLD_COMPILER=${COMPILER} while [ 0 ]; do menu_header 'Choose Compiler' i=1 while [ $i -lt ${_COMPILER_NUMBER} ]; do _tmp=`eval "echo '$'_COMPILER_$i"` _tmp=`eval "echo ${_tmp}"` print_line \ "${_bold_on}<${i}>${_bold_off} `extended_compiler_description \"${_tmp}\"`" eval "${_EXPR} ${i} + 1" i=${_result} done menu_tailer 'Compiler Menu' case ${KEY} in 1|2|3|4|5|6|7|8|9) if [ ${KEY} -lt ${_COMPILER_NUMBER} ]; then _set_compiler ${KEY} if [ "${_OLD_COMPILER}" != "${COMPILER}" ]; then go_down_lines 3 flush_buffer _choose_compiler fi return fi ;; q|Q|b|B) return ;; esac done } compiler_menu() { while [ 0 ]; do menu_header 'Compiler' print_line "${_bold_on}${_bold_off} Choose compiler" if [ "${STL_STATUS}" != "e" ]; then print_line "${_bold_on}${_bold_off} Toggle use of builtin STL" fi if [ "${STL_STATUS}" != "b" ]; then print_line "${_bold_on}${_bold_off} STL include directory" print_line " ${STL_DIR:-}" fi print_line "${_bold_on}${_bold_off} Set custom compiler flags" print_multi_line "${CUSTOM_CXXFLAGS:-}" print_line "${_bold_on}${_bold_off} Set custom linker flags" print_multi_line "${CUSTOM_LDFLAGS:-}" print_line "${_bold_on}${_bold_off} Test (and save) setup" menu_tailer 'Main Menu' case ${KEY} in c|C) compiler_choose_menu ;; s|S) if [ "${STL_STATUS}" = "x" ]; then STL_STATUS="b" STL_TEST_PASSED='y' elif [ "${STL_STATUS}" = "b" ]; then STL_STATUS="x" STL_TEST_PASSED='' SETUP_COMPLETE='' fi ;; i|I) if [ "${STL_STATUS}" != "b" ]; then if change_dir STL_DIR dir; then go_down_lines 1 flush_buffer test_stl 'v' fi fi ;; f|F) change_value CUSTOM_CXXFLAGS reset_all_test_variables SETUP_COMPLETE='' ;; l|L) change_value CUSTOM_LDFLAGS reset_all_test_variables SETUP_COMPLETE='' ;; t|T) go_down_lines 3 flush_buffer test_setup ;; q|Q|b|B) return ;; esac done } # --------------------------------------------------------------------- # leda_menu to setup LEDA # leda_menu() { while [ 0 ]; do menu_header 'LEDA' print_line "${_bold_on}${_bold_off} Toggle LEDA support" if [ -n "${LEDA_SUPPORT}" ]; then print_line "${_bold_on}${_bold_off} LEDA include directory" if [ -n "${NEED_EXTRA_LEDA_IDIR}" ]; then print_line " ${LEDA_INCL_DIR:-}" if [ "${NEED_EXTRA_LEDA_IDIR}" = "x" ]; then print_line \ "${_bold_on}${_bold_off} Use LEDA headers from system include." fi else print_line " " fi print_line "${_bold_on}${_bold_off} LEDA lib directory" if [ -n "${NEED_EXTRA_LEDA_LDIR}" ]; then print_line " ${LEDA_LIB_DIR:-}" if [ "${NEED_EXTRA_LEDA_LDIR}" = "x" ]; then print_line \ "${_bold_on}${_bold_off} Use LEDA libs from system libdir." fi else print_line " " fi fi print_line "${_bold_on}${_bold_off} Test (and save) setup" menu_tailer 'Main Menu' case ${KEY} in e|E) if [ -z "${LEDA_SUPPORT}" ]; then LEDA_SUPPORT='_LEDA' SETUP_COMPLETE='' make_lib_dir # check, if libgmp can be linked link_gmp # test for LEDA sysincl/-lib, if this was not done before if [ "${NEED_EXTRA_LEDA_IDIR}" = 'n' -o \ "${NEED_EXTRA_LEDA_LDIR}" = 'n' ]; then go_down_lines 3 flush_buffer test_for_leda_incl_in_sys_incl "${INSTALL_VERBOSE}" test_for_leda_lib_in_sys_lib "${INSTALL_VERBOSE}" fi else LEDA_SUPPORT='' # check, if libgmp can be linked link_gmp fi ;; i|I) if [ -n "${LEDA_SUPPORT}" ]; then if [ -z "${NEED_EXTRA_LEDA_IDIR}" ]; then NEED_EXTRA_LEDA_IDIR='x' fi if change_dir LEDA_INCL_DIR dir; then if [ -z "${NEED_EXTRA_LEDA_IDIR}" ]; then NEED_EXTRA_LEDA_IDIR='x' fi LEDA_TEST_PASSED='' SETUP_COMPLETE='' fi fi ;; j|J) if [ "${NEED_EXTRA_LEDA_IDIR}" = "x" ]; then NEED_EXTRA_LEDA_IDIR='' LEDA_TEST_PASSED='' SETUP_COMPLETE='' fi ;; l|L) if [ -n "${LEDA_SUPPORT}" ]; then if change_dir LEDA_LIB_DIR dir; then if [ -z "${NEED_EXTRA_LEDA_LDIR}" ]; then NEED_EXTRA_LEDA_LDIR='x' fi LEDA_TEST_PASSED='' SETUP_COMPLETE='' fi fi ;; m|M) if [ "${NEED_EXTRA_LEDA_LDIR}" = "x" ]; then NEED_EXTRA_LEDA_LDIR='' LEDA_TEST_PASSED='' SETUP_COMPLETE='' fi ;; t|T) go_down_lines 3 flush_buffer test_setup;; q|Q|b|B) return;; *);; esac done } # --------------------------------------------------------------------- # gmp_menu to setup GMP # gmp_menu() { while [ 0 ]; do menu_header 'GMP' print_line "${_bold_on}${_bold_off} Install GMP in CGAL tree" print_line "${_bold_on}${_bold_off} Toggle GMP support" if [ -n "${GMP_SUPPORT}" ]; then print_line "${_bold_on}${_bold_off} GMP include directory" case ${GMP_INSTALLATION} in c) _tmp='';; s) _tmp='';; *) _tmp="${GMP_INCL_DIR}";; esac print_line " ${_tmp:-}" print_line "${_bold_on}${_bold_off} GMP lib directory" case ${GMP_INSTALLATION} in c) _tmp='';; s) _tmp='';; *) _tmp="${GMP_LIB_DIR}";; esac print_line " ${_tmp:-}" if [ "${GMP_INSTALLATION}" = 'z' ]; then print_line \ "${_bold_on}${_bold_off} Use GMP installation in CGAL tree" fi if [ "${GMP_INSTALLATION}" = 'x' ]; then print_line \ "${_bold_on}${_bold_off} Use GMP installation in system dirs" fi fi print_line "${_bold_on}${_bold_off} Test (and save) setup" menu_tailer 'Main Menu' case $KEY in c|C) install_gmp ;; g|G) if [ -z "${GMP_SUPPORT}" ]; then SETUP_COMPLETE='' GMP_SUPPORT='_GMP' if [ -z "${GMP_INSTALLATION}" ]; then go_down_lines 3 flush_buffer search_gmp "${INSTALL_VERBOSE}" fi else GMP_SUPPORT='' fi ;; i|I) if [ -n "${GMP_SUPPORT}" ]; then if change_dir GMP_INCL_DIR dir; then GMP_TEST_PASSED='' SETUP_COMPLETE='' case ${GMP_INSTALLATION} in c|z) GMP_INSTALLATION='z';; s|x) GMP_INSTALLATION='x';; *) GMP_INSTALLATION='e';; esac fi fi ;; l|L) if [ -n "${GMP_SUPPORT}" ]; then if change_dir GMP_LIB_DIR dir; then GMP_TEST_PASSED='' SETUP_COMPLETE='' case ${GMP_INSTALLATION} in c|z) GMP_INSTALLATION='z';; s|x) GMP_INSTALLATION='x';; *) GMP_INSTALLATION='e';; esac fi fi ;; c|C) if [ -n "${GMP_SUPPORT}" -a \ "${GMP_INSTALLATION}" = 'z' ]; then GMP_TEST_PASSED='y' GMP_INSTALLATION='c' fi ;; t|T) go_down_lines 3 flush_buffer test_setup ;; s|S) if [ "${GMP_SUPPORT}" -a \ "${GMP_INSTALLATION}" = 'x' ]; then GMP_TEST_PASSED='y' GMP_INSTALLATION='s' fi ;; q|Q|b|B) return;; *);; esac done } # --------------------------------------------------------------------- # GNU GMP installation # # $1 is the command to execute and $2 its description # if the command fails, exit with an error message _do_command() { ${_printf} "%s" "${_LEFTSPACE}$2 ..." if eval "$1 >${TMP_LOGFILE} 2>&1"; then log_print "\"$2\" succeeded." ${_printf} "%s\n" " done." ${_rm} -f ${TMP_LOGFILE} else log_print "ERROR: \"$2\" failed." ${_cat} ${TMP_LOGFILE} | ${PAGER:-${_cat}} ${_rm} -f ${TMP_LOGFILE} exit_on_error "\"$2\" failed" fi } # $1 is the command to execute and $2 its description # if the command fails, show the log and return 1, # otherwise return 0 _do_command_may_fail() { ${_printf} "%s" "${_LEFTSPACE}$2 ..." if eval "$1 >${TMP_LOGFILE} 2>&1"; then log_print "\"$2\" succeeded." ${_printf} "%s\n" " done." ${_rm} -f ${TMP_LOGFILE} return 0 else log_print "ERROR: \"$2\" failed." ${_printf} "\n%s\n" "${_LEFTSPACE}\"$2\" failed." ${_printf} "%s\n" "${_LEFTSPACE}You will be shown a log now ..." print_filled_line wait_for_enter ${_cat} ${TMP_LOGFILE} | ${PAGER:-${_cat}} ${_rm} -f ${TMP_LOGFILE} return 1 fi } # used by install_gmp to create symbolic links of libgmp.a # in the CGAL tree link_gmp() { for i in ${CGAL_LIB_DIR}/${CGAL_OS_COMPILER} \ ${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}_LEDA; do if [ ! -r ${CGAL_LIB_DIR}/`full_ostype`/libgmp.a -a \ -r ${i}/libgmp.a ] then ${_ln} -s ${i}/libgmp.a \ ${CGAL_LIB_DIR}/`full_ostype`/libgmp.a log_print "remark: linked libgmp from ${i}" log_print " to ${CGAL_LIB_DIR}/`full_ostype`." fi done } # install GNU GMP in the CGAL directory tree install_gmp() { make_lib_dir if [ -r ${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}/libgmp.a -o \ -r ${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}/libgmp.so ]; then if [ "${GMP_INSTALLATION}" != "c" ]; then GMP_INSTALLATION='c' GMP_TEST_PASSED='' fi go_down_lines 2 print_line "There already exists a GMP installation" print_line "for this os/compiler in the CGAL tree." print_empty_line print_empty_line print_filled_line go_up_lines 2 print_prompt "Do you want to proceed anyway (y/N)? " _read if [ "${KEY}" != 'y' ]; then return fi fi # remove all os/compiler specific stuff SAVE_LEDA="${LEDA_SUPPORT}" LEDA_SUPPORT='' make_lib_dir clear_screen print_filled_line print_empty_line print_headline "Installing GNU GMP in the CGAL tree" print_filled_line write_buffer "\n" flush_buffer ${_printf} "%s\t\t%s\n" "${_LEFTSPACE}OS:" "${SYST}" ${_printf} "%s\t%s\n\n" \ "${_LEFTSPACE}COMPILER:" "`extended_compiler_description`" if [ ! -d ${GMP_VERSION} ]; then # unzip gmpfile=${CGAL_AUX_DIR}/${GMP_VERSION}.tar.gz _check_read ${gmpfile} _check_write ${CGAL_AUX_DIR} _check_for_sysutil gunzip y _do_command "${_gunzip} ${gmpfile}" "Unzip" # untar gmpfile=${CGAL_AUX_DIR}/${GMP_VERSION}.tar _check_read ${gmpfile} _check_for_sysutil tar y _do_command "${_tar} xf ${gmpfile}" "Untar" # re-zip _check_for_sysutil gzip y _do_command "${_gzip} -9 ${gmpfile}" "Re-zip" fi cd ${GMP_VERSION} case ${CGAL_OS_COMPILER} in mips_IRIX*-6*_CC-*32-*) # gmp-2.0.2 build fails on irix6, since it assummes # 64 bit wordsize _host=mips-sgi-irix5;; *) _host='';; esac if _do_command_may_fail "./configure ${_host}" Configuring; then if _do_command_may_fail "make CC=\"`c_compiler_bin`\"" Building then ${_printf} "%s" "${_LEFTSPACE}Installing ..." _check_write ${CGAL_INCL_DIR} ${_cp} gmp.h ${CGAL_INCL_DIR} ${_mv} libgmp.a ${CGAL_LIB_DIR}/`full_ostype` ${_printf} "%s\n" " done." _do_command "make clean" "Cleaning" GMP_INSTALLATION='c' fi fi cd .. write_buffer "\n" print_filled_line wait_for_enter # restore os/compiler stuff LEDA_SUPPORT="${SAVE_LEDA}" link_gmp } # --------------------------------------------------------------------- # lib menu # # --------------------------------------------------------------------- # create include makefile # these makefiles are placed in ${CGAL_MAKE_DIR} # and define compiler/os specific flags # they should be included in any CGAL makefile # when compiling on this compiler/os # --------------------------------------------------------------------- makefile_header() { ${_printf} "\n%s\n" \ "#---------------------------------------------------------------------#" ${_printf} "%s\n" \ "# ${1}" ${_printf} "%s\n\n" \ "#---------------------------------------------------------------------#" } # print args, if string is not empty # (empty strings on a line give problems with SGI make :() makefile_print_line() { if [ -n "${*}" ]; then ${_printf} "\t%s \\\\\n" "${*}" fi } # write compiler flags for a CGAL include makefile write_compiler_flags() { makefile_header "compiler flags" \ >> ${FILE} print_as_shell_comment \ "For more information about the compiler flags see the installation guide.\n" \ >> ${FILE} # # CGAL_INCL_CONF_DIR # print_as_shell_comment \ "compiler specific configuration dir" \ >> ${FILE} ${_printf} "%s\\\\\n" "CGAL_INCL_CONF_DIR = " >> ${FILE} ${_printf} "\t%s\n\n" \ "\$(CGAL_INCL_DIR)/CGAL/config/${CGAL_OS_COMPILER}" \ >> ${FILE} # # CGAL_STL_INCLUDE_DIRECTIVE # print_as_shell_comment \ "*** Fill in your STL include directory ***" \ >> ${FILE} print_as_shell_comment \ "(including the -I directive)" \ >> ${FILE} print_as_shell_comment \ "(e.g. -I/usr/local/STL)" \ >> ${FILE} ${_printf} "%s\n\n" \ "CGAL_STL_INCLUDE_DIRECTIVE = `stl_cxxflags`" \ >> ${FILE} # # LEDA_INCL_DIR # if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_IDIR}" ]; then print_as_shell_comment \ "*** Fill in your LEDA include directory ***" \ >> ${FILE} print_as_shell_comment \ "(e.g. /usr/local/include)" \ >> ${FILE} ${_printf} "%s\\\\\n" "LEDA_INCL_DIR = " >> ${FILE} ${_printf} "\t%s\n\n" \ "`_where_is 'LEDA_INCL_DIR'`" \ >> ${FILE} fi # # CUSTOM_CXXFLAGS # print_as_shell_comment \ "*** Fill in any additional compiler flags you need ***" \ >> ${FILE} ${_printf} "%s\n\n" \ "CUSTOM_CXXFLAGS = ${CUSTOM_CXXFLAGS}" \ >> ${FILE} # # GMP_INCL_DIR # if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then print_as_shell_comment \ "*** Fill in your GMP include directory ***" \ >> ${FILE} ${_printf} "%s\\\\\n" "GMP_INCL_DIR = " >> ${FILE} ${_printf} "\t%s\n\n" \ "`_where_is 'GMP_INCL_DIR'`" \ >> ${FILE} fi fi # # LONG_NAME_PROBLEM_CXXFLAGS # print_as_shell_comment \ "*** to work around the long-name-problem" >> ${FILE} print_as_shell_comment \ "*** on sparc_SunOS-5.5_g++-2.8.*/egcs-1.0.*" >> ${FILE} ${_printf} "%s\n\n" \ "LONG_NAME_PROBLEM_CXXFLAGS = ${LONG_NAME_PROBLEM_CXXFLAGS}" \ >> ${FILE} # # CGAL_CXXFLAGS # ${_printf} "%s\\\\\n" "CGAL_CXXFLAGS = " >> ${FILE} makefile_print_line "\$(CUSTOM_CXXFLAGS)" >> ${FILE} makefile_print_line "${ADDITIONAL_CXXFLAGS}" >> ${FILE} makefile_print_line "\$(CGAL_STL_INCLUDE_DIRECTIVE)" >> ${FILE} if [ -n "${GMP_SUPPORT}" ]; then makefile_print_line "-DCGAL_USE_GMP" >> ${FILE} if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then makefile_print_line "-I\$(GMP_INCL_DIR)" >> ${FILE} fi fi makefile_print_line "-I\$(CGAL_INCL_CONF_DIR)" >> ${FILE} if [ -n "${LEDA_SUPPORT}" ]; then makefile_print_line "-DCGAL_USE_LEDA -DLEDA_PREFIX" >> ${FILE} if [ -n "${NEED_EXTRA_LEDA_IDIR}" ]; then makefile_print_line "-I\$(CGAL_INCL_DIR)" >> ${FILE} ${_printf} "\t%s\n\n" "-I\$(LEDA_INCL_DIR)" >> ${FILE} else ${_printf} "\t%s\n\n" "-I\$(CGAL_INCL_DIR)" >> ${FILE} fi else ${_printf} "\t%s\n\n" "-I\$(CGAL_INCL_DIR)" >> ${FILE} fi } # write linker flags for a CGAL include makefile write_linker_flags() { makefile_header "linker flags" >> ${FILE} # # LEDA_LIB_DIR # if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_LDIR}" ]; then print_as_shell_comment \ "*** Fill in your LEDA_lib_directory ***" \ >> ${FILE} print_as_shell_comment \ "(e.g. /usr/local/lib)" \ >> ${FILE} ${_printf} "%s\\\\\n" "LEDA_LIB_DIR = " >> ${FILE} ${_printf} "\t%s\n\n" \ "`_where_is 'LEDA_LIB_DIR'`" \ >> ${FILE} fi # # GMP_LIB_DIR # if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then print_as_shell_comment \ "*** Fill in your GMP lib directory ***" \ >> ${FILE} print_as_shell_comment \ "(e.g. /usr/local/lib)" \ >> ${FILE} ${_printf} "%s\\\\\n" "GMP_LIB_DIR = " >> ${FILE} ${_printf} "\t%s\n\n" \ "`_where_is 'GMP_LIB_DIR'`" \ >> ${FILE} fi fi # # CUSTOM_LDFLAGS # print_as_shell_comment \ "*** Fill in any additional linker flags you need ***" \ >> ${FILE} ${_printf} "%s\n\n" "CUSTOM_LDFLAGS = ${CUSTOM_LDFLAGS}" \ >> ${FILE} # # LIBS # LIB_PATH="-L\$(CGAL_LIB_DIR)/\$(CGAL_OS_COMPILER)" RUNTIME_LIB_PATH="\$(CGAL_LIB_DIR)/\$(CGAL_OS_COMPILER)" LIBS="-lCGAL" WLIBS="-lCGAL" if [ -n "${LEDA_SUPPORT}" ] ; then if [ -n "${NEED_EXTRA_LEDA_LDIR}" ]; then LIB_PATH="${LIB_PATH} -L\$(LEDA_LIB_DIR)" RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(LEDA_LIB_DIR)" fi LIBS="${LIBS} -lP -lG -lL" WLIBS="${WLIBS} -lW -lP -lG -lL -lX11" fi if [ -n "${GMP_SUPPORT}" ]; then if [ "${GMP_INSTALLATION}" = 'x' -o \ "${GMP_INSTALLATION}" = 'z' -o \ "${GMP_INSTALLATION}" = 'e' ]; then LIB_PATH="${LIB_PATH} -L\$(GMP_LIB_DIR)" RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(GMP_LIB_DIR)" fi LIBS="${LIBS} -lgmp" WLIBS="${WLIBS} -lgmp" fi LIBS="${LIBS} -lm" WLIBS="${WLIBS} -lm" # # LONG_NAME_PROBLEM_LDFLAGS # print_as_shell_comment \ "*** to work around the long-name-problem" >> ${FILE} print_as_shell_comment \ "*** on sparc_SunOS-5.5_g++-2.8.*/egcs-1.0.*" >> ${FILE} ${_printf} "%s\n\n" \ "LONG_NAME_PROBLEM_LDFLAGS = ${LONG_NAME_PROBLEM_LDFLAGS}" \ >> ${FILE} # # CGAL_LDFLAGS # ${_printf} "%s\\\\\n" "CGAL_LDFLAGS = " >> ${FILE} makefile_print_line "\$(CUSTOM_LDFLAGS)" >> ${FILE} makefile_print_line "${LIB_PATH}" >> ${FILE} if [ -n "${RUNTIME_LINKER_FLAG}" ]; then makefile_print_line \ "${RUNTIME_LINKER_FLAG}${RUNTIME_LIB_PATH}" \ >> ${FILE} fi ${_printf} "\t%s\n\n" "${LIBS}" >> ${FILE} # # CGAL_WINDOW_LDFLAGS # if [ -n "${LEDA_SUPPORT}" ]; then LIB_PATH="${LIB_PATH} -L${WINDOW_DIR}" RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:${WINDOW_DIR}" ${_printf} "%s\\\\\n" "CGAL_WINDOW_LDFLAGS = " >> ${FILE} makefile_print_line "${CUSTOM_LDFLAGS}" >> ${FILE} makefile_print_line "${LIB_PATH}" >> ${FILE} if [ -n "${RUNTIME_LINKER_FLAG}" ]; then makefile_print_line "${RUNTIME_LINKER_FLAG}${RUNTIME_LIB_PATH}" \ >> ${FILE} fi ${_printf} "\t%s\n\n" "${WLIBS}" >> ${FILE} fi } # create the include makefile for current configuration create_include_makefile() { FILE=${CGAL_MAKEFILE} print_as_shell_comment \ "This file contains CGAL makefile settings for the following platform:" \ > ${FILE} print_os_setting 'print_as_shell_comment' \ >> ${FILE} # # CGAL_DIRECTORIES # makefile_header "include directory settings" \ >> ${FILE} ${_printf} "%s\\\\\n" "CGAL_DIRECTORIES = " >> ${FILE} ${_printf} "\t%s\n" "${CGAL_DIRFILE}" >> ${FILE} ${_printf} "%s\n" "include \$(CGAL_DIRECTORIES)" >> ${FILE} # # CGAL_OS_COMPILER # makefile_header "os/compiler description" \ >> ${FILE} ${_printf} "%s\n" "CGAL_OS_COMPILER = `full_ostype`" >> ${FILE} # # CGAL_CXX # makefile_header "compiler" >> ${FILE} ${_printf} "%s\n" "CGAL_CXX = ${CGAL_CXX}" >> ${FILE} write_compiler_flags write_linker_flags makefile_header "commands and flags for creating libraries" \ >> ${FILE} # # CGAL_LIB # ${_printf} "%s\n" "CGAL_LIB = libCGAL.a" >> ${FILE} # # CGAL_LIB_CXXFLAGS # ${_printf} "%s\\\\\n" "CGAL_LIB_CXXFLAGS = " >> ${FILE} makefile_print_line "${CGAL_LIB_CXXFLAGS}" >> ${FILE} ${_printf} "\t%s\n" "\$(CGAL_CXXFLAGS)" >> ${FILE} # # CGAL_LIB_LDFLAGS # ${_printf} "%s\n" \ "CGAL_LIB_LDFLAGS = ${CGAL_LIB_LDFLAGS}" \ >> ${FILE} ${_printf} "\n" >> ${FILE} # # CGAL_LIB_CREATE # ${_printf} "%s\n\n" "CGAL_LIB_CREATE = ${CGAL_LIB_CREATE}" >> ${FILE} # # CGAL_SHARED_LIB # ${_printf} "%s\n" "CGAL_SHARED_LIB = libCGAL.so" >> ${FILE} # # CGAL_SHARED_LIB_CXXFLAGS # ${_printf} "%s\\\\\n" "CGAL_SHARED_LIB_CXXFLAGS = " >> ${FILE} makefile_print_line "${CGAL_SHARED_LIB_CXXFLAGS}" >> ${FILE} ${_printf} "\t%s\n" "\$(CGAL_CXXFLAGS)" >> ${FILE} # # CGAL_SHARED_LIB_LDFLAGS # if [ -n "${LEDA_SUPPORT}" -a -n "${NEED_EXTRA_LEDA_LDIR}" ]; then ${_printf} "%s\\\\\n" "CGAL_SHARED_LIB_LDFLAGS = " >> ${FILE} makefile_print_line "-L\$(LEDA_LIB_DIR)" >> ${FILE} if [ -n "${RUNTIME_LINKER_FLAG}" ]; then makefile_print_line "${RUNTIME_LINKER_FLAG}\$(LEDA_LIB_DIR)" \ >> ${FILE} fi ${_printf} "\t%s\n" "-lL ${CGAL_SHARED_LIB_LDFLAGS}" >> ${FILE} else ${_printf} "%s\n" \ "CGAL_SHARED_LIB_LDFLAGS = ${CGAL_SHARED_LIB_LDFLAGS}" >> ${FILE} fi ${_printf} "\n" >> ${FILE} # # CGAL_SHARED_LIB_CREATE # ${_printf} "%s\n\n" \ "CGAL_SHARED_LIB_CREATE = ${CGAL_SHARED_LIB_CREATE} -o" \ >> ${FILE} # # PRINT_STACKTRACE_PROGRAM # print_as_shell_comment \ "*** only used for the testsuite" >> ${FILE} print_as_shell_comment \ "*** program used to create stacktrace from coredump" >> ${FILE} ${_printf} "%s\n\n" \ "PRINT_STACKTRACE_PROGRAM = ${PRINT_STACKTRACE_PROGRAM}" \ >> ${FILE} makefile_header "EOF" >> ${FILE} } #--------------------------------------------------------------------# # replace_line # replaces all the lines in that start with # with #--------------------------------------------------------------------# replace_line() { if [ ! -f $1 ] ; then ${_printf} "%s\n" "Error: could not open file $1 in replace_line()" return fi if eval '${_sed} -e "/^$2/c\\ $3" $1 > $1.TEMP' ; then ${_mv} $1.TEMP $1 else ${_printf} "%s\n" "Error sed replacement failed in replace_line()" fi } prepare_lib_makefiles() { for FILE in ${CGAL_SRC_DIR}/makefile_lib \ ${CGAL_SRC_DIR}/makefile_sharedlib \ ${CGAL_EXAMPLE_DIR}/makefile do replace_line ${FILE} CGAL_MAKEFILE \ "CGAL_MAKEFILE = ${CGAL_MAKEFILE}" done } # log via $1 generatemakefiles() { _check_dir_exists ${CGAL_MAKE_DIR} _check_write ${CGAL_MAKE_DIR} _check_read ${CGAL_DIRFILE} _check_write ${CGAL_DIRFILE} replace_line ${CGAL_DIRFILE} CGAL_INCL_DIR \ "CGAL_INCL_DIR = ${CGAL_INCL_DIR}" replace_line ${CGAL_DIRFILE} CGAL_LIB_DIR \ "CGAL_LIB_DIR = ${CGAL_LIB_DIR}" # create ${CGAL_MAKEFILE}, if it does not exist if [ ! -r ${CGAL_MAKEFILE} ]; then $1 "remark: `${_basename} ${CGAL_MAKEFILE}` does not exist," $1 " creating." else $1 "remark: `${_basename} ${CGAL_MAKEFILE}` already exists," $1 " saving as \".bak\"." ${_mv} ${CGAL_MAKEFILE} ${CGAL_MAKEFILE}.bak fi create_include_makefile prepare_lib_makefiles for FILE in `${_ls} ${CGAL_EXAMPLE_DIR}/*/makefile`; do replace_line ${FILE} CGAL_MAKEFILE \ "CGAL_MAKEFILE = ${CGAL_MAKEFILE}" done if [ -n "${CGAL_TESTSUITE}" ]; then for FILE in `${_ls} ${CGAL_TEST_DIR}/*/makefile`; do replace_line ${FILE} CGAL_MAKEFILE \ "CGAL_MAKEFILE = ${CGAL_MAKEFILE}" done fi } # compile $1 (= lib or sharedlib) # return 0, iff success _do_compile() { ${_printf} "%s" "${_LEFTSPACE}Building CGAL_$1 ..." if [ -f ${COMPILE_LOGFILE} -a ! -w ${COMPILE_LOGFILE} ]; then ${_rm} -f ${COMPILE_LOGFILE} fi if make -f makefile_$1 >${COMPILE_LOGFILE} 2>&1; then log_print "Compilation of $1 ${_libname} succeeded." ${_printf} "%s\n" " done." ANY_LIB_COMPILED='y' return 0 else log_print "Compilation of $1 ${_libname} failed." ${_printf} "\n%s\n" "${_LEFTSPACE}Compilation of CGAL_$1 failed." ${_printf} "%s\n" "${_LEFTSPACE}You will be shown a log now ..." print_filled_line wait_for_enter ${_cat} ${COMPILE_LOGFILE} | ${PAGER:-${_cat}} write_buffer "\n" return 1 fi } # make lib dir make_lib_dir() { _libname=${CGAL_LIB_DIR}/`full_ostype` _check_dir_exists_create ${_libname} _libname=`${_basename} ${_libname}` } # create appropriate dirs and makefiles make_makefiles() { # generate directoryfile and makefile: ${_printf} "%s" "${_LEFTSPACE}Generating Makefiles ..." CGAL_MAKEFILE=${CGAL_MAKE_DIR}/makefile_${_libname} generatemakefiles log_print ${_printf} "%s\n" " done." } write_menu_information() { if [ -n "${INSTALL_INTERACTIVE}" ]; then clear_screen else write_buffer "\n" fi print_filled_line print_empty_line print_headline "$1 CGAL ${CGAL_VERSION}" print_filled_line write_buffer "\n" flush_buffer print_os_setting 'print_with_indent' ${_printf} "\n" } build_cgal() { cd ${CGAL_SRC_DIR} if _do_compile lib; then LIB_COMPILED='ok' ${_printf} "%s" "`print_os_setting 'print_with_indent'`" \ >> ${INSTALL_RIS_LOGFILE} ${_printf} "\n${_LEFTSPACE}%s\n" \ "----------------------------------------------------------" \ >> ${INSTALL_RIS_LOGFILE} _do_compile sharedlib fi write_buffer "\n" print_filled_line wait_for_enter cd ${CGAL_DIR} } lib_menu() { write_menu_information "Compiling" make_lib_dir make_makefiles # build the libs: build_cgal } # --------------------------------------------------------------------- # test menu # test_menu() { write_menu_information "Testing" ${_printf} "%s" "${_LEFTSPACE}Updating `$_basename ${CGAL_TESTFILE}` ..." _check_write ${CGAL_TESTFILE} replace_line ${CGAL_TESTFILE} 'run_testsuite ' "" ${_printf} "%s" "run_testsuite ${CGAL_MAKE_DIR}/makefile_`full_ostype`" \ >> ${CGAL_TESTFILE} $_chmod 744 ${CGAL_TESTFILE} ${_printf} "%s\n" " done." ${_printf} "%s\n" "${_LEFTSPACE}Starting ${CGAL_TESTFILE} ..." cd ${CGAL_TEST_DIR} ${CGAL_TESTFILE} cleanup_after_compile log_print "Test completed." print_filled_line print_empty_line print_headline "Test completed." print_center_line "You will be shown a log now ..." wait_for_enter ${_cat} ${TEST_LOGFILE} | ${PAGER:-${_cat}} write_buffer "\n" print_filled_line cd ${CGAL_DIR} wait_for_enter return } # --------------------------------------------------------------------- # main menu # # get timestamp of file $1 via ls # (assumed to be in columns 6-8) _get_timestamp() { ${_ls} -l $1 | ${_awk} '{printf "%s %s %s",$7,$6,$8}' } main_menu() { while [ 0 ]; do menu_header 'Main' if [ -r ${CGAL_LIB_DIR}/`full_ostype`/${CGAL_LIB_NAME}.a ]; then print_line "Libs built: `_get_timestamp ${CGAL_LIB_DIR}/\`full_ostype\`/${CGAL_LIB_NAME}.a`" else print_line "There are no libs for this os/compiler." fi print_empty_line print_line "${_bold_on}${_bold_off} Compiler Menu" print_line "${_bold_on}${_bold_off} LEDA Menu" print_line "${_bold_on}${_bold_off} GMP Menu" print_line "${_bold_on}${_bold_off} Test (and save) setup" print_line "${_bold_on}${_bold_off} Run all setup tests (no cache)" print_empty_line print_line "${_bold_on}${_bold_off} Build CGAL Libraries" if [ -n "${CGAL_TESTSUITE}" -a -n "${LIB_COMPILED}" ]; then print_line "${_bold_on}${_bold_off} Run CGAL testsuite" fi menu_tailer 'OS' case $KEY in c|C) compiler_menu;; l|L) leda_menu;; g|G) gmp_menu;; b|B) lib_menu;; a|A) reset_all_test_variables go_down_lines 3 flush_buffer if [ -n "${LEDA_SUPPORT}" ]; then test_for_leda_incl_in_sys_incl "${INSTALL_VERBOSE}" test_for_leda_lib_in_sys_lib "${INSTALL_VERBOSE}" fi if [ -n "${GMP_SUPPORT}" ]; then search_gmp "${INSTALL_VERBOSE}" fi test_for_builtin_stl test_setup;; t|T) go_down_lines 3 flush_buffer test_setup;; s|S) if [ -n "${CGAL_TESTSUITE}" -a -n "${LIB_COMPILED}" ]; then test_menu fi ;; q|Q) return;; esac done } # --------------------------------------------------------------------- # MAIN BODY # # for command line parsing: check if ${*} is really a compiler # with its full path and set _tmp to its basename _check_comp_executable() { _tmp=`eval "_real_basename ${*} 2>/dev/null"` if [ -z "${_tmp}" ]; then exit_on_error "basename returned empty string" elif [ -z "${*}" ]; then exit_on_error "Missing argument" elif [ "`_real_dirname \"${*}\"`" != "." ]; then _check_execute ${1} elif [ ! -x "${1}" ]; then # that was not an absolute path -> try which _tmp1="`real_which ${_tmp}`" if [ -z "${_tmp1}" ]; then exit_on_error "Cannot find \"${_tmp}\"" fi _check_execute "${_tmp1}" log_print "${_tmp} is \"${_tmp1}\"." fi } cgal_install_header() { ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" \ " This is the install script for CGAL ${CGAL_VERSION}." ${_printf} "%s\n\n" \ "--------------------------------------------------------" } # --------------------------------------------------------------------- # functions for interactive modes: # startup_interactive() { ${_printf} "%s\n" " one moment, please" INSTALL_LOGFILE_REDIRECTION=">>${INSTALL_LOGFILE}" if [ -n "${_ANY_OPT}" ]; then ${_printf} "\n%s\n" \ "WARNING: In interactive mode all command line options" ${_printf} "%s\n\n" \ " except for \"-i\" and \"--CGAL_DIR\" are ignored." clear_buffer fi init_logfiles ${_printf} "." check_for_utils ${_printf} "." get_cgal_version ${_printf} "." check_conf_dir ${_printf} "." set_expr ${_printf} "." set_menu_lines ${_printf} "." set_terminal_variables ${_printf} "." } finish_interactive() { if [ -z "${ANY_LIB_COMPILED}" ]; then go_down_lines 1 print_filled_line print_line \ "WARNING: You did not build any libs during this session." else go_down_lines 3 flush_buffer ${_cat} ${INSTALL_RIS_LOGFILE} print_filled_line print_center_line "`${_basename} ${0}` completed." fi print_center_line \ "If something went wrong, (or maybe also, if not:)" print_center_line \ "have a look at `${_basename} ${INSTALL_LOGFILE}`." print_filled_line flush_buffer } # --------------------------------------------------------------------- # command line parsing # # for variable setting: # checks if $2 contains '=' # if so, sets variable $1 to the substring of $2 to the right of '=' # and returns 1 # otherwise sets variable $1 to $3 and returns 0 set_variable_from_command_line() { _tmp=`${_printf} "%s\n" "$2" | ${_awk} 'BEGIN {FS="="} {printf $2}'` if [ -n "${_tmp}" ]; then eval "$1=\"${_tmp}\"" write_buffer "${_LEFTSPACE}Set $1 to \"`value_of $1`\".\n" return 1 else eval "$1=\"$3\"" write_buffer "${_LEFTSPACE}Set $1 to \"`value_of $1`\".\n" return 0 fi } _WHAT_TO_DO='' _CONFLICT='' _ANY_OPT='' _check_for_sysutil printf y _check_for_sysutil awk y _check_for_sysutil rm y initial_check while [ ${#} -gt 0 ]; do case ${*} in --cgal_dir*|--CGAL_DIR*|-CGAL_DIR*|-cgal_dir*) if set_variable_from_command_line 'CGAL_DIR' "$1" "$2"; then shift fi set_dirs_dependant_on_cgal_dir initial_check ;; --stl_dir*|--STL_DIR*|-STL_DIR*|-stl_dir*) _ANY_OPT='y' if set_variable_from_command_line 'STL_DIR' "$1" "$2"; then shift fi STL_STATUS='e' ;; --leda_sys_incl*|--LEDA_SYS_INCL*|--leda-sys-incl*|--LEDA-SYS-INCL*|\ -leda_sys_incl*|-LEDA_SYS_INCL*|-leda-sys-incl*|-LEDA-SYS-INCL*) _ANY_OPT='y' NEED_EXTRA_LEDA_IDIR='' ;; --leda_incl_dir*|--LEDA_INCL_DIR*|-LEDA_INCL_DIR*|-leda_incl_dir*) _ANY_OPT='y' if set_variable_from_command_line 'LEDA_INCL_DIR' "$1" "$2"; then shift fi ;; --leda_sys_lib*|--LEDA_SYS_LIB*|--leda-sys-lib*|--LEDA-SYS-LIB*|\ -leda_sys_lib*|-LEDA_SYS_LIB*|-leda-sys-lib*|-LEDA-SYS-LIB*) _ANY_OPT='y' NEED_EXTRA_LEDA_LDIR='' ;; --leda_lib_dir*|--LEDA_LIB_DIR*|-LEDA_LIB_DIR*|-leda_lib_dir*) _ANY_OPT='y' if set_variable_from_command_line 'LEDA_LIB_DIR' "$1" "$2"; then shift fi ;; --gmp_incl_dir*|--GMP_INCL_DIR*|-GMP_INCL_DIR*|-gmp_incl_dir*) _ANY_OPT='y' if set_variable_from_command_line 'GMP_INCL_DIR' "$1" "$2"; then shift fi GMP_INSTALLATION='e' ;; --gmp_lib_dir*|--GMP_LIB_DIR*|-GMP_LIB_DIR*|-gmp_lib_dir*) _ANY_OPT='y' if set_variable_from_command_line 'GMP_LIB_DIR' "$1" "$2"; then shift fi GMP_INSTALLATION='e' ;; -LEDA*|-leda*|--leda*|--LEDA*) _ANY_OPT='y' LEDA_SUPPORT='_LEDA' write_buffer "${_LEFTSPACE}Enable LEDA support.\n" ;; -gmp*|-GMP*|--gmp*|--GMP*) _ANY_OPT='y' GMP_SUPPORT='_GMP' write_buffer "${_LEFTSPACE}Enable GMP support.\n" ;; -os*|-OS*) if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y' fi _WHAT_TO_DO='ostype' COMPILER=$2 shift ;; --non-interactive*|-ni*) if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y' fi _WHAT_TO_DO='non-interactive' COMPILER=$2 shift ;; --interactive*|-i*|-I*) if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y' fi _WHAT_TO_DO='interactive' ;; --verbose*|-verbose*) INSTALL_VERBOSE='y' ;; *--version*|-V*|-v*) # version ${_printf} "%s\n" "`basename $0` is ${CGAL_INSTALL_VERSION}." exit 0 ;; --rebuild-all*|-ra*|-RA*|-rba*|-RBA*) if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y' fi _WHAT_TO_DO='rebuild-all' ;; --build-all*|-ba*|-BA*) if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y' fi _WHAT_TO_DO='build-all' ;; *) _WHAT_TO_DO='help' ;; esac shift done if [ -n "${_CONFLICT}" ]; then _WHAT_TO_DO='help' fi case ${_WHAT_TO_DO} in *non-interactive*) cgal_install_header ${_printf} "%s\n" "running non interactive mode ..." INSTALL_INTERACTIVE='' INSTALL_LOGFILE_REDIRECTION='|print_with_indent' ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Locating Utilities:" ${_printf} "%s\n" \ "--------------------------------------------------------" check_for_utils check_conf_dir guess_os 'print_with_indent' ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Determining CGAL Version:" ${_printf} "%s\n" \ "--------------------------------------------------------" get_cgal_version ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Settings from Command Line:" ${_printf} "%s\n" \ "--------------------------------------------------------" _check_comp_executable ${COMPILER} INSTALL_LOGFILE_REDIRECTION='>/dev/null' COMPILER="`compiler_absolute ${COMPILER}`" INSTALL_LOGFILE_REDIRECTION='|print_with_indent' set_ostype set_compiler_flags flush_buffer ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Determining Compiler Specs:" ${_printf} "%s\n" \ "--------------------------------------------------------" INSTALL_LOGFILE_REDIRECTION='>/dev/null' test_compiler_specifica "${INSTALL_VERBOSE}" INSTALL_LOGFILE_REDIRECTION='|print_with_indent' ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Show Setup:" ${_printf} "%s\n" \ "--------------------------------------------------------" print_os_setting 'print_with_indent' ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" "Creating Directories and Makefiles:" ${_printf} "%s\n" \ "--------------------------------------------------------" make_lib_dir CGAL_MAKEFILE=${CGAL_MAKE_DIR}/makefile_`full_ostype` generatemakefiles 'print_with_indent' store_compiler_settings ${_printf} "\n%s\n" \ "--------------------------------------------------------" ${_printf} "%s\n" \ "-- DONE, please read the documentation --" ${_printf} "%s\n" \ "-- on how to proceed --" ${_printf} "%s\n" \ "--------------------------------------------------------" ;; *interactive*) cgal_install_header # start interactive part ${_printf} "%s" "starting interactive mode -" startup_interactive INSTALL_INTERACTIVE='y' search_for_compilers main_menu finish_interactive ;; *ostype*) # architecture/os key _uname=uname _basename=basename _dirname=dirname _fgrep=fgrep _which=real_which _sed=sed eval "guess_os ${_printf}" >/dev/null _check_comp_executable "${COMPILER}" COMPILER="`compiler_absolute ${COMPILER}`" set_ostype set_compiler_flags full_ostype ${_printf} "\n" ;; *build-all*) cgal_install_header ${_printf} "%s" "starting ${_WHAT_TO_DO} -" startup_interactive guess_os log_print ${_printf} "\n\n" for i in `${_ls} ${CGAL_INSTALL_CONF_DIR}/${SYST}* 2>/dev/null` do log_print log_print \ "--------------------------------------------------------" log_print "Build on `${_basename} ${i}`:" log_print \ "--------------------------------------------------------" try_to_get_var_from_file COMPILER ${i} if [ -n "${COMPILER}" ]; then set_ostype set_compiler_flags retrieve_compiler_settings case ${_WHAT_TO_DO} in *rebuild-all*) test_compiler_specifica "${INSTALL_VERBOSE}" ;; esac lib_menu store_compiler_settings else log_print "Cannot rebuild the library." print_filled_line print_empty_line print_headline "Cannot build on `${_basename} ${i}` !" print_headline "No COMPILER defined in config/install/..." print_filled_line write_buffer "\n" flush_buffer fi done finish_interactive ;; *help*) cgal_install_header print_usage_information ;; *) cgal_install_header print_general_information ;; esac exit 0 # --------------------------------------------------------------------- # EOF # ---------------------------------------------------------------------