songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cgal/Installation/install_cgal

6678 lines
178 KiB
Bash
Executable File
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/bin/sh
# ---------------------------------------------------------------------
# The CGAL Installation Script
# ---------------------------------------------------------------------
# $Id$
# ---------------------------------------------------------------------
#
# Copyright (c) 1997-2004 Utrecht University (The Netherlands),
# ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
# INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
# (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
# and Tel-Aviv University (Israel). All rights reserved.
#
# This file is part of CGAL (www.cgal.org); you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public License as
# published by the Free Software Foundation; version 2.1 of the License.
# See the file LICENSE.LGPL distributed with CGAL.
#
# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#
# $URL$
# $Id$
#
#
# Author(s): Michael Hoffmann, Sylvain Pion
# ---------------------------------------------------------------------
# some important global variables
# ---------------------------------------------------------------------
# ---------------------------------------------
# CGAL specific:
# ---------------------------------------------
CGAL_VERSION="version_to_be_determined"
# ---------------------------------------------
CGAL_INSTALL_CGAL="`basename ${0}`"
# ---------------------------------------------
CGAL_INSTALL_VERSION='$Id$'
# ---------------------------------------------
CGAL_DIR="`pwd`"
# ---------------------------------------------
CGAL_INSTALL_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_'
# ---------------------------------------------
# will be automatically set later to 'y' if the test/ directory is present,
# which will enable the test-suite menu.
INTERNAL_RELEASE=''
# ---------------------------------------------
# set to non-empty string, if MIPSPRO 64 compiler
# is to be supported
SUPPORT_MIPSPRO_64='y'
# ---------------------------------------------
# the directory of an existing CGAL installation
# we want to upgrade
UPGRADE_FROM=''
# ---------------------------------------------
# the config name we want to [re]build one
BUILD_ONE_CONFIG=''
# ---------------------------------------------
# set to empty to disable building of shared libraries.
ENABLE_SHARED='y'
# ---------------------------------------------
# LEDA specific:
# suffix for include makefile:
# toggles the use of LEDA: ('' - no LEDA, '_LEDA' - LEDA)
LEDA_SUPPORT=''
LEDA_VERSION=''
# directories for LEDA
LEDA_INCL_DIR=''
LEDA_LIB_DIR=''
# did LEDA tests succeed ('' - no, 'y' - yep)
LEDA_TEST_PASSED=''
# ---------------------------------------------
# GMP specific:
#
# toggles use of GMP ('' - no, '_GMP' - use it)
GMP_SUPPORT=''
GMP_VERSION=''
# 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
GMP_INSTALLATION=''
GMP_INCL_DIR=''
GMP_LIB_DIR=''
# did GMP tests succeed ('' - no, 'y' - yep)
GMP_TEST_PASSED=''
# toggles use of GMP's C++ wrapper ('' - no, '_GMPXX' - use it)
GMPXX_SUPPORT=''
GMPXX_VERSION=''
# did GMPXX test succeed ('' - no, 'y' - yep)
GMPXX_TEST_PASSED=''
# ---------------------------------------------
# CORE specific:
#
# toggles use of CORE ('' - no, '_CORE' - use it)
CORE_SUPPORT=''
CORE_VERSION=''
# indicate whether and where CORE is installed
# ('' - didn't try,
# 'e' - we need compiler/linker flags and CORE_INCL_DIR/LIB_DIR for this,
# 'c' - in the cgal tree,
# 'z' - in the cgal tree, but specify CORE_INCL_DIR/LIB_DIR anyway)
CORE_INSTALLATION=''
CORE_INCL_DIR=''
CORE_LIB_DIR=''
# did CORE test succeed ('' - no, 'y' - yep)
CORE_TEST_PASSED=''
# ---------------------------------------------
# QT specific:
#
# toggles use of QT ('' - no, '_QT' - use it)
QT_SUPPORT=''
QT_VERSION=''
# directories for QT
QT_DIR=''
QT_INCL_DIR=''
QT_LIB_DIR=''
# Qt Meta Object Compiler
QT_MOC=''
# Qt advanced mode ('' - basic mode, 'y' - advanced mode)
QT_ADVANCED_MODE=''
# do we have to provide extra incl/lib flags for Qt('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_QT_IDIR='y'
NEED_EXTRA_QT_LDIR='y'
# do we have to provide a path for moc
# or is it in $PATH (''),
# or do we want to provide a path for moc, although it is in
# the path ('x')
# set to 'n', if this has not been tested yet
NEED_EXTRA_QTMOC='y'
# do we have to provide an extra QTDIR ('y')
# or is it in environment (''),
# or do we want to provide extra QTDIR, although it is defined
# in the environment
# set to 'n', if this has not been tested yet
NEED_EXTRA_QTDIR='y'
# did QT tests succeed ('' - no, 'y' - yep)
QT_MOC_TEST_PASSED=''
QT_TEST_PASSED=''
#WINDOWS ONLY:
#The second library used with qtmain.lib
QT_SECOND_LIB='qt'
QT_T_SUPPORT='n'
QT_DLL='not_defined'
#END WINDOWS ONLY
# indicate whether there is a "long name problem" on
# the current platform
LONG_NAME_PROBLEM=''
# ---------------------------------------------------------------------
# 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:
# <BASENAME>@<DESCRIPTION>@<CC_EXECUTABLE>@<CXX_EXECUTABLE>@<VERSION_ID>@<CUSTOM_TAG>
# 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=''
# indicates whether the compiler is supported by CGAL or not
# empty <=> unsupported
CGAL_SUPPORT_COMPILER=''
# string defining OS and compiler
# (used for naming makefiles and lib directories)
CGAL_OS_COMPILER=''
# this is woven into CGAL_OS_COMPILER; allows to run different installations
# for the same os/compiler combination
CUSTOM_OSTYPE_TAG=''
# can we start building the libs?
SETUP_COMPLETE=''
# has compiler config test been run ('' - no, 'y' - yep)
CONFIG_TEST_PASSED=''
# 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=''
# LGPL License header to be used in some generated files.
LGPL_LICENSE_HEADER=\
"// Copyright (c) 1996-2004 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE."
# ---------------------------------------------------------------------
# How to use this script
# ---------------------------------------------------------------------
print_general_information()
{
${_printf} "%s\n\n" \
"You can get a list of all options with \"${CGAL_INSTALL_CGAL} --help\"
First-time installers:
----------------------
Just type \"${CGAL_INSTALL_CGAL} -i\" and follow the menus.
If you get stuck, please read the documentation."
}
print_usage_information()
{
${_printf} "%s\n\n" \
"Usage: ${CGAL_INSTALL_CGAL}
[--help | --version | -i | --interactive |
-u <dir> | --upgrade <dir> | --build-all | --rebuild-all |
--build <config> | --rebuild <config> | --disable-shared |
-ni <comp> | --non-interactive <comp> | -os <comp>]
[-leda] [-core] [-gmp] [-gmpxx] [-qt] [-qt_mt] [--verbose]
[--prefix <dir>]
[--CGAL_DIR <dir>]
[--LEDA_INCL_DIR <dir>] [--LEDA_LIB_DIR <dir>]
[--GMP_INCL_DIR <dir>] [--GMP_LIB_DIR <dir>]
[--CORE_INCL_DIR <dir>] [--CORE_LIB_DIR <dir>]
[--QT_DIR <dir>] [--QT_INCL_DIR <dir>]
[--QT_LIB_DIR <dir>] [--QT_MOC <exe>]
[--CXXFLAGS <flags>] [--LDFLAGS <flags>]
[--ostype_tag <tag>]
-leda enables support for LEDA
-core enables support for CORE
-gmp enables support for GMP
-gmpxx enables support for GMP built-in C++ interface
-qt enables support for Qt
-qt_mt enables thread support for Qt
--verbose give report for each test that fails
(not generally recommended)
--help gives this message
--version prints ${CGAL_INSTALL_CGAL} version number
--prefix <dir>
specifies an installation directory
--CGAL_DIR <dir>
specifies an explicit path to use for the CGAL directory
--interactive or -i
runs the script in interactive mode
(other options - except for --CGAL_DIR - are ignored)
--upgrade <dir> or -u <dir>
runs the script in upgrade mode
Use this option, if you upgrade from a previously installed
CGAL and supply the directory where it is installed
on your system.
The config/install files and GMP installations will
be copied from there.
--build-all
Build libraries for all compilers for which a
config/install file exists.
--rebuild-all
(Re)build compiler configuration files and libraries
for all compilers for which a config/install file
exists.
--build <config>
Build libraries for the compiler specified by its
configuration file config/install/<config>.
--rebuild <config>
(Re)build the compiler configuration file and libraries
for the compiler specified by its configuration file
config/install/<config>.
--disable-shared
Do not build shared libraries, only the static archives.
--non-interactive <comp> or -ni <comp>
runs the script in non-interactive mode
i.e. makefiles are generated for C++ compiler
specified by <comp>.
For the rest you are on your own.
(Have a look at the README file.)
-os <comp> prints architecture/os/compiler specifications
--CXXFLAGS <flags>
pass the specified <flags> to the compiler
--LDFLAGS <flags>
pass the specified <flags> to the linker
--ostype_tag <tag>
weave this tag into architecture/os/compiler specification"
}
# ---------------------------------------------------------------------
# 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()
{
for i in `echo ${PATH} | sed 's/ //g' | awk 'BEGIN {RS=":"}{print $0}'`
do
i=`echo $i | sed 's// /g'`
if [ -x "${i}/$1" ]; then
echo ${i}/$1
return
fi
done
}
# basename/dirname is somewhat nasty when having options like:
# /<path>/<cmd> -<opt1> ... -<optn>
_real_basename()
{
${_basename} "`${_printf} \"${*}\" | ${_awk} '{ printf \"%s\",$1; for (i=2; i<=NF; ++i) if (substr($i,0,1) != \"-\") printf \"%s\",$i }'`"
}
_real_dirname()
{
${_dirname} "`${_printf} \"${*}\" | ${_awk} '{ printf \"%s\",$1; for (i=2; i<=NF; ++i) if (substr($i,0,1) != \"-\") printf \"%s\",$i }'`"
}
_real_options()
{
${_printf} "${*}" | ${_awk} '{ for (i=2; i<=NF; ++i) if (substr($i,0,1) == "-") 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} -p ${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/version.h
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/version.h"
_check_read ${FILE}
CGAL_VERSION="`${_awk} '/#define CGAL_VERSION / {print $3}' ${FILE}`"
log_print "CGAL version is ${CGAL_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}
}
# check ${CGAL_INSTALL_CONF_DIR}: create it, if not existent
check_conf_dir()
{
_check_dir_exists ${CGAL_MAKE_DIR}
_check_dir_exists ${CGAL_SRC_DIR}
_check_dir_exists ${CGAL_INCL_DIR}
_check_dir_exists_create ${CGAL_INCL_CONF_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}'
}
# on some systems, like FreeBSD, printf handles options, that's why
# the first options should be --
#
# printf to use on some systems
printf_dash_dash()
{
${_printf_bin} -- "$@"
}
# check if printf handles options
# $1 indicates verbosity
_check_printf()
{
if [ x`${_printf} "-I%s" CGAL 2>/dev/null` != "x-ICGAL" ]; then
_printf_bin=${_printf}
_printf=printf_dash_dash
if [ x`${_printf} "-I%s" CGAL 2>/dev/null` != "x-ICGAL" ]; then
exit_on_error "Cannot find a working printf."
fi
if [ -n "$1" ]; then
log_print "REMARK: printf handles options: printf='printf --'"
fi
fi
}
# check, if all needed utility programs are available
# (they should be on a unix system, but ...)
check_for_utils()
{
_which=real_which
_check_for_sysutil basename y
_check_for_sysutil dirname y
_check_for_sysutil uname y
_check_for_sysutil printf y
_check_printf $INSTALL_VERBOSE
_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 sed y
_check_for_sysutil tr y
_check_for_sysutil awk y
_check_for_sysutil tee y
_check_for_sysutil find y
_check_for_sysutil tar y
# test whether sed respects newline (I have seen at least one
# Darwin version that does not...)
case `${_printf} '1\n2\n' | ${_sed} '/^1/c\\
2'` in
22) log_print "sed does not respect newline."
_EXTRA_NEWLINE='
';;
*) log_print "sed respects newline."
_EXTRA_NEWLINE='';;
esac
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 ${CGAL_INSTALL_CGAL} 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 | ${_sed} 's/_/-/g' 2>/dev/null`
if [ -z "${_tmp}" -o "${_tmp}" = 'unknown' -o "`${_uname}`" = "Linux" ]; then
_tmp=`${_uname} -m | ${_sed} 's/_/-/g' 2>/dev/null`
fi
if [ -n "${_tmp}" ]; then
_tmp=${_tmp}"_"
else
$1 "WARNING: Could not determine architecture."
fi
_tmpx="`${_uname} -s | ${_sed} 's/_//g'`"
# if there is already a minus in `uname -s` (as, e.g., on Cygwin)
# we don't append `uname -r`
case "${_tmpx}" in
*-*) SYST="${_tmp}${_tmpx}";;
*) SYST="${_tmp}${_tmpx}-`${_uname} -r | ${_awk} 'BEGIN {FS=\".\"}{printf \"%d.%d\n\",$1,$2}' | ${_sed} -e 's/(.*)//g' -e 's/_/-/g' | ${_awk} '{print $1}'`";;
esac
$1 "OS is \"${SYST}\"."
}
# the old version, used for transition...
# to be removed at some point
old_guess_os()
{
_tmp=`${_uname} -p | ${_sed} 's/_/-/g' 2>/dev/null`
if [ -z "${_tmp}" -o "${_tmp}" = 'unknown' -o "`${_uname}`" = "Linux" ]; then
_tmp=`${_uname} -m | ${_sed} 's/_/-/g' 2>/dev/null`
fi
if [ -n "${_tmp}" ]; then
_tmp=${_tmp}"_"
fi
OLD_SYST="${_tmp}`${_uname} -s | ${_sed} 's/_//g'`-`${_uname} -r | ${_sed} -e 's/(.*)//g' -e 's/_/-/g' | ${_awk} '{print $1}'`"
}
# -------------------------------------------------------
# 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_INSTALL_CONF_DIR=${CGAL_CONF_DIR}/install
CGAL_TEST_CONF_DIR=${CGAL_CONF_DIR}/testfiles
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=./tmp_test
# detect if we are an internal release
if [ -d $CGAL_TEST_DIR ]; then
INTERNAL_RELEASE='y'
else
INTERNAL_RELEASE=''
fi
}
# initialize once
set_dirs_dependant_on_cgal_dir
# -------------------------------------------------------------------
# compiler related functions:
# -------------------------------------------------------------------
# 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()
{
# set some compiler/os specific variables
# defaults:
ADDITIONAL_CXXFLAGS=""
ADDITIONAL_LDFLAGS=""
LONG_NAME_PROBLEM_CXXFLAGS=""
LONG_NAME_PROBLEM_LDFLAGS=""
CGAL_LIB_CXXFLAGS=""
CGAL_LIB_LDFLAGS=""
CGAL_LIB_CREATE="ar cr ''"
CGAL_OBJ_PREFIX=""
CGAL_SHARED_LIB_CXXFLAGS="-fpic"
CGAL_SHARED_LIB_LDFLAGS=
CGAL_WINLIB_CXXFLAGS=""
CGAL_QT_CXXFLAGS=""
WINDOW_INCLUDE=""
WINDOW_DIR="/usr/X11R6/lib"
XLIBS="-lX11"
RUNTIME_LINKER_FLAG=''
PRINT_STACKTRACE_PROGRAM="gdb"
WINDOWS_COMPILER=""
CYGWIN_COMPILER=""
SUFFIX_LIST=
OBJ_EXT=".o"
OBJ_OPT="-c"
LIB_SUFFIX=""
SHARED_LIB_EXT=".so"
REMOVE_EXT_LIST=".o"
LIB_OPT=" -l"
LIBPATH_OPT=" -L"
DEBUG_OPT="-g"
EXE_OPT="-o "
SAVE_THE_BLANK="\$(SAVESTHEBLANK)"
EXE_EXT=""
CGAL_LIBNAME="libCGAL.a"
CGAL_QT_LIBNAME="libCGALQt.a"
CORE_LIBNAME="libcore++.a"
CGAL_WIN_EXTRA_DIR=x11
GMP_LIBNAME="libgmp.a"
GMPXX_LIBNAME="libgmpxx.a"
MPFR_LIBNAME="libmpfr.a"
MATH_LIB="m"
OPENGL_LIBS="-lGL -lGLU"
SEPARATE_LIBPATH=""
START_LD_OPT=""
CGAL_CXX="`compiler_bin`"
CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared"
RANLIB="cat >/dev/null"
case ${CGAL_OS_COMPILER} in
*bcc32.exe*|*BCC32*)
#### settings Borland C++ compiler
ADDITIONAL_CXXFLAGS="-P -vi- -w-inl"
CGAL_LIB_CXXFLAGS="-P"
CGAL_LIB_CREATE="tlib /C /P512 ''"
CGAL_OBJ_PREFIX="+"
WINDOW_DIR=""
XLIBS=""
WINDOWS_COMPILER="y"
CYGWIN_COMPILER="y"
SUFFIX_LIST=".obj .exe"
OBJ_EXT=".obj"
LIB_SUFFIX=".lib"
REMOVE_EXT_LIST=".obj .tds"
LIB_OPT=""
DEBUG_OPT=""
EXE_OPT="-e"
SAVE_THE_BLANK=""
EXE_EXT=".exe"
CGAL_LIBNAME="CGAL.lib"
CGAL_QT_LIBNAME="CGALQt.lib"
CORE_LIBNAME="libcore++.lib"
CGAL_WIN_EXTRA_DIR=mswin
GMP_LIBNAME="gmp.lib"
GMPXX_LIBNAME="gmpxx.lib"
MPFR_LIBNAME="mpfr.lib"
MATH_LIB=""
OPENGL_LIBS="Opengl32.lib Glu32.lib"
SEPARATE_LIBPATH="y"
;;
*ICL.*|*icl.*)
#### settings Intel C++ compiler
WINDOWS_COMPILER="y"
CYGWIN_COMPILER="y"
ADDITIONAL_CXXFLAGS="-Op -TP -GR -EHsc -Zm900 -nologo -Zc:wchar_t -Zc:forScope"
ADDITIONAL_LDFLAGS="-nologo"
# CGAL_LIB_CXXFLAGS="-TP"
# CGAL_QT_CXXFLAGS="-DQT_DLL -DQT_THREAD_SUPPORT"
CGAL_LIB_CREATE="LIB /OUT:"
CGAL_SHARED_LIB_CXXFLAGS=
CGAL_SHARED_LIB_CREATE=
WINDOW_DIR=
XLIBS="ws2_32.lib user32.lib gdi32.lib comdlg32.lib shell32.lib advapi32.lib"
SUFFIX_LIST=".obj .exe"
OBJ_EXT=".obj"
LIB_SUFFIX=".lib"
REMOVE_EXT_LIST=".obj"
LIB_OPT=""
LIBPATH_OPT="-LIBPATH:"
DEBUG_OPT="-Z7"
EXE_OPT="-Fe"
SAVE_THE_BLANK=""
EXE_EXT=".exe"
CGAL_LIBNAME="CGAL.lib"
CGAL_QT_LIBNAME="CGALQt.lib"
CORE_LIBNAME="core++.lib"
CGAL_WIN_EXTRA_DIR=mswin
GMP_LIBNAME="gmp.lib"
GMPXX_LIBNAME="gmpxx.lib"
MPFR_LIBNAME="mpfr.lib"
MATH_LIB=
OPENGL_LIBS="Opengl32.lib Glu32.lib"
START_LD_OPT="-link "
;;
*CL.*|*cl.*)
#### settings Microsoft Visual C++ compiler
WINDOWS_COMPILER="y"
CYGWIN_COMPILER="y"
ADDITIONAL_CXXFLAGS="-TP -GR -EHsc -Zm900 -nologo"
ADDITIONAL_LDFLAGS="-nologo"
# CGAL_LIB_CXXFLAGS="-TP"
# CGAL_QT_CXXFLAGS="-DQT_DLL -DQT_THREAD_SUPPORT"
CGAL_LIB_CREATE="LIB /OUT:"
CGAL_SHARED_LIB_CXXFLAGS=
CGAL_SHARED_LIB_CREATE=
WINDOW_DIR=
XLIBS="ws2_32.lib user32.lib gdi32.lib comdlg32.lib shell32.lib advapi32.lib"
SUFFIX_LIST=".obj .exe"
OBJ_EXT=".obj"
LIB_SUFFIX=".lib"
REMOVE_EXT_LIST=".obj"
LIB_OPT=""
LIBPATH_OPT="-LIBPATH:"
DEBUG_OPT="-Z7"
EXE_OPT="-Fe"
SAVE_THE_BLANK=""
EXE_EXT=".exe"
CGAL_LIBNAME="CGAL.lib"
CGAL_QT_LIBNAME="CGALQt.lib"
CORE_LIBNAME="core++.lib"
CGAL_WIN_EXTRA_DIR=mswin
GMP_LIBNAME="gmp.lib"
GMPXX_LIBNAME="gmpxx.lib"
MPFR_LIBNAME="mpfr.lib"
MATH_LIB=
OPENGL_LIBS="Opengl32.lib Glu32.lib"
START_LD_OPT="-link "
;;
*IRIX*5.*CC*)
#### settings for sgi mipspro compiler on irix5
CGAL_SHARED_LIB_CXXFLAGS=
CGAL_SHARED_LIB_LDFLAGS="-lm"
RUNTIME_LINKER_FLAG="-rpath "
PRINT_STACKTRACE_PROGRAM="dbx"
WINDOW_DIR="/usr/lib/X11"
;;
*IRIX*6.*CC*7.3*)
#### settings for sgi mipspro compiler V7.3 on irix6
ADDITIONAL_CXXFLAGS="-LANG:std"
ADDITIONAL_LDFLAGS="-LANG:std"
CGAL_LIB_CREATE="\$(CGAL_CXX) -ar -o''"
CGAL_SHARED_LIB_CXXFLAGS=
RUNTIME_LINKER_FLAG="-rpath "
PRINT_STACKTRACE_PROGRAM="dbx"
WINDOW_DIR="/usr/lib/X11"
;;
*IRIX*6.*CC*)
#### settings for sgi mipspro compiler on irix6
CGAL_LIB_CREATE="\$(CGAL_CXX) -ar -o''"
CGAL_SHARED_LIB_CXXFLAGS=
RUNTIME_LINKER_FLAG="-rpath "
PRINT_STACKTRACE_PROGRAM="dbx"
WINDOW_DIR="/usr/lib/X11"
;;
*IRIX*g++*)
#### settings for gcc on irix
ADDITIONAL_CXXFLAGS="-Wall"
LONG_NAME_PROBLEM_LDFLAGS="-U -s"
CGAL_SHARED_LIB_LDFLAGS="-lm"
RUNTIME_LINKER_FLAG="-Xlinker -rpath -Xlinker "
WINDOW_DIR="/usr/lib/X11"
;;
*SunOS*5.*CC*)
#### settings for sunpro compiler on solaris
ADDITIONAL_CXXFLAGS="-pto -D_RWSTD_ALLOCATOR"
CGAL_LIB_CREATE="\$(CGAL_CXX) -xar -o ''"
CGAL_SHARED_LIB_CXXFLAGS="-pic"
CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -G"
WINDOW_INCLUDE="/usr/openwin/include"
WINDOW_DIR="/usr/openwin/lib"
RUNTIME_LINKER_FLAG="-R "
PRINT_STACKTRACE_PROGRAM="dbx"
;;
*SunOS*5.*g++*)
#### settings for gcc on solaris
LONG_NAME_PROBLEM_CXXFLAGS="-g"
LONG_NAME_PROBLEM_LDFLAGS="-z nodefs -s"
CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -G"
CGAL_WINLIB_CXXFLAGS="-fpermissive"
WINDOW_INCLUDE="/usr/openwin/include"
WINDOW_DIR="/usr/openwin/lib"
RUNTIME_LINKER_FLAG="-R "
;;
*alpha*Linux*g++*)
#### settings for g++ on alpha-linux (special FPU handling)
#### LONG_NAME_PROBLEM is cured by disabling debugging
ADDITIONAL_CXXFLAGS="-Wall -mieee -mfp-rounding-mode=d"
RUNTIME_LINKER_FLAG='-Wl,-R'
;;
*Linux*g++*)
#### settings for gcc on linux
ADDITIONAL_CXXFLAGS="-Wall"
RUNTIME_LINKER_FLAG='-Wl,-R'
;;
*Linux*icc*|*Linux*icpc*)
#### settings for icc on linux
# -mp is required for correct enough floating point operations
# necessary for interval arithmetic.
ADDITIONAL_CXXFLAGS="-mp"
RUNTIME_LINKER_FLAG='-Wl,-R'
PRINT_STACKTRACE_PROGRAM="idb"
;;
*CYGWIN*g++*)
#### settings for gcc on Cygwin
ADDITIONAL_CXXFLAGS="-Wall"
WINDOW_DIR=
XLIBS="-luser32 -lgdi32 -lcomdlg32 -lshell32"
EXE_EXT=".exe"
;;
*MINGW*g++*)
#### settings for gcc on mingw
ADDITIONAL_CXXFLAGS="-Wall"
WINDOW_DIR=
XLIBS="-luser32 -lgdi32 -lcomdlg32 -lshell32"
EXE_EXT=".exe"
;;
*Darwin*g++*)
#### settings for gcc on Darwin
ADDITIONAL_CXXFLAGS="-Wall -fno-common"
CGAL_SHARED_LIB_CXXFLAGS=""
CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -dynamiclib"
SHARED_LIB_EXT=".dylib"
RUNTIME_LINKER_FLAG=''
RANLIB="ranlib"
;;
*mwcc.exe*|*MWCC*)
#### settings Metroworks C++ compiler
ADDITIONAL_CXXFLAGS="-gccincludes -lang c++ -msgstyle gcc "
CGAL_LIB_CXXFLAGS=""
CGAL_LIB_CREATE="mwld -library -o "
WINDOW_DIR=""
CYGWIN_COMPILER="y"
XLIBS=""
SUFFIX_LIST=".obj .exe"
OBJ_EXT=".obj"
REMOVE_EXT_LIST=".obj"
DEBUG_OPT=""
EXE_OPT="-o "
EXE_EXT=".exe"
CGAL_WIN_EXTRA_DIR=mswin
GMP_LIBNAME="gmp.lib"
GMPXX_LIBNAME="gmpxx.lib"
MPFR_LIBNAME="mpfr.lib"
MATH_LIB=""
SEPARATE_LIBPATH="y"
;;
*Linux*pgCC*)
#### settings for Portland Group Compiler on linux
RUNTIME_LINKER_FLAG='-Wl,-R'
# PGCC has long name problems with "-g".
DEBUG_OPT=""
;;
*)
#### settings for unknown compiler
CGAL_SHARED_LIB_CREATE="`compiler_bin` -G"
;;
esac
# Remove *.moc files too, on all platforms
REMOVE_EXT_LIST="${REMOVE_EXT_LIST} .moc"
# version specific adjustments for gcc
case `compiler_description` in
*GNU*)
case `compiler_version` in
2.*) ADDITIONAL_CXXFLAGS="${ADDITIONAL_CXXFLAGS} -ftemplate-depth-50";;
3.*) : ;;
*) ADDITIONAL_CXXFLAGS="${ADDITIONAL_CXXFLAGS} -frounding-math";;
# g++-4.x and after: we need -frounding-math to avoid FPU rounding mode optimisations
esac
;;
esac
# version specific adjustments for msvc
case ${CGAL_OS_COMPILER} in
*CL.*|*cl.*) ADDITIONAL_CXXFLAGS="${ADDITIONAL_CXXFLAGS}";;
*ICL.*|*icl.*) ADDITIONAL_CXXFLAGS="${ADDITIONAL_CXXFLAGS} `include_dir_option D:/vc7/include`";;
esac
}
# --------------------------------------------------------------------------
# Following code is taken from make_redirection_headers
# (by Geert-Jan <geert@cs.uu.nl>)
#
# internal variables from make_redirection_headers
#
tmp_code_file=redirect_tmpfile.C
tmp_header_file=redirect_tmpfile
# this function is used to add symbols to namespace std
# (that should be present, but are not due to compiler/stdlib bugs)
print_using()
{
_tmp=${1}
shift
${_printf} "\n%s\n" \
"#if defined(CGAL_CFG_NO_STD${_tmp}_NAMESPACE) && !defined(CGAL_NO_STD${_tmp}_NAMESPACE)"
${_printf} "\n%s\n" "namespace std {"
for i in ${*}; do
${_printf} "\t%s\n" "using ::${i};"
done
${_printf} "%s\n" "}"
${_printf} "\n%s\n" \
"#endif // CGAL_CFG_NO_STD${_tmp}_NAMESPACE && !CGAL_NO_STD${_tmp}_NAMESPACE"
}
# this function is used to undefine macros (used for cctype)
print_undef()
{
for i in ${*}; do
${_printf} "%s\n" "#ifdef ${i}"
${_printf} "%s\n" "#undef ${i}"
${_printf} "%s\n" "#endif // ${i}"
done
}
quote()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "%s\n" "${*}"
else
${_printf} "%s\n" "\"${*}\""
fi
}
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...
#
{
uncond=''
# special option to create header unconditionally (for CCTYPE_MACRO_BUG)
if [ "${1}" = "notest" ]; then
shift
uncond='y'
fi
replacement_header=rh
header_name=$1
header_suffix=$2
shift 2
_final_file="${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}/${header_name}${header_suffix}"
#
# Test if the standard header exists. Return if it does.
#
if [ -z "${uncond}" ]; then
${_printf} "%s\n" "#include <$header_name>" > ${tmp_code_file}
${_printf} "%s\n" "int main() {return 0;}" >> ${tmp_code_file}
if eval "`quote \`compiler_bin\`` ${ADDITIONAL_CXXFLAGS} ${tmp_code_file} >/dev/null 2>&1"; then
${_printf} "%s\n" " ok."
return;
fi
${_printf} "%s\n" " no."
fi
#
# The standard header does not exist.
# If some of the replacement headers exist, they are 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 eval "`quote \`compiler_bin\`` ${ADDITIONAL_CXXFLAGS} ${tmp_code_file} >/dev/null 2>&1"; then
${_cat} <<EOF3 >>${replacement_header}
$LGPL_LICENSE_HEADER
//
// Author(s): install_cgal script
// This file was automatically generated during installation.
// It wraps a standard header file that did not exist for this compiler
// and adds its symbols to namespace std.
// The existence of this file indicates that your compiler does not
// conform to the ISO/IEC standard 14882 for C++.
EOF3
${_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
#
# this is just an ugly list of additions to namespace std
#
case ${header_name} in
iosfwd|ios)
print_using IO ios >> ${replacement_header};;
fstream) print_using IO filebuf ifstream ofstream fstream >> ${replacement_header};;
streambuf) print_using IO streampos streamoff streambuf >> ${replacement_header};;
iomanip) print_using IO setbase resetiosflags setiosflags setfill setprecision setw >> ${replacement_header};;
iostream) print_using IO cin cout cerr clog endl ends flush ios streampos streamoff streambuf ostream istream iostream istream_withassign ostream_withassign iostream_withassign >> ${replacement_header};;
# those do not exist e.g. on mipspro: wcin wcout wcerr wclog
istream) print_using IO istream istream_withassign >> ${replacement_header};;
ostream) print_using IO ostream ostream_withassign >> ${replacement_header};;
strstream) print_using IO strstream istrstream ostrstream >> ${replacement_header};;
csetjmp) print_using C longjmp jmp_buf >> ${replacement_header};;
cstdarg) print_using C va_list >> ${replacement_header};;
ctime) print_using C size_t time_t clock_t tm asctime ctime clock difftime gmtime localtime mktime time strftime >> ${replacement_header};;
csignal) print_using C sig_atomic_t raise signal >> ${replacement_header};;
cstdlib) print_using C abort atexit exit getenv system calloc malloc free realloc atof atoi atol mblen mbstowcs mbtowc strtod strtol strtoul wcstombs wctomb bsearch qsort div_t ldiv_t abs div labs ldiv rand srand >> ${replacement_header};;
# the functions from cctype are implemented as macros
# on some platforms (IRIX6, Solaris2.6)
# but they have to be functions according to the std!
cctype) ${_printf} "\n%s\n" \
"#ifdef CGAL_CFG_CCTYPE_MACRO_BUG" >> ${replacement_header}
print_undef isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit >> ${replacement_header}
${_printf} "\n%s\n" \
"#endif // CGAL_CFG_CCTYPE_MACRO_BUG" >> ${replacement_header}
print_using C isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit >> ${replacement_header};;
cwctype) print_using C wctrans_t wctype_t wint_t iswalnum iswalpha iswcntrl iswctype iswdigit iswgraph iswlower iswprint iswpunct iswspace iswupper iswxdigit towctrans towlower towupper wctrans wctype >> ${replacement_header};;
cstring) print_using C size_t memchr memcmp memcpy memmove memset strcat strchr strcmp strcoll strcpy strcspn strerror strlen strncat strncmp strncpy strpbrk strrchr strspn strstr strtok strxfrm >> ${replacement_header};;
cwchar) print_using C wint_t size_t fgetwc fgetws fputwc fputws getwc getwchar putwc putwchar ungetwc wcscat wcschr wcscmp wcscoll wcscpy wcscspn wcsftime wcslen wcsncat wcsncmp wcsncpy wcspbrk wcsrchr wcsspn wcstod wcstok wcstol wcstoul wcsxfrm >> ${replacement_header};;
cstdio) print_using C FILE fpos_t size_t clearerr fclose feof ferror fflush fgetc fgetpos fgets fopen fprintf fputc fputs fread freopen fscanf fseek fsetpos ftell fwrite getc getchar gets perror printf putc putchar puts remove rename rewind scanf setbuf setvbuf sprintf sscanf tmpfile tmpnam ungetc vfprintf vprintf vsprintf >> ${replacement_header};;
cmath) print_using C acos asin atan2 atan ceil cos cosh exp fabs floor fmod frexp ldexp log10 log modf pow sin sinh sqrt tan tanh >> ${replacement_header};;
cstddef) print_using C ptrdiff_t size_t >> ${replacement_header};;
esac
#
# end of ugly list of additions to namespace std :)
#
${_printf} "\n%s\n" "// EOF //" >> ${replacement_header}
mv ${replacement_header} "${_final_file}"
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 eval "`quote \`compiler_bin\`` ${ADDITIONAL_CXXFLAGS} -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
done <<EOF2
algorithm algobase.h algo.h
ostream ostream.h
numeric numeric.h
new new.h
memory alloc.h algobase.h
map map.h multimap.h
locale locale.h
list list.h
limits
iterator iterator.h
istream istream.h
iostream iostream.h
iosfwd iostream.h
ios ios.h
iomanip iomanip.h
functional function.h
fstream fstream.h
exception exception.h
deque deque.h
cwctype wctype.h
cwchar wchar.h
ctime time.h
cstring string.h
cstdlib stdlib.h
cstdio stdio.h
cstddef stddef.h
cstdarg stdarg.h
csignal signal.h
csetjmp setjmp.h
complex complex.h
cmath math.h
clocale locale.h
climits limits.h
ciso646 iso646.h
cfloat float.h
cerrno errno.h
cctype ctype.h
cassert assert.h
bitset bitset.h
queue stack.h
vector vector.h
valarray valarray.h
utility function.h pair.h
typeinfo typeinfo.h
string
streambuf streambuf.h
strstream strstream.h
stdexcept stdexcept.h
stack stack.h
sstream sstream.h
set set.h multiset.h
EOF2
}
#
# end of code segment from make_redirection_headers
# --------------------------------------------------------------------------
# COMPILER SPECS TEST:
# set some compiler specific flags needed for CGAL
# these flags are determined by the corresponding test-sources
# in CGAL_CONF_DIR
# ($1 nonzero indicates verbosity)
test_compiler_specifica()
{
${_cat} <<EOF5 >${_file}
$LGPL_LICENSE_HEADER
//
// Author(s): the install_cgal script
// Compiler specific configuration file for CGAL ${CGAL_VERSION}
// System: ${CGAL_OS_COMPILER}
// generated by ${CGAL_INSTALL_CGAL} ${CGAL_INSTALL_VERSION}
EOF5
# test for other compiler features/bugs
LONG_NAME_PROBLEM=''
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}" \
"`compiler_test_cxxflags` " \
"$1" \
"${_NO}" \
&& _link_run_test \
"${_tmp_name}" \
"`compiler_test_libpathflags` " \
"`compiler_test_ldflags` " \
"$1" \
"${_NO}"
then
${_printf} "%s" "//" >> ${_file}
elif [ "`${_basename} ${i}`" = "CGAL_CFG_CCTYPE_MACRO_BUG.C" ]; then
# we have to generate the redirection header cctype
create_replacement_header notest cctype "" ctype.h
elif [ "`${_basename} ${i}`" = "CGAL_CFG_LONGNAME_BUG.C" ]; then
LONG_NAME_PROBLEM=y
elif [ "`${_basename} ${i}`" = "CGAL_CFG_NO_STL.C" ]; then
log_print "`extended_compiler_description` seems NOT to have STL."
fi
${_printf} "%s\n\n" \
"#define ${CGAL_CONFIG_PREFIX}${_test_name} 1" \
>> ${_file}
cleanup_after_compile
cleanup_after_link_run
done
}
#---------------------------------------------------------
# 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
filename_for_compiler "`value_of \"${1}\"`"
fi
}
posix_path()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "%s" "$*"
else
${_printf} "%s" "`${_cygpath} -u $*`"
fi
}
filename_for_compiler()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "%s" "$1"
else
${_printf} "%s" "`${_cygpath} -w $1`"
fi
}
include_dir_option()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "-I%s " "$1"
else
${_printf} "'-I%s' " "`${_cygpath} -w $1`"
fi
}
libpath_option()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "${LIBPATH_OPT}%s " "$*"
else
${_printf} "'${LIBPATH_OPT}%s' " "`${_cygpath} -w $*`"
fi
}
leda_lib_option()
{
if [ -z "${WINDOWS_COMPILER}" ]; then
${_printf} "${LIB_OPT}%s${LIB_SUFFIX} " "$*"
else
${_printf} "${LIB_OPT}lib%s${LIB_SUFFIX} " "$*"
fi
}
lib_option()
{
${_printf} "${LIB_OPT}%s${LIB_SUFFIX} " "$*"
}
object_file_name()
{
if [ -z "${CYGWIN_COMPILER}" ]; then
${_printf} "%s" "$1${OBJ_EXT}"
else
${_printf} "%s" "'`${_cygpath} -w $1`${OBJ_EXT}'"
fi
}
to_object_file_option()
{
if [ -z "${WINDOWS_COMPILER}" ]; then
${_printf} "%s" "-o $1.o"
else
${_printf} "%s" "'-o`${_cygpath} -w $1`'"
fi
}
output_file_option()
{
if [ -z "${WINDOWS_COMPILER}" ]; then
${_printf} "%s" "${EXE_OPT}$1"
else
${_printf} "%s" "'${EXE_OPT}`${_cygpath} -w $1`'"
fi
}
concat_path()
{
if [ $# != 0 ] ; then
${_printf} "%s" "$1"
shift
if [ -n "${CYGWIN_COMPILER}" ]; then
for elem in "$@"
do
${_printf} "%s%s" '\' "${elem}"
#This character ' is just to please font-lock-mode under (x)emacs
done
else
for elem in "$@"
do
${_printf} "/%s" "${elem}"
done
fi
fi
}
cgal_cxxflags()
{
${_printf} "%s" "${ADDITIONAL_CXXFLAGS} "
include_dir_option "`_where_is 'CGAL_INCL_DIR'`"
}
cgal_ldflags()
{
libpath_option "`_where_is 'CGAL_LIB_DIR'`/`full_ostype`"
rpath_directive 'CGAL_LIB_DIR'
if [ -n "${RUNTIME_LINKER_FLAG}" ]; then
${_printf} "%s" "/`full_ostype` "
fi
${_printf} "%s" "${ADDITIONAL_LDFLAGS} "
}
#---------------------------------------------------------
# flags for the math library
math_ldflags()
{
if [ -n "${MATH_LIB}" ] ; then
lib_option "${MATH_LIB}"
fi
}
#---------------------------------------------------------
# flags for the compiler tests
compiler_test_cxxflags()
{
${_printf} "%s" \
"${CUSTOM_CXXFLAGS} ${ADDITIONAL_CXXFLAGS} `include_dir_option ${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}` "
}
compiler_test_libpathflags()
{
return 0;
}
compiler_test_ldflags()
{
${_printf} "%s" "${CUSTOM_LDFLAGS} ${ADDITIONAL_LDFLAGS} `math_ldflags`"
}
#---------------------------------------------------------
# flags for GMP
gmp_cxxflags()
{
if [ -n "${GMP_SUPPORT}" -a "${GMP_INSTALLATION}" != 's' ]; then
tmp_dir_name=`_where_is 'GMP_INCL_DIR'`
${_printf} "%s" "`include_dir_option ${tmp_dir_name}` "
fi
}
gmp_libpathflags()
{
if [ -n "${SEPARATE_LIBPATH}" -a -n "${GMP_SUPPORT}" ]; then
if [ "${GMP_INSTALLATION}" != 's' ]; then
libpath_option "`_where_is 'GMP_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'GMP_LIB_DIR'` "
fi
fi
}
gmp_ldflags()
{
if [ -n "${GMP_SUPPORT}" ]; then
if [ -z "${SEPARATE_LIBPATH}" -a "${GMP_INSTALLATION}" != 's' ]; then
libpath_option "`_where_is 'GMP_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'GMP_LIB_DIR'` "
fi
# Note : gmpxx must come before gmp since it depends on it.
if [ -n "${GMPXX_SUPPORT}" ]; then
lib_option "gmpxx"
fi
lib_option "gmp"
fi
}
gmp_test_cxxflags()
{
compiler_test_cxxflags
gmp_cxxflags
}
gmp_test_libpathflags()
{
compiler_test_libpathflags
gmp_libpathflags
}
gmp_test_ldflags()
{
compiler_test_ldflags
gmp_ldflags
}
#---------------------------------------------------------
# flags for CORE
core_cxxflags()
{
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" != 'c' ]; then
tmp_dir_name=`_where_is 'CORE_INCL_DIR'`
${_printf} "%s" "`include_dir_option ${tmp_dir_name}` "
fi
}
core_libpathflags()
{
if [ -n "${SEPARATE_LIBPATH}" -a -n "${CORE_SUPPORT}" ]; then
if [ "${CORE_INSTALLATION}" != 'c' ]; then
libpath_option "`_where_is 'CORE_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'CORE_LIB_DIR'` "
fi
fi
}
core_ldflags()
{
if [ -n "${CORE_SUPPORT}" ]; then
if [ -z "${SEPARATE_LIBPATH}" -a "${CORE_INSTALLATION}" != 'c' ]; then
libpath_option "`_where_is 'CORE_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'CORE_LIB_DIR'` "
fi
lib_option "core++"
fi
}
core_test_cxxflags()
{
compiler_test_cxxflags
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" = 'c' ]; then
cgal_cxxflags
fi
core_cxxflags
}
core_test_libpathflags()
{
compiler_test_libpathflags
core_libpathflags
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" = 'c' ]; then
cgal_ldflags
fi
}
core_test_ldflags()
{
compiler_test_ldflags
core_ldflags
gmp_ldflags
}
#---------------------------------------------------------
# flags for QT
qt_cxxflags()
{
if [ -n "${QT_SUPPORT}" ]; then
if [ -z "${QT_ADVANCED_MODE}" ]; then
include_dir_option "`_where_is 'QT_DIR'`/include"
else
if [ -n "${NEED_EXTRA_QT_IDIR}" ]; then
include_dir_option "`_where_is 'QT_INCL_DIR'`"
fi
fi
${_printf} "%s" "${CGAL_QT_CXXFLAGS} "
fi
}
qt_libpathflags()
{
if [ -n "${SEPARATE_LIBPATH}" -a -n "${QT_SUPPORT}" ]; then
if [ -z "${QT_ADVANCED_MODE}" ]; then
libpath_option "`_where_is 'QT_DIR'`/lib "
${_printf} "%s" "`rpath_directive 'QT_LIB_DIR'` "
else
if [ -n "${NEED_EXTRA_QT_LDIR}" ]; then
libpath_option "`_where_is 'QT_LIB_DIR'` "
${_printf} "%s" "`rpath_directive 'QT_LIB_DIR'` "
fi
fi
fi
}
lib_qt()
{
if [ "${QT_T_SUPPORT}" = 'n' ]; then
lib_option "qt"
else
lib_option "qt-mt"
fi
}
qt_ldflags()
{
if [ -n "${QT_SUPPORT}" ]; then
if [ -z "${SEPARATE_LIBPATH}" ]; then
if [ -z "${QT_ADVANCED_MODE}" ]; then
libpath_option "`_where_is 'QT_DIR'`/lib "
${_printf} "%s" "`rpath_directive 'QT_LIB_DIR'` "
else
if [ -n "${NEED_EXTRA_QT_LDIR}" ]; then
libpath_option "`_where_is 'QT_LIB_DIR'` "
${_printf} "%s" "`rpath_directive 'QT_LIB_DIR'` "
fi
fi
fi
if [ -z "${WINDOWS_COMPILER}" ]; then
lib_qt
else
lib_option "qtmain"
lib_option "${QT_SECOND_LIB}"
lib_option "imm32"
lib_option "wsock32"
lib_option "gdi32"
lib_option "user32"
lib_option "ole32"
lib_option "winspool"
lib_option "comdlg32"
lib_option "advapi32"
lib_option "shell32"
lib_option "ws2_32"
fi
fi
}
qt_test_cxxflags()
{
${_printf} "%s" "`compiler_test_cxxflags` "
qt_cxxflags
}
qt_test_ldflags()
{
${_printf} "%s" "`compiler_test_ldflags` "
qt_ldflags
}
#---------------------------------------------------------
# flags for LEDA
leda_cxxflags()
{
if [ -n "${LEDA_SUPPORT}" -a -n "${LEDA_INCL_DIR}" ]; then
pathname1=`_where_is 'LEDA_INCL_DIR'`
pathname2=`filename_for_compiler ${pathname1}`
${_printf} "%s" "`include_dir_option ${pathname2}` "
fi
}
leda_libpathflags()
{
if [ -n "${SEPARATE_LIBPATH}" -a -n "${LEDA_SUPPORT}" ]; then
if [ -n "${LEDA_LIB_DIR}" ]; then
libpath_option "`_where_is 'LEDA_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'LEDA_LIB_DIR'` "
fi
fi
}
leda_ldflags()
{
if [ -n "${LEDA_SUPPORT}" ]; then
if [ -z "${SEPARATE_LIBPATH}" -a -n "${LEDA_LIB_DIR}" ]; then
# ${_printf} "%s" "${START_LD_OPT}"
libpath_option "`_where_is 'LEDA_LIB_DIR'`"
${_printf} "%s" "`rpath_directive 'LEDA_LIB_DIR'` "
fi
leda_lib_option "P"
leda_lib_option "G"
leda_lib_option "L"
fi
}
leda_test_cxxflags()
{
${_printf} "%s" "`compiler_test_cxxflags` "
leda_cxxflags
}
leda_test_ldflags()
{
${_printf} "%s" "`compiler_test_ldflags` "
leda_ldflags
math_ldflags
}
#---------------------------------------------------------
# all flags
# print cxxflags for current setting
compiler_flags()
{
# core must be first, otherwise it would be impossible to use a core
# installation different from the CGAL one (CORE is in CGAL_INCL_DIR)
${_printf} "%s" "${CUSTOM_CXXFLAGS} `core_cxxflags``cgal_cxxflags``leda_cxxflags``gmp_cxxflags``qt_cxxflags`"
}
# print ldflags for current setting (do not link with cgal lib,
# used for test before lib is compiled)
# NOTE : the order matters, if A depends on B, then B must come after A.
linker_flags_no_cgal_lib()
{
${_printf} "%s" "${CUSTOM_LDFLAGS} `cgal_ldflags``leda_ldflags``qt_ldflags``core_ldflags``gmp_ldflags``math_ldflags`"
}
# print compiler description/version of compiler $1 (executable)
# in the format DESCRIPTION@VERSION
get_compiler_description()
{
${_cat} <<EOF4 >${TMP_CXX_FILE}.C
// We need the following lines, since MIPSPRO only knows <iostream>,
// if it is called with -LANG:std (as of Rel 7.3)
// and I do not want to check for this before compiling ...
#if defined(__sgi) && defined(_COMPILER_VERSION) && !defined(_STANDARD_C_PLUS_PLUS)
#include <iostream.h>
#define CGAL_STDCOUT cout
#define CGAL_STDENDL endl
#else
#include <iostream>
#define CGAL_STDCOUT std::cout
#define CGAL_STDENDL std::endl
#endif
void output_first_ciff_separate(int x, int base)
{
int j = 1;
while (x / (base * j) >= 1) j *= base;
CGAL_STDCOUT << x/j << "." << x - j * (x/j);
}
int main()
{
#if defined(__INTEL_COMPILER)
// Intel Compiler
// it has to be checked before the g++ and VC++ compilers since it also
// defines __GNUC__ or _MSC_VER
int intel_version_major = __INTEL_COMPILER / 100;
int intel_version_minor = (__INTEL_COMPILER - intel_version_major * 100) / 10;
CGAL_STDCOUT << "Intel@" << intel_version_major << "." << intel_version_minor;
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__GNUC__)
// GNU cc
CGAL_STDCOUT << "GNU@" << __GNUC__ << "." << __GNUC_MINOR__;
# ifdef __GNUC_PATCHLEVEL__
CGAL_STDCOUT << "." << __GNUC_PATCHLEVEL__;
# endif
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__sgi) && defined(_COMPILER_VERSION)
// SGI mipspro
CGAL_STDCOUT << "MIPSPRO";
# if (_MIPS_SIM == _OABI32)
CGAL_STDCOUT << " (o32)";
# elif (_MIPS_SIM == _NABI32)
CGAL_STDCOUT << " (n32)";
# elif (_MIPS_SIM == _ABI64)
CGAL_STDCOUT << " (64)";
# endif // _MIPS_SIM
CGAL_STDCOUT << "@";
output_first_ciff_separate(_COMPILER_VERSION, 10);
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__sun) && defined(__SUNPRO_CC)
// SUN workshop
CGAL_STDCOUT << "SUNPRO";
# ifdef __sparcv9
CGAL_STDCOUT << " (v9)";
# endif // __sparcv9
CGAL_STDCOUT << "@" << std::hex;
output_first_ciff_separate(__SUNPRO_CC, 16);
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__BORLANDC__)
// Borland
CGAL_STDCOUT << "Borland@" << std::hex;
output_first_ciff_separate(__BORLANDC__, 16);
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__MWERKS__)
// Metrowerks
CGAL_STDCOUT << "Metrowerks@" << std::hex;
# if (__MWERKS__ == 1)
CGAL_STDCOUT << "precw7" << CGAL_STDENDL;
# else
output_first_ciff_separate(__MWERKS__, 16);
CGAL_STDCOUT << CGAL_STDENDL;
# endif // (__MWERKS__ == 1)
#elif defined(__KCC)
// KAI CC
CGAL_STDCOUT << "KAI CC@";
output_first_ciff_separate(__KCC_VERSION / 100, 10);
if (__KCC_VERSION % 100 != 0)
CGAL_STDCOUT << char(__KCC_VERSION % 100 + int('a') - 1);
CGAL_STDCOUT << CGAL_STDENDL;
#elif defined(__PGI)
// Portland Group Compiler
// There does not seem to be a way to find the compiler version from
// within the translation unit. So we cheat by passing it as a macro
// defined on the command line (based on "pgCC -V").
CGAL_STDCOUT << "PGCC@" << CGAL_PGCC_VERSION << CGAL_STDENDL;
#elif defined(_MSC_VER)
// Microsoft Visual C++
CGAL_STDCOUT << "VC++@" << _MSC_VER << CGAL_STDENDL;
#else
// we do not know this compiler --> add specs if supported
CGAL_STDCOUT << "unknown" << CGAL_STDENDL;
#endif
return 0;
}
EOF4
# set flags
EXE_OPT="-o "
case $1 in
*bcc32.exe*|*BCC32*) EXE_OPT="-P -e";;
*CL.*-1300*|*cl.*-1300*|*CL.*-1400*|*cl.*-1400*) EXE_OPT="-TP -GR -nologo -Fe";;
*ICL.*|*icl.*) EXE_OPT="-TP -GR -nologo -Fe";;
*CL.*|*cl.*) EXE_OPT="-TP -GR -nologo -Fe";;
*mwcc.exe*|*MWCC*) EXE_OPT="-gccincludes -lang c++ -msgstyle gcc -o ";;
*pgCC*) PGCC_VERSION=`$1 -V | grep pgCC | cut -d' ' -f2`
EXE_OPT="-DCGAL_PGCC_VERSION='\"$PGCC_VERSION\"' -o ";;
esac
_flags="${CUSTOM_CXXFLAGS} ${CUSTOM_LDFLAGS} ${EXE_OPT}${TMP_CXX_FILE} ${TMP_CXX_FILE}.C"
# compile
${_printf} "%s\n%s\n" \
"Compiler call:" "--------------" >${TMP_LOGFILE}
${_printf} "%s" \
"$1 ${_flags}" >>${TMP_LOGFILE}
${_printf} "\n\n%s\n" \
"Got the following error messages:" >>${TMP_LOGFILE}
${_printf} "%s\n" \
"---------------------------------" >>${TMP_LOGFILE}
eval "`quote $1` ${_flags} >>${TMP_LOGFILE} 2>&1"
if [ $? = 0 ]; then
log_print "Compiler version test compiled."
${_printf} "\n\n%s\n" "Execution:" >>${TMP_LOGFILE}
${_printf} "%s\n" \
"---------------------------------" >>${TMP_LOGFILE}
${TMP_CXX_FILE} >>${TMP_LOGFILE} 2>&1
if [ $? = 0 ]; then
_tmp3=`eval "${TMP_CXX_FILE} 2>&1"`
cleanup_after_compile
cleanup_after_link_run
return 0
elif [ -n "${INSTALL_INTERACTIVE}" ]; then
log_print "ERROR: Compiler version test execution failed."
write_buffer "\n"
print_filled_line
print_empty_line
print_headline " Compiler version test 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" " execution failed."
${_cat} ${TMP_LOGFILE}
${_printf} "%s\n\n" \
"--------------------------------------------------------"
fi
cleanup_after_compile
cleanup_after_link_run
return 1
else
if [ -n "${INSTALL_INTERACTIVE}" ]; then
log_print "ERROR: Compiler version test did NOT compile."
write_buffer "\n"
print_filled_line
print_empty_line
print_headline "Compiler version test 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
cleanup_after_compile
cleanup_after_link_run
return 1
fi
}
# $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 custom os tag
custom_ostype_tag()
{
# the tag should not start with underscore
# (consistent treatment of old _LEDA suffix)
${_printf} "%s\n" "${*:-${COMPILER}}" | \
${_awk} 'BEGIN {FS="@"} {printf "%s",$6}' | \
${_sed} 's/^_//'
}
# reassemble compiler string, i.e. adjust to CUSTOM_OSTYPE_TAG
reassemble_compiler()
{
COMPILER="`compiler_basename`@`compiler_description`@`c_compiler_bin`@`compiler_bin`@`compiler_version`@${CUSTOM_OSTYPE_TAG}"
}
# $1 is a compiler string
# print extended compiler description
extended_compiler_description()
{
${_printf} "%s\n" "${*:-${COMPILER}}" | \
${_awk} 'BEGIN {FS="@"} {printf "%s %s",$2,$5}'
${_printf} "\n"
}
# 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
get_compiler_description "$2"
COMPILER="$2@`compiler_basename \"${_tmp3}\"`@${_tmp2}@${_tmp1}@`compiler_description \"${_tmp3}\"`@"
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
case ${SYST} in
*CYGWIN*) _check_for_sysutil cygpath y;;
esac
_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
CUSTOM_OSTYPE_TAG=''
_search_compiler gcc g++ ''
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
;;
*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
;;
*IRIX*|*SunOS*)
_search_compiler cc CC ''
;;
*CYGWIN*)
_search_compiler CL.EXE CL.EXE ''
_search_compiler ICL.EXE ICL.EXE ''
_search_compiler bcc32.exe bcc32.exe ''
_search_compiler mwcc.exe mwcc.exe ''
;;
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;s#/#-#g"`
if [ -n "${_tmp1}" ]; then
${_printf} "%s" "${_tmp1}"
fi
${_printf} "%s" "@"
get_compiler_description "${_args}"
compiler_basename "${_tmp3}"
${_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}@"
compiler_description "${_tmp3}"
${_printf} "%s" "@${CUSTOM_OSTYPE_TAG}"
}
# ---------------------------------------------------------------------
# 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=`${_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 | ${_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
elif _check_for_sysutil expr n; then
_EXPR=_expr_expr
elif _check_for_sysutil expr n; 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='
'
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:
remove_special_chars()
{
_read
echo "$KEY" | ${_tr} -d '\\!@#$%^&*()_|~";?<>{}[]\`/ ' | ${_tr} -d "'"
}
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}\"\`"`
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 "${_LEFTSPACE}**"
string_n_print " " $_result
write_buffer "$1"
lb=$_result
eval "$_EXPR $_MENU_WIDTH \* 10"
eval "$_EXPR $_result - $l"
eval "$_EXPR $_result - $lb"
string_n_print " " $_result
write_buffer "**\n"
}
# print a headline with text $1
print_headline()
{
print_center_line "$1"
length "`echo "$1"`"
l=$?
eval "$_EXPR $_MENU_WIDTH \* 10"
eval "$_EXPR $_result - $l"
eval "$_EXPR $_result / 2"
write_buffer "${_LEFTSPACE}**"
string_n_print " " $_result
string_n_print "=" $l
lb=$_result
eval "$_EXPR $_MENU_WIDTH \* 10"
eval "$_EXPR $_result - $l"
eval "$_EXPR $_result - $lb"
string_n_print " " $_result
write_buffer "**\n"
print_empty_line
}
# wait until enter is pressed
wait_for_enter()
{
if [ -n "${INSTALL_INTERACTIVE}" ]; then
print_center_line "Please press <ENTER> 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()
{
# save buffer
_tmp3=${_BUF}
_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})}'"
_BUF=${_tmp3}
}
# set some variables for output
set_terminal_variables()
{
if _check_for_sysutil tput n; then
${_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
else
eval "${_EXPR} ${_MENU_WIDTH} \* 10"
length "${_LEFTSPACE}"
eval "${_EXPR} ${_result} + $?"
# for two-star('**') border
eval "${_EXPR} ${_result} + 4"
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_GMPXX_SUPPORT()
{
if [ "${GMPXX_SUPPORT}" != "" -a "${GMPXX_SUPPORT}" != "_GMPXX" ]; then
$1 "WARNING: GMPXX_SUPPORT is not set correctly."
return 0
fi
return 1
}
check_GMP_INSTALLATION()
{
if [ -n "${GMP_INSTALLATION}" ]; then
# for backwards-compatibility, we used to support GMP installation
# within the CGAL tree
if [ "${GMP_INSTALLATION}" = 'c' -o "${GMP_INSTALLATION}" = 'z' ]; then
GMP_INSTALLATION='e'
fi
if [ "${GMP_INSTALLATION}" != 'x' -a \
"${GMP_INSTALLATION}" != 'e' -a \
"${GMP_INSTALLATION}" != 's' ]; then
$1 "WARNING: GMP_INSTALLATION should be \"e\", \"x\", \"s\", or empty."
return 0
fi
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
if [ -n "${GMPXX_SUPPORT}" ]; then
if [ ! -r ${GMP_INCL_DIR}/gmpxx.h ]; then
$1 "WARNING: GMP_INCL_DIR should contain"
$1 " gmpxx.h."
else
return 1
fi
fi
fi
return 0
}
check_GMP_LIB_DIR()
{
if [ -n "${GMP_LIB_DIR}" ]; then
if [ ! -r ${GMP_LIB_DIR}/${GMP_LIBNAME} -a \
! -r ${GMP_LIB_DIR}/libgmp${SHARED_LIB_EXT} ]; then
$1 "WARNING: GMP_LIB_DIR should contain"
$1 " libgmp.a, libgmp${SHARED_LIB_EXT} or gmp.lib."
else
return 1
fi
if [ -n "${GMPXX_SUPPORT}" ]; then
if [ ! -r ${GMP_LIB_DIR}/${GMPXX_LIBNAME} -a \
! -r ${GMP_LIB_DIR}/libgmpxx${SHARED_LIB_EXT} ]; then
$1 "WARNING: GMP_LIB_DIR should contain"
$1 " libgmpxx.a, libgmpxx${SHARED_LIB_EXT} or gmpxx.lib."
else
return 1
fi
fi
fi
return 0
}
check_CORE_SUPPORT()
{
if [ "${CORE_SUPPORT}" != "" -a "${CORE_SUPPORT}" != "_CORE" ]; then
$1 "WARNING: CORE_SUPPORT is not set correctly."
return 0
elif [ -n "${CORE_SUPPORT}" -a -z "${GMP_SUPPORT}" ]; then
$1 "WARNING: CORE_SUPPORT requires GMP_SUPPORT."
$1 " ==> Also set GMP_SUPPORT."
GMP_SUPPORT='_GMP'
fi
return 1
}
check_CORE_INSTALLATION()
{
if [ -n "${CORE_INSTALLATION}" -a "${CORE_INSTALLATION}" != 'z' -a \
"${CORE_INSTALLATION}" != 'c' -a "${CORE_INSTALLATION}" != 'e' ]; then
$1 "WARNING: CORE_INSTALLATION should be \"e\", \"c\", \"z\", or empty."
return 0
fi
return 1
}
check_CORE_INCL_DIR()
{
if [ -n "${CORE_INCL_DIR}" ]; then
if [ ! -r ${CORE_INCL_DIR}/CORE/CORE.h ]; then
$1 "WARNING: CORE_INCL_DIR should contain a file CORE/CORE.h."
else
return 1
fi
fi
return 0
}
check_CORE_LIB_DIR()
{
if [ -n "${CORE_LIB_DIR}" ]; then
if [ ! -r ${CORE_LIB_DIR}/${CORE_LIBNAME} ]; then
$1 "WARNING: CORE_LIB_DIR should contain "
$1 " libcore++.a, libcore++.lib, or core++.lib."
else
return 1
fi
fi
return 0
}
check_QT_SUPPORT()
{
if [ "${QT_SUPPORT}" != "" -a "${QT_SUPPORT}" != "_QT" ]; then
$1 "WARNING: Qt_SUPPORT is not set correctly."
return 0
fi
return 1
}
check_QT_T_SUPPORT()
{
return 1
}
check_QT_DLL()
{
return 1
}
check_QT_SECOND_LIB()
{
return 1
}
check_NEED_EXTRA_QT_IDIR()
{
if [ -n "${NEED_EXTRA_QT_IDIR}" -a \
"${NEED_EXTRA_QT_IDIR}" != 'n' -a \
"${NEED_EXTRA_QT_IDIR}" != 'y' -a \
"${NEED_EXTRA_QT_IDIR}" != 'x' ]; then
$1 "WARNING: NEED_EXTRA_QT_IDIR should be \"n\", \"x\", \"y\" or empty."
return 0
fi
return 1
}
check_NEED_EXTRA_QT_LDIR()
{
if [ -n "${NEED_EXTRA_QT_LDIR}" -a \
"${NEED_EXTRA_QT_LDIR}" != 'n' -a \
"${NEED_EXTRA_QT_LDIR}" != 'y' -a \
"${NEED_EXTRA_QT_LDIR}" != 'x' ]; then
$1 "WARNING: NEED_EXTRA_QT_LDIR should be \"n\", \"x\", \"y\" or empty."
return 0
fi
return 1
}
check_NEED_EXTRA_QTMOC()
{
if [ -n "${NEED_EXTRA_QTMOC}" -a \
"${NEED_EXTRA_QTMOC}" != 'n' -a \
"${NEED_EXTRA_QTMOC}" != 'y' -a \
"${NEED_EXTRA_QTMOC}" != 'x' ]; then
$1 "WARNING: NEED_EXTRA_QTMOC should be \"n\", \"x\", \"y\" or empty."
return 0
fi
return 1
}
check_NEED_EXTRA_QTDIR()
{
if [ -n "${NEED_EXTRA_QTDIR}" -a \
"${NEED_EXTRA_QTDIR}" != 'n' -a \
"${NEED_EXTRA_QTDIR}" != 'y' -a \
"${NEED_EXTRA_QTDIR}" != 'x' ]; then
$1 "WARNING: NEED_EXTRA_QTDIR should be \"n\", \"x\", \"y\" or empty."
return 0
fi
return 1
}
check_QT_DIR()
{
if [ -n "${QT_DIR}" ]; then
if [ -d "${QT_DIR}" -a -d "${QT_DIR}/bin" -a \
-d "${QT_DIR}/include" -a \
-d "${QT_DIR}/lib" -a -x "${QT_DIR}/bin/moc${EXE_EXT}" -a \
-r ${QT_DIR}/include/qaction.h ]; then
return 1
else
$1 "WARNING: QT_DIR should contain"
$1 " bin/moc${EXE_EXT}, include/qaction.h lib/."
fi
fi
return 0
}
check_QT_INCL_DIR()
{
if [ -n "${QT_INCL_DIR}" ]; then
if [ -r ${QT_INCL_DIR}/qaction.h ]; then
return 1
else
$1 "WARNING: QT_INCL_DIR should contain qaction.h."
fi
fi
return 0
}
check_QT_LIB_DIR()
{
if [ -n "${QT_LIB_DIR}" ]; then
if [ ! -r ${QT_LIB_DIR}/libqt.${LIB_SUFFIX} -a \
! -r ${QT_LIB_DIR}/libqt${SHARED_LIB_EXT} -a \
! -r ${QT_LIB_DIR}/libqt-mt.${LIB_SUFFIX} -a \
! -r ${QT_LIB_DIR}/libqt-mt${SHARED_LIB_EXT} ]; then
$1 "WARNING: QT_LIB_DIR should contain libqt.${LIB_SUFFIX}, libqt${SHARED_LIB_EXT}, libqt-mt.${LIB_SUFFIX} or libqt-mt${SHARED_LIB_EXT}."
else
return 1
fi
fi
return 0
}
check_QT_MOC()
{
if [ -n "${QT_MOC}" ]; then
if [ -x "${QT_MOC}" ]; then
return 1
else
$1 "WARNING: QT_MOC sould be executable."
fi
fi
return 0
}
check_QT_ADVANCED_MODE()
{
if [ -n "${QT_ADVANCED_MODE}" -a \
"${QT_ADVANCED_MODE}" != 'y' ]; then
$1 "WARNING: QT_ADVANCED_MODE sould be \"y\" or empty."
return 0
fi
return 1
}
# user's business
check_CUSTOM_CXXFLAGS()
{
return 1
}
# user's business
check_CUSTOM_LDFLAGS()
{
return 1
}
# nothing to check here
check_LONG_NAME_PROBLEM()
{
return 1
}
# nothing to check here
check_ENABLE_SHARED()
{
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${LIB_SUFFIX} -a \
! -r $LEDA_LIB_DIR/libL${SHARED_LIB_EXT} ]; then
$1 "WARNING: LEDA_LIB_DIR should contain libL.${LIB_SUFFIX} or libL${SHARED_LIB_EXT}."
else
return 1
fi
fi
return 0
}
check_UPGRADE_FROM()
{
if [ ! -d "${UPGRADE_FROM}/include/CGAL" ]; then
$1 "WARNING: UPGRADE_FROM should contain a subdirectory \"include/CGAL\"."
elif [ ! -d "${UPGRADE_FROM}/lib" ]; then
$1 "WARNING: UPGRADE_FROM should contain a subdirectory \"lib\"."
else
return 1
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_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
}
check_CUSTOM_OSTYPE_TAG()
{
CUSTOM_OSTYPE_TAG=`echo ${CUSTOM_OSTYPE_TAG} | remove_special_chars`
return 1
}
check_GMP_VERSION()
{
return 1
}
check_GMPXX_VERSION()
{
return 1
}
check_LEDA_VERSION()
{
return 1
}
check_CORE_VERSION()
{
return 1
}
check_QT_VERSION()
{
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<NF-1; ++i) printf "%s ",$(i); \
printf "%s",$(NF-1)}'`
log_print "got ${1} from config/`${_basename} ${2}`."
log_print "set to <\${_tmp2}>."
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}${OBJ_EXT}
# remove log file
${_rm} -f ${TMP_LOGFILE}
# remove moc file
${_rm} -f ${TMP_CXX_FILE}.moc
}
# 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 '`filename_for_compiler ${TMP_CXX_FILE}.C`' `to_object_file_option ${TMP_CXX_FILE}`"
_flags="${_flags} -c '`filename_for_compiler ${TMP_CXX_FILE}.C`'"
# 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 "`quote \`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 non-empty, use it as libpath flags
# if $3 is empty, use standard linker flags
# if $3 is non-empty, use it as linker flags
# if $4 is non-zero, inform about eventually occurring problems
# $5 is message to print ("no" or "unfortunately") in case of failure.
# The program output is scanned for a line starting with the string
# version=
# and whatever comes after this is assigned to $6.
_link_run_test()
{
# set flags
if [ -z "${3}" ]; then
_flags="`linker_flags_no_cgal_lib`"
else
_flags="${3}"
fi
case ${COMPILER} in
*CL.*|*cl.*|*ICL.*|*icl.*) _flags="${2} `object_file_name ${TMP_CXX_FILE}` ${_flags}";;
*) _flags="${2}`output_file_option ${TMP_CXX_FILE}` `object_file_name ${TMP_CXX_FILE}` ${_flags}";;
esac
# link
_link="`compiler_bin`"
case ${COMPILER} in
*CL.*|*cl.*) _link="link";;
esac
${_printf} "%s\n%s\n" "Linker call:" "--------------" >${TMP_LOGFILE}
${_printf} "%s\n\n" "${_link} ${_flags}" >>${TMP_LOGFILE}
${_printf} "%s\n" "Got the following error messages:" >>${TMP_LOGFILE}
${_printf} "%s\n" "---------------------------------" >>${TMP_LOGFILE}
eval "`quote ${_link}` ${_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}
_tmp=`eval "${TMP_CXX_FILE} 2>&1 | ${_tee} -a ${TMP_LOGFILE} | ${_awk} 'BEGIN{FS=\"=\"} /^version=/{print \\$2}' | remove_special_chars"`
j=$?
if [ $j = 0 ]; then
log_print "$1 test execution succeeded."
if [ -n "${6}" ]; then
if [ -n "${_tmp}" ]; then
eval "$6=\"${_tmp}\""
else
eval "$6=0"
fi
fi
else
if [ -n "${4}" ]; then
log_print "ERROR: $1 test execution FAILED."
else
log_print "remark: $1 test execution failed."
fi
fi
else
if [ -n "${4}" ]; 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 "${4}" ]; 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" " ${5:-no.}"
fi
cleanup_after_link_run
return 1
fi
}
# ---------------------------------------------------------------------
# LEDA TEST:
# test if LEDA setting works (return 0, iff ok)
# ($2 nonzero indicates verbosity)
test_LEDA()
{
if [ -n "${LEDA_SUPPORT}" ]; then
${_cp} ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_LEDA.C ${TMP_CXX_FILE}.C
if _compile_test LEDA "`leda_test_cxxflags`" $2 && \
_link_run_test LEDA \
"`leda_libpathflags`" "`leda_test_ldflags`" \
$2 no LEDA_VERSION
then
LEDA_TEST_PASSED='y'
return 0
else
LEDA_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# ---------------------------------------------------------------------
# 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
${_cp} ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_GMP.C ${TMP_CXX_FILE}.C
if _compile_test "$1" "`gmp_test_cxxflags`" "$2" && \
_link_run_test "$1" \
"`gmp_test_libpathflags`" "`gmp_test_ldflags`" \
"$2" no GMP_VERSION
then
GMP_TEST_PASSED='y'
return 0
else
GMP_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# test GMP's built-in C++ interface.
test_GMPXX()
{
if [ -n "${GMPXX_SUPPORT}" ]; then
${_cp} ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_GMPXX.C ${TMP_CXX_FILE}.C
if _compile_test "$1" "`gmp_test_cxxflags`" "$2" && \
_link_run_test "$1" \
"`gmp_test_libpathflags`" "`gmp_test_ldflags`" \
"$2" no GMPXX_VERSION
then
GMPXX_TEST_PASSED='y'
return 0
else
GMPXX_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# ---------------------------------------------------------------------
# CORE TEST:
# core test program (return 0, iff it works)
# ($2 nonzero indicates verbosity)
test_CORE()
{
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" != 'c' ]; then
${_cp} ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_CORE.C ${TMP_CXX_FILE}.C
if _compile_test "CORE" "`core_test_cxxflags`" "$2" && \
_link_run_test "CORE" \
"`core_test_libpathflags`" "`core_test_ldflags`" \
"$2" no CORE_VERSION
then
CORE_TEST_PASSED='y'
return 0
else
CORE_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# ---------------------------------------------------------------------
# QT TEST:
qt_dir_has_changed()
{
# if [ -n "${WINDOWS_COMPILER}" ]; then
# QT_INCL_DIR="${QT_DIR}\\include"
# QT_LIB_DIR="${QT_DIR}\\lib"
# QT_MOC="${QT_DIR}\\bin\\moc${EXE_EXT}"
# else
QT_INCL_DIR="${QT_DIR}/include"
QT_LIB_DIR="${QT_DIR}/lib"
QT_MOC="${QT_DIR}/bin/moc${EXE_EXT}"
# fi
# if [ -z "${NEED_EXTRA_QTDIR}" ]; then
# NEED_EXTRA_QTDIR='x'
# fi
if [ -z "${NEED_EXTRA_QT_IDIR}" ]; then
NEED_EXTRA_QT_IDIR='x'
fi
if [ -z "${NEED_EXTRA_QT_LDIR}" ]; then
NEED_EXTRA_QT_LDIR='x'
fi
if [ -z "${NEED_EXTRA_QTMOC}" ]; then
NEED_EXTRA_QTMOC='x'
fi
}
# test if $QTDIR is a valid Qt directory
# and sets NEED_EXTRA_QTDIR correspondingly
# ($1 nonzero indicates verbosity)
# [ tests if $QTDIR/{include,lib,bin} are directories and checks if
# $QTDIR/bin/moc exists and is executable ]
test_for_qt_dir()
{
${_printf} "%s" "${_LEFTSPACE}Testing for \$QTDIR ..."
if [ -d "${QTDIR}" -a -d "${QTDIR}/bin" -a -d "${QTDIR}/include" -a \
-d "${QTDIR}/lib" -a -x "${QTDIR}/bin/moc${EXE_EXT}" -a \
-r "${QTDIR}/include/qaction.h" ]; then
log_print 'remark: $QTDIR is a valid Qt directory.'
QT_DIR="$QTDIR"
NEED_EXTRA_QTDIR=''
qt_dir_has_changed
${_printf} "%s\n" " ok."
return 0
else
if [ -n "$1" ];then
if [ -n "${INSTALL_INTERACTIVE}" ]; then
log_print 'ERROR: $QTDIR is not a valid Qt directory.'
else
${_printf} "%s\n\n" 'ERROR: $QTDIR is not a valid Qt directory.'
fi
else
log_print 'remark: $QTDIR is not a valid Qt directory.'
fi
${_printf} "%s\n" " no."
NEED_EXTRA_QTDIR='y'
return 1
fi
}
# test if Qt header files are in some sys include dir
# and sets NEED_EXTRA_QT_IDIR correspondingly
# ($1 nonzero indicates verbosity)
# [ checks for the existence of <qaction.h>, since this
# is a new file of Qt 2.2 ]
test_for_qt_incl_in_sys_incl()
{
${_printf} "%s\n" "
#include <qaction.h>
int main() { return 0; }" > ${TMP_CXX_FILE}.C
if _compile_test "Qt sysincl" "${CUSTOM_CXXFLAGS} " "$1"; then
cleanup_after_compile
${_printf} "%s\n" " ok."
NEED_EXTRA_QT_IDIR=''
return 0
fi
cleanup_after_compile
NEED_EXTRA_QT_IDIR='y'
return 1
}
# test if Qt libs are in some sys lib dir
# and sets NEED_EXTRA_QT_LDIR correspondingly
# ($1 nonzero indicates verbosity)
test_for_qt_lib_in_sys_lib()
{
${_printf} "%s\n" "int main() { return 0; }" > ${TMP_CXX_FILE}.C
if _compile_test "Qt syslibs" "${CUSTOM_CXXFLAGS} " "$1";
then
if _link_run_test "Qt syslibs" "" \
"${CUSTOM_LDFLAGS} `lib_qt`" "$1"; then
NEED_EXTRA_QT_LDIR=''
return 0
fi
fi
NEED_EXTRA_QT_LDIR='y'
return 1
}
# test if Qt moc is in path
# and set NEED_EXTRA_QTMOC correspondingly
# ($1 nonzero indicates verbosity)
test_for_qt_moc_in_path()
{
${_printf} "%s" "${_LEFTSPACE}Testing for moc${EXE_EXT}..."
_tmp="`${_which} moc${EXE_EXT}`"
if [ -x "${_tmp}" ]; then
log_print "remark: moc${EXE_EXT} is in path directories."
NEED_EXTRA_QTMOC=''
QT_MOC="moc"
${_printf} "%s\n" " ok."
return 0
else
if [ -n "$1" ];then
log_print "ERROR: moc${EXE_EXT} is not in path directories."
write_buffer "\n"
wait_for_enter
else
log_print "remark: moc${EXE_EXT} is in path directories."
fi
${_printf} "%s\n" " no."
NEED_EXTRA_QTMOC='y'
return 1
fi
}
# test if Qt Meta Object Compiler setting works (return 0, iff ok)
# ($1 nonzero indicates verbosity)
test_QT_MOC()
{
if [ -n "${QT_SUPPORT}" ]; then
${_printf} "%s\n" '
#include <qobject.h>
class Foo : public QObject
{
Q_OBJECT
public:
Foo() {};
int value() const { return val; }
public slots:
void setValue( int );
signals:
void valueChanged( int );
private:
int val;
};
void Foo::setValue( int v )
{
if ( v != val ) {
val = v;
emit valueChanged(v);
}
}
int main( int argc, char **argv )
{
Foo a, b;
a.connect(&a, SIGNAL(valueChanged(int)), &b, SLOT(setValue(int)));
b.setValue( 11 );
a.setValue( 79 );
if (b.value()==79)
return 0;
return 1;
}' > ${TMP_CXX_FILE}.C
${_printf} "%s\n" "
#include \"${TMP_CXX_FILE}.moc\"
" >> ${TMP_CXX_FILE}.C
${_printf} "%s\n%s\n" \
"MOC call:" "--------------" >${TMP_LOGFILE}
${_printf} "%s" \
"`posix_path ${QT_MOC}` -o ${TMP_CXX_FILE}.moc ${TMP_CXX_FILE}.C" \
>>${TMP_LOGFILE}
${_printf} "\n\n%s\n" \
"Got the following error messages:" >>${TMP_LOGFILE}
${_printf} "%s\n" \
"---------------------------------" >>${TMP_LOGFILE}
`posix_path ${QT_MOC}` -o ${TMP_CXX_FILE}.moc ${TMP_CXX_FILE}.C \
>>${TMP_LOGFILE} 2>&1
if [ $? = 0 ]; then
log_print "Qt MOC test has passed \$QT_MOC execution."
if _compile_test "Qt MOC" "`qt_test_cxxflags`" $1 && \
_link_run_test "Qt MOC" \
"`qt_libpathflags`" "`qt_test_ldflags`" $1
then
QT_MOC_TEST_PASSED='y'
return 0
else
QT_MOC_TEST_PASSED=''
return 1
fi
else
if [ -n "$1" ]; then
if [ -n "${INSTALL_INTERACTIVE}" ]; then
log_print "ERROR: Qt MOC test did not passed \$QT_MOC execution."
write_buffer "\n"
print_filled_line
print_empty_line
print_headline "Compilation failed because of \$QT_MOC."
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: Qt MOC test did not passed \$QT_MOC execution."
${_printf} "%s" "${_LEFTSPACE}Testing for Qt MOC ... no."
fi
QT_MOC_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# test if Qt setting works (return 0, iff ok)
# ($2 nonzero indicates verbosity)
test_QT()
{
if [ -n "${QT_SUPPORT}" ]; then
${_cp} ${CGAL_TEST_CONF_DIR}/CGAL_CFG_NO_QT.C ${TMP_CXX_FILE}.C
if _compile_test Qt "`qt_test_cxxflags`" $2 && \
_link_run_test Qt \
"`qt_libpathflags`" "`qt_test_ldflags`" $2 no QT_VERSION
then
QT_TEST_PASSED='y'
return 0
else
QT_TEST_PASSED=''
return 1
fi
else
return 0
fi
}
# set variable CGAL_OS_COMPILER according to the current
# compiler settings
set_ostype()
{
CGAL_OS_COMPILER="${SYST}_`compiler_basename`"
if [ -n "`compiler_version`" ]; then
CGAL_OS_COMPILER="${CGAL_OS_COMPILER}-`compiler_version`"
fi
if [ -n "${CUSTOM_OSTYPE_TAG}" ]; then
CGAL_OS_COMPILER="${CGAL_OS_COMPILER}_${CUSTOM_OSTYPE_TAG}"
fi
}
# return the full os/compiler string
# (i.e. including LEDA extension)
full_ostype()
{
${_printf} "%s" "${CGAL_OS_COMPILER}"
}
# 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`"
_set_tmp_to_not_or_not "${GMP_SUPPORT}"
${1} "GMP:\t\t${_tmp}supported"
_set_tmp_to_not_or_not "${GMPXX_SUPPORT}"
${1} "GMPXX:\t${_tmp}supported"
_set_tmp_to_not_or_not "${CORE_SUPPORT}"
${1} "CORE:\t\t${_tmp}supported"
_set_tmp_to_not_or_not "${LEDA_SUPPORT}"
${1} "LEDA:\t\t${_tmp}supported"
_set_tmp_to_not_or_not "${QT_SUPPORT}"
${1} "Qt:\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_LIBNAME} ]; then
LIB_COMPILED='ok'
else
LIB_COMPILED=''
fi
}
# set GMP_INSTALLATION
# first check for sysdir installation, then for an external installation
# return 0, iff one of these tests 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
GMP_INSTALLATION='e'
log_print "remark: GMP is not installed."
return 1
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 ${CGAL_INSTALL_CGAL} 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 LEDA_INCL_DIR "${_file}"; then
if [ -n "${LEDA_SUPPORT}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file LEDA_LIB_DIR "${_file}"; then
if [ -n "${LEDA_SUPPORT}" ]; then
SETUP_COMPLETE=''
fi
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_VERSION "${_file}"; then
GMP_VERSION=''
if [ -n "${GMP_SUPPORT}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file GMPXX_SUPPORT "${_file}"; then
GMPXX_SUPPORT=''
fi
if try_to_get_var_from_file GMPXX_VERSION "${_file}"; then
GMPXX_VERSION=''
if [ -n "${GMPXX_SUPPORT}" ]; then
SETUP_COMPLETE=''
fi
fi
if [ -z "${GMP_SUPPORT}" ]; then
GMPXX_SUPPORT=''
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}" = '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}" = 'e' ]; then
SETUP_COMPLETE=''
fi
fi
fi
# CORE specific stuff:
if try_to_get_var_from_file CORE_SUPPORT "${_file}" ||\
try_to_get_var_from_file CORE_INSTALLATION "${_file}"; then
CORE_INSTALLATION=''
CORE_SUPPORT=''
SETUP_COMPLETE=''
fi
if try_to_get_var_from_file CORE_VERSION "${_file}"; then
CORE_VERSION=''
# As we do not have it yet and core had to be built before CGAL,
# let's not be too picky about it...
# if [ -n "${CORE_SUPPORT}" ]; then
# SETUP_COMPLETE=''
# fi
fi
if try_to_get_var_from_file CORE_INCL_DIR "${_file}"; then
if [ -n "${CORE_SUPPORT}" ]; then
if [ "${CORE_INSTALLATION}" = 'z' -o \
"${CORE_INSTALLATION}" = 'e' ]; then
SETUP_COMPLETE=''
fi
fi
fi
if try_to_get_var_from_file CORE_LIB_DIR "${_file}"; then
if [ -n "${CORE_SUPPORT}" ]; then
if [ "${CORE_INSTALLATION}" = 'z' -o \
"${CORE_INSTALLATION}" = 'e' ]; then
SETUP_COMPLETE=''
fi
fi
fi
# Qt specific stuff:
if try_to_get_var_from_file QT_SUPPORT "${_file}"; then
QT_SUPPORT=''
else
try_to_get_var_from_file QT_SECOND_LIB "${_file}"
try_to_get_var_from_file QT_T_SUPPORT "${_file}"
try_to_get_var_from_file QT_DLL "${_file}"
fi
if try_to_get_var_from_file QT_VERSION "${_file}"; then
QT_VERSION=''
if [ -n "${QT_SUPPORT}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file QT_ADVANCED_MODE "${_file}"; then
QT_ADVANCED_MODE=''
fi
if try_to_get_var_from_file NEED_EXTRA_QT_IDIR "${_file}" || \
try_to_get_var_from_file NEED_EXTRA_QT_LDIR "${_file}" || \
try_to_get_var_from_file NEED_EXTRA_QTMOC "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -n "${QT_ADVANCED_MODE}" ]; then
QT_SUPPORT=''
SETUP_COMPLETE=''
fi
NEED_EXTRA_QT_IDIR='n'
NEED_EXTRA_QT_LDIR='n'
NEED_EXTRA_QTMOC='n'
fi
if try_to_get_var_from_file NEED_EXTRA_QTDIR "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -z "${QT_ADVANCED_MODE}" ]; then
QT_SUPPORT=''
SETUP_COMPLETE=''
fi
NEED_EXTRA_QTDIR='n'
fi
if try_to_get_var_from_file QT_DIR "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -z "${QT_ADVANCED_MODE}" -a \
-n "${NEED_EXTRA_QTDIR}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file QT_INCL_DIR "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -n "${QT_ADVANCED_MODE}" -a \
-n "${NEED_EXTRA_QT_IDIR}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file QT_LIB_DIR "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -n "${QT_ADVANCED_MODE}" -a \
-n "${NEED_EXTRA_QT_LDIR}" ]; then
SETUP_COMPLETE=''
fi
fi
if try_to_get_var_from_file QT_MOC "${_file}"; then
if [ -n "${QT_SUPPORT}" -a -n "${QT_ADVANCED_MODE}" -a \
-n "${NEED_EXTRA_QTMOC}" ]; then
SETUP_COMPLETE=''
fi
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
if try_to_get_var_from_file LONG_NAME_PROBLEM "${_file}"; then
SETUP_COMPLETE=''
fi
if try_to_get_var_from_file ENABLE_SHARED "${_file}"; then
ENABLE_SHARED='y'
SETUP_COMPLETE=''
fi
set_lib_compiled_flag
reassemble_compiler
}
# 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}/`full_ostype`
store_compiler_settings()
{
_file="${CGAL_INSTALL_CONF_DIR}/`full_ostype`"
${_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 " \
"${CGAL_INSTALL_CGAL} ${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 LEDA_SUPPORT >>${_file}
_store_install_config_variable LEDA_VERSION >>${_file}
_store_install_config_variable LEDA_INCL_DIR >>${_file}
_store_install_config_variable LEDA_LIB_DIR >>${_file}
_store_install_config_variable GMP_SUPPORT >>${_file}
_store_install_config_variable GMP_VERSION >>${_file}
_store_install_config_variable GMPXX_SUPPORT >>${_file}
_store_install_config_variable GMPXX_VERSION >>${_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 CORE_SUPPORT >>${_file}
_store_install_config_variable CORE_VERSION >>${_file}
_store_install_config_variable CORE_INSTALLATION >>${_file}
_store_install_config_variable CORE_INCL_DIR >>${_file}
_store_install_config_variable CORE_LIB_DIR >>${_file}
_store_install_config_variable QT_SUPPORT >>${_file}
_store_install_config_variable QT_VERSION >>${_file}
_store_install_config_variable QT_SECOND_LIB >>${_file}
_store_install_config_variable QT_T_SUPPORT >>${_file}
_store_install_config_variable QT_DLL >>${_file}
_store_install_config_variable QT_ADVANCED_MODE >>${_file}
_store_install_config_variable NEED_EXTRA_QTDIR >>${_file}
_store_install_config_variable QT_DIR >>${_file}
_store_install_config_variable NEED_EXTRA_QT_IDIR >>${_file}
_store_install_config_variable QT_INCL_DIR >>${_file}
_store_install_config_variable NEED_EXTRA_QT_LDIR >>${_file}
_store_install_config_variable QT_LIB_DIR >>${_file}
_store_install_config_variable NEED_EXTRA_QTMOC >>${_file}
_store_install_config_variable QT_MOC >>${_file}
_store_install_config_variable CUSTOM_CXXFLAGS >>${_file}
_store_install_config_variable CUSTOM_LDFLAGS >>${_file}
_store_install_config_variable LONG_NAME_PROBLEM >>${_file}
_store_install_config_variable ENABLE_SHARED >>${_file}
${_printf} "\n%s\n" \
"/* EOF */" \
>>${_file}
log_print "Settings stored in ${_file}."
}
# test current setup and set SETUP_COMPLETE
# return 0, iff setup is ok
test_setup()
{
SETUP_COMPLETE=''
make_lib_dir
cd ${CGAL_TEST_CONF_DIR}
_check_dir_exists_create ${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}
create_standard_header_replacements
_check_dir_exists_create ${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}/CGAL
_file=${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}/CGAL/compiler_config.h
if [ -z "${CONFIG_TEST_PASSED}" ]; then
print_filled_line
print_line "The following lines show results of configuration tests."
print_line \
"Some of the tests might fail, since many compilers are"
print_line "still not completely ISO standard compliant."
print_line "Since we worked around the arising problems,"
print_center_line "${_bold_on}*** CGAL will work fine ***${_bold_off}"
print_line "regardless of the outcome of these tests."
print_filled_line
flush_buffer
test_compiler_specifica "${INSTALL_VERBOSE}"
for totest in LEDA GMP GMPXX CORE QT; do
${_printf} "%s%s\n" \
"//+----------------------------------------------------------" \
"----------------" \
>> ${_file}
${_printf} "%s\n" "//| Is CGAL compiled with support for ${totest}?" \
>> ${_file}
${_printf} "%s%s\n" \
"//+----------------------------------------------------------" \
"----------------" \
>> ${_file}
${_printf} "%s\n" "#ifndef CGAL_NO_${totest}" >> ${_file}
${_printf} "%s\n" "//#define CGAL_USE_${totest} 1" >> ${_file}
${_printf} "%s\n" "#define CGAL_${totest}_VERSION 0" >> ${_file}
${_printf} "%s\n\n" "#endif // ! CGAL_NO_${totest}" >> ${_file}
done
CONFIG_TEST_PASSED='y'
fi
SETUP_COMPLETE='y'
for totest in LEDA GMP GMPXX CORE QT; do
# run test
_tmp="${totest}_TEST_PASSED"
if [ -z "`value_of ${_tmp}`" ]; then
if eval "test_${totest} \"${totest}\" 'v'"; then
# set CGAL_USE in compiler_config file
_tmp="${totest}_SUPPORT"
_tmp2="#define CGAL_USE_${totest} 1"
_tmp3="//#define CGAL_USE_${totest} 1"
if [ -n "`value_of ${_tmp}`" ]; then
replace_line "${_file}" "${_tmp3}" "${_tmp2}"
else
replace_line "${_file}" "${_tmp2}" "${_tmp3}"
fi
# set VERSION in compiler_config file
_tmp2="${totest}_VERSION"
_tmp3="`value_of ${_tmp2}`"
replace_line "${_file}" "#define CGAL_${_tmp2}" \
"#define CGAL_${_tmp2} ${_tmp3:-0}"
else
SETUP_COMPLETE=''
fi
else
${_printf} "%s\n" "${_LEFTSPACE}${totest} test has already been passed."
fi
done
cd ${CGAL_DIR}
if [ -z "${SETUP_COMPLETE}" ]; then return 1; fi
${_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()
{
CONFIG_TEST_PASSED=''
LEDA_TEST_PASSED=''
GMP_TEST_PASSED=''
CORE_TEST_PASSED=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
}
# load the settings for ${COMPILER},
# if a config file exists, otherwise check for STL
_choose_compiler()
{
log_print "Choosing `extended_compiler_description` as compiler."
CUSTOM_OSTYPE_TAG="`custom_ostype_tag`"
set_ostype
set_compiler_flags
retrieve_compiler_settings
if [ -z "${SETUP_COMPLETE}" ]; then
# reset all TEST_PASSED variables
reset_all_test_variables
else
# reset all TEST_PASSED variables
CONFIG_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
if [ -n "${CORE_SUPPORT}" ]; then
CORE_TEST_PASSED='y'
else
CORE_TEST_PASSED=''
fi
if [ -n "${QT_SUPPORT}" ]; then
QT_TEST_PASSED='y'
QT_MOC_TEST_PASSED='y'
else
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
fi
fi
}
# sets the CGAL_SUPPORT_COMPILER variable for CGAL_COMPILER to
# empty (unsupported) or 'y' (supported).
_set_support()
{
CGAL_SUPPORT_COMPILER=''
case `compiler_description` in
# *Borland*)
# case `compiler_version` in
# 5.5*) CGAL_SUPPORT_COMPILER='y';;
# esac
# ;;
*SUNPRO*)
case `compiler_version` in
5.5*) CGAL_SUPPORT_COMPILER='y';;
esac
;;
*MIPSPRO*n32*|*MIPSPRO*64*)
case `compiler_version` in
7.[34]*) CGAL_SUPPORT_COMPILER='y';;
esac
;;
*GNU*)
case `compiler_version` in
3.[234]*) CGAL_SUPPORT_COMPILER='y';;
4.0*) CGAL_SUPPORT_COMPILER='y';;
esac
;;
*Intel*|*ICC*)
case `compiler_version` in
[78]*) CGAL_SUPPORT_COMPILER='y';;
esac
;;
*VC++*)
case `compiler_version` in
1310*) CGAL_SUPPORT_COMPILER='y';;
esac
;;
esac
}
# 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}
_set_support
}
# ---------------------------------------------------------------------
# functions common to all menus
#
# used to build the string of supported third-party libraries
# $1 is supported, iff $2 is non-empty
_set_supported_library()
{
if [ -n "${2}" ]; then
if [ -n "${_SUPPORT}" ]; then
if [ -n "${_PRELASTSUPPORT}" ]; then
if [ -n "${_LASTSUPPORT}" ]; then
_SUPPORT="${_SUPPORT}, ${_PRELASTSUPPORT}"
_PRELASTSUPPORT="${_LASTSUPPORT}"
fi
_LASTSUPPORT="${1}"
else
_PRELASTSUPPORT="${1}"
fi
else
_SUPPORT="${1}"
fi
fi
}
# print current setup status, $1 is menu-name
menu_header()
{
_SUPPORT=''
_PRELASTSUPPORT=''
_LASTSUPPORT=''
_set_supported_library "GMP" "${GMP_SUPPORT}"
_set_supported_library "GMPXX" "${GMPXX_SUPPORT}"
_set_supported_library "CORE" "${CORE_SUPPORT}"
_set_supported_library "LEDA" "${LEDA_SUPPORT}"
_set_supported_library "QT" "${QT_SUPPORT}"
if [ -n "${_LASTSUPPORT}" ]; then
_SUPPORT="${_SUPPORT}, ${_PRELASTSUPPORT}, and ${_LASTSUPPORT}"
elif [ -n "${_PRELASTSUPPORT}" ]; then
_SUPPORT="${_SUPPORT} and ${_PRELASTSUPPORT}"
elif [ -z "${_SUPPORT}" ]; then
_SUPPORT='no other library'
fi
clear_screen
print_filled_line
print_headline "CGAL $CGAL_VERSION Installation ${1} Menu"
print_line "OS: ${SYST}"
print_line \
"Compiler: `extended_compiler_description`"
print_line "Support for: ${_SUPPORT}."
print_empty_line
if [ -n "${CGAL_SUPPORT_COMPILER}" ]; then
print_line "Compiler is supported by CGAL."
else
print_line "Compiler is NOT supported by CGAL."
fi
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}<Q>${_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
_tmp="`value_of $1`"
eval "$1=\"`posix_path ${_tmp}`\""
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_choose_menu to choose which compiler to use
#
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
print_line "${_bold_on}<R>${_bold_off} Register new compiler"
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
;;
r|R)
change_value COMPILER_NAME
# Reject if it's the name of an already registered compiler
i=1
while [ $i -lt ${_COMPILER_NUMBER} ]; do
_tmp=`eval "echo '$'_COMPILER_$i"`
_tmp=`eval "echo ${_tmp}"`
if [ "${COMPILER_NAME}" = `compiler_bin ${_tmp}` ]; then
return
fi
eval "${_EXPR} ${i} + 1"
i=${_result}
done
# Reject if it doesn't pass this test
if get_compiler_description ${COMPILER_NAME} ; then :
else
return
fi
COMPILER="`basename ${COMPILER_NAME}`@`compiler_basename \"${_tmp3}\"`@${COMPILER_NAME}@${COMPILER_NAME}@`compiler_description \"${_tmp3}\"`@"
CUSTOM_OSTYPE_TAG=''
_check_and_register_compiler "${COMPILER}"
reset_all_test_variables
_choose_compiler
_set_support
SETUP_COMPLETE=''
return
;;
q|Q|b|B)
return
;;
esac
done
}
# ---------------------------------------------------------------------
# compiler_menu : setup compiler options.
#
compiler_menu()
{
while [ 0 ]; do
menu_header 'Compiler'
print_line "${_bold_on}<C>${_bold_off} Choose compiler"
print_line "${_bold_on}<F>${_bold_off} Set custom compiler flags"
print_multi_line "${CUSTOM_CXXFLAGS:-<none>}"
print_line "${_bold_on}<L>${_bold_off} Set custom linker flags"
print_multi_line "${CUSTOM_LDFLAGS:-<none>}"
print_line "${_bold_on}<S>${_bold_off} Toggle shared libraries building"
if [ -n "${ENABLE_SHARED}" ]; then
print_multi_line "<enabled>"
else
print_multi_line "<disabled>"
fi
print_line "${_bold_on}<O>${_bold_off} Set custom ostype tag"
print_multi_line "${CUSTOM_OSTYPE_TAG:-<none>}"
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Main Menu'
case ${KEY} in
c|C)
compiler_choose_menu
;;
f|F)
change_value CUSTOM_CXXFLAGS
reset_all_test_variables
SETUP_COMPLETE=''
;;
l|L)
change_value CUSTOM_LDFLAGS
reset_all_test_variables
SETUP_COMPLETE=''
;;
o|O)
change_value CUSTOM_OSTYPE_TAG
check_CUSTOM_OSTYPE_TAG
reassemble_compiler
_register_compiler "${COMPILER}"
_choose_compiler
reset_all_test_variables
SETUP_COMPLETE=''
;;
s|S)
if [ -n "${ENABLE_SHARED}" ]; then
ENABLE_SHARED=''
else
ENABLE_SHARED='y'
fi
#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}<E>${_bold_off} Toggle LEDA support"
if [ -n "${LEDA_SUPPORT}" ]; then
print_line "${_bold_on}<I>${_bold_off} LEDA include directory"
print_line " ${LEDA_INCL_DIR:-<undefined>}"
print_line "${_bold_on}<L>${_bold_off} LEDA lib directory"
print_line " ${LEDA_LIB_DIR:-<undefined>}"
fi
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Support Menu'
case ${KEY} in
e|E)
if [ -z "${LEDA_SUPPORT}" ]; then
LEDA_SUPPORT='_LEDA'
SETUP_COMPLETE=''
else
LEDA_SUPPORT=''
fi
;;
i|I)
if [ -n "${LEDA_SUPPORT}" ]; then
if change_dir LEDA_INCL_DIR dir; then
LEDA_TEST_PASSED=''
SETUP_COMPLETE=''
fi
fi
;;
l|L)
if [ -n "${LEDA_SUPPORT}" ]; then
if change_dir LEDA_LIB_DIR dir; then
LEDA_TEST_PASSED=''
SETUP_COMPLETE=''
fi
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}<G>${_bold_off} Toggle GMP support"
if [ -n "${GMP_SUPPORT}" ]; then
print_line "${_bold_on}<X>${_bold_off} Toggle GMP built-in C++ interface support"
print_line "${_bold_on}<I>${_bold_off} GMP include directory"
case ${GMP_INSTALLATION} in
s) _tmp='<system include directory>';;
*) _tmp="${GMP_INCL_DIR}";;
esac
print_line " ${_tmp:-<undefined>}"
print_line "${_bold_on}<L>${_bold_off} GMP lib directory"
case ${GMP_INSTALLATION} in
s) _tmp='<system lib directory>';;
*) _tmp="${GMP_LIB_DIR}";;
esac
print_line " ${_tmp:-<undefined>}"
if [ "${GMP_INSTALLATION}" = 'x' ]; then
print_line \
"${_bold_on}<S>${_bold_off} Use GMP installation in system dirs"
fi
fi
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Support Menu'
case $KEY in
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
if [ -n "${CORE_SUPPORT}" ]; then
go_down_lines 1
print_filled_line
print_center_line "REMARK: Core requires GMP."
wait_for_enter
CORE_SUPPORT=''
fi
GMP_SUPPORT=''
GMPXX_SUPPORT=''
fi
;;
x|X)
if [ -n "${GMP_SUPPORT}" ]; then
if [ -n "${GMPXX_SUPPORT}" ]; then
GMPXX_SUPPORT=''
else
GMPXX_SUPPORT='_GMPXX'
fi
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
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
s|x) GMP_INSTALLATION='x';;
*) GMP_INSTALLATION='e';;
esac
fi
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
}
# ---------------------------------------------------------------------
# core_menu to setup CORE
#
core_menu()
{
while [ 0 ]; do
menu_header 'CORE'
print_line "${_bold_on}<C>${_bold_off} Toggle CORE support"
if [ -n "${CORE_SUPPORT}" ]; then
print_line "${_bold_on}<I>${_bold_off} CORE include directory"
case ${CORE_INSTALLATION} in
c) _tmp='<CGAL include directory>';;
*) _tmp="${CORE_INCL_DIR}";;
esac
print_line " ${_tmp:-<undefined>}"
print_line "${_bold_on}<L>${_bold_off} CORE lib directory"
case ${CORE_INSTALLATION} in
c) _tmp='<CGAL lib directory>';;
*) _tmp="${CORE_LIB_DIR}";;
esac
print_line " ${_tmp:-<undefined>}"
if [ "${CORE_INSTALLATION}" = 'z' ]; then
print_line \
"${_bold_on}<Z>${_bold_off} Use CORE installation in CGAL tree"
fi
fi
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Support Menu'
case $KEY in
c|C)
if [ -z "${CORE_SUPPORT}" ]; then
if [ -z "${GMP_SUPPORT}" ]; then
go_down_lines 1
print_filled_line
print_center_line "REMARK: Core requires GMP."
wait_for_enter
GMP_SUPPORT='_GMP'
if [ -z "${GMP_INSTALLATION}" ]; then
flush_buffer
search_gmp "${INSTALL_VERBOSE}"
fi
fi
SETUP_COMPLETE=''
CORE_SUPPORT='_CORE'
if [ -z "${CORE_INSTALLATION}" ]; then
CORE_INSTALLATION='c'
fi
else
CORE_SUPPORT=''
fi
;;
i|I)
if [ -n "${CORE_SUPPORT}" ]; then
if change_dir CORE_INCL_DIR dir; then
CORE_TEST_PASSED=''
SETUP_COMPLETE=''
case ${CORE_INSTALLATION} in
c|z) CORE_INSTALLATION='z';;
*) CORE_INSTALLATION='e';;
esac
fi
fi
;;
l|L)
if [ -n "${CORE_SUPPORT}" ]; then
if change_dir CORE_LIB_DIR dir; then
CORE_TEST_PASSED=''
SETUP_COMPLETE=''
case ${CORE_INSTALLATION} in
c|z) CORE_INSTALLATION='z';;
*) CORE_INSTALLATION='e';;
esac
fi
fi
;;
z|Z)
if [ -n "${CORE_SUPPORT}" -a \
"${CORE_INSTALLATION}" = 'z' ]; then
CORE_TEST_PASSED='y'
CORE_INSTALLATION='c'
fi
;;
t|T)
go_down_lines 3
flush_buffer
test_setup
;;
q|Q|b|B)
return;;
*);;
esac
done
}
# ---------------------------------------------------------------------
# qt_menu to setup Qt
#
qt_menu()
{
while [ 0 ]; do
menu_header 'Qt'
print_line "${_bold_on}<K>${_bold_off} Toggle Qt support"
if [ -n "${QT_SUPPORT}" ]; then
if [ -z "${QT_ADVANCED_MODE}" ]; then
print_line "${_bold_on}<A>${_bold_off} Advanced mode"
print_line \
"${_bold_on}<D>${_bold_off} Qt directory"
if [ -n "${NEED_EXTRA_QTDIR}" ]; then
if [ -z "${QT_DIR}" ]; then
_tmp1='<undefined>'
else
_tmp1="`posix_path ${QT_DIR}`"
fi
print_line " ${_tmp1}"
if [ "${NEED_EXTRA_QTDIR}" = "x" ]; then
print_line \
"${_bold_on}<E>${_bold_off} Use \$QTDIR as Qt directory."
fi
else
_tmp1="`posix_path ${QT_DIR}`"
print_line " ${_tmp1} <defined in \$QTDIR>"
fi
else
print_line "${_bold_on}<B>${_bold_off} Basic mode"
print_line \
"${_bold_on}<I>${_bold_off} Qt include directory"
if [ -n "${NEED_EXTRA_QT_IDIR}" ]; then
print_line \
" `posix_path ${QT_INCL_DIR:-<undefined>}`"
if [ "${NEED_EXTRA_QT_IDIR}" = "x" ]; then
print_line \
"${_bold_on}<J>${_bold_off} Use Qt headers from system include."
fi
else
print_line " <system include directory>"
fi
print_line "${_bold_on}<L>${_bold_off} Qt lib directory"
if [ -n "${NEED_EXTRA_QT_LDIR}" ]; then
print_line \
" `posix_path ${QT_LIB_DIR:-<undefined>}`"
if [ "${NEED_EXTRA_QT_LDIR}" = "x" ]; then
print_line \
"${_bold_on}<M>${_bold_off} Use Qt libs from system libdir."
fi
else
print_line " <system lib directory>"
fi
print_line "${_bold_on}<O>${_bold_off} Qt moc executable"
if [ -n "${NEED_EXTRA_QTMOC}" ]; then
print_line " `posix_path ${QT_MOC:-<undefined>}`"
if [ "${NEED_EXTRA_QTMOC}" = "x" ]; then
print_line \
"${_bold_on}<P>${_bold_off} Use Qt moc from path."
fi
else
print_line " <in path>"
fi
fi
if [ -n "${WINDOWS_COMPILER}" ]; then
print_line \
"${_bold_on}<R>${_bold_off} Set the second lib used along with qtmain.lib"
if [ "${QT_SECOND_LIB}" = 'qt' ]; then
print_line " The default one is qt.lib"
else
print_line " Qt second lib is ${QT_SECOND_LIB}.lib"
fi
fi
print_line "${_bold_on}<S>${_bold_off} Toggle THREAD_SUPPORT"
if [ "${QT_T_SUPPORT}" = 'y' ]; then
print_line " Thread support is currently ON"
else
print_line " Thread support is currently OFF"
fi
if [ -n "${WINDOWS_COMPILER}" ]; then
print_line \
"${_bold_on}<F>${_bold_off} Toggle QT_DLL macro (used when Qt is built shared)"
if [ "${QT_DLL}" = 'not_defined' ]; then
print_line " QT_DLL macro is not defined"
else
print_line " QT_DLL macro is defined"
fi
fi
fi
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Support Menu'
case ${KEY} in
k|K)
if [ -z "${QT_SUPPORT}" ]; then
SETUP_COMPLETE=''
QT_SUPPORT='_QT'
go_down_lines 3
flush_buffer
# test QTDIR if this was not done before
if [ "${NEED_EXTRA_QTDIR}" = 'n' ]; then
test_for_qt_dir "${INSTALL_VERBOSE}"
fi
# test for QT sysincl/-lib and moc, if this was not
# done before
if [ "${NEED_EXTRA_QT_IDIR}" = 'n' -o \
"${NEED_EXTRA_QT_LDIR}" = 'n' -o \
"${NEED_EXTRA_QTMOC}" = 'n' ]; then
test_for_qt_moc_in_path "${INSTALL_VERBOSE}"
if [ -z "${WINDOWS_COMPILER}" ]; then
test_for_qt_incl_in_sys_incl "${INSTALL_VERBOSE}"
test_for_qt_lib_in_sys_lib "${INSTALL_VERBOSE}"
fi
fi
if [ "${NEED_EXTRA_QT_IDIR}" = 'x' -a \
"${NEED_EXTRA_QT_LDIR}" = 'x' -a \
"${NEED_EXTRA_QTMOC}" = 'x' ]; then
QT_ADVANCED_MODE='y'
else
QT_ADVANCED_MODE=''
fi
else
QT_SUPPORT=''
QT_ADVANCED_MODE=''
fi
;;
r|R)
if [ -n "${WINDOWS_COMPILER}" ]; then
change_value QT_SECOND_LIB
fi;;
s|S)
if [ "${QT_T_SUPPORT}" = 'y' ]; then
QT_T_SUPPORT='n'
if [ "${QT_DLL}" = 'not_defined' ]; then
CGAL_QT_CXXFLAGS=''
else
CGAL_QT_CXXFLAGS='-DQT_DLL'
fi
else
QT_T_SUPPORT='y'
if [ "${QT_DLL}" = 'not_defined' ]; then
CGAL_QT_CXXFLAGS='-DQT_THREAD_SUPPORT'
else
CGAL_QT_CXXFLAGS='-DQT_DLL -DQT_THREAD_SUPPORT'
fi
fi
;;
f|F)
if [ -n "${WINDOWS_COMPILER}" ]; then
if [ "${QT_DLL}" = 'not_defined' ]; then
QT_DLL='y'
else
QT_DLL='not_defined'
fi
fi
;;
a|A)
if [ -n "${QT_SUPPORT}" -a -z "${QT_ADVANCED_MODE}" ]; then
QT_ADVANCED_MODE='y'
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
;;
b|B)
if [ -n "${QT_SUPPORT}" -a -n "${QT_ADVANCED_MODE}" ]; then
QT_ADVANCED_MODE=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
# test QTDIR if this was not done before
if [ "${NEED_EXTRA_QTDIR}" = 'n' ]; then
go_down_lines 3
flush_buffer
test_for_qt_dir "${INSTALL_VERBOSE}"
fi
if [ -n "${QT_DIR}" ]; then
qt_dir_has_changed
fi
fi
;;
d|D)
if [ -n "${QT_SUPPORT}" -a -z "${QT_ADVANCED_MODE}" ]; then
if [ -z "${NEED_EXTRA_QTDIR}" ]; then
NEED_EXTRA_QTDIR='x'
fi
if change_dir QT_DIR dir; then
if [ -z "${NEED_EXTRA_QTDIR}" ]; then
NEED_EXTRA_QTDIR='x'
fi
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
qt_dir_has_changed
fi
fi
;;
e|E)
if [ "${NEED_EXTRA_QTDIR}" = "x" ]; then
NEED_EXTRA_QTDIR=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
;;
i|I)
if [ -n "${QT_SUPPORT}" ]; then
if [ -z "${NEED_EXTRA_QT_IDIR}" ]; then
NEED_EXTRA_QT_IDIR='x'
fi
if change_dir QT_INCL_DIR dir; then
if [ -z "${NEED_EXTRA_QT_IDIR}" ]; then
NEED_EXTRA_QT_IDIR='x'
fi
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
fi
;;
j|J)
if [ "${NEED_EXTRA_QT_IDIR}" = "x" ]; then
NEED_EXTRA_QT_IDIR=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
;;
l|L)
if [ -n "${QT_SUPPORT}" ]; then
if change_dir QT_LIB_DIR dir; then
if [ -z "${NEED_EXTRA_QT_LDIR}" ]; then
NEED_EXTRA_QT_LDIR='x'
fi
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
fi
;;
m|M)
if [ "${NEED_EXTRA_QT_LDIR}" = "x" ]; then
NEED_EXTRA_QT_LDIR=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
;;
o|O)
if [ -n "${QT_SUPPORT}" ]; then
if change_dir QT_MOC exe; then
if [ -z "${NEED_EXTRA_QTMOC}" ]; then
NEED_EXTRA_QTMOC='x'
fi
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
fi
;;
p|P)
if [ "${NEED_EXTRA_QTMOC}" = "x" ]; then
NEED_EXTRA_QTMOC=''
QT_TEST_PASSED=''
QT_MOC_TEST_PASSED=''
SETUP_COMPLETE=''
fi
;;
t|T)
go_down_lines 3
flush_buffer
test_setup;;
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
}
# ---------------------------------------------------------------------
# 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
}
# print args a s a continuation line, if not empty
makefile_print_continuationline()
{
if [ -n "${*}" ]; then
${_printf} " \\\\\n\t%s" "${*}"
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" >>${FILE}
concat_path "\$(CGAL_INCL_DIR)" "CGAL" config "${CGAL_OS_COMPILER}" >> ${FILE}
${_printf} "\n\n" >>${FILE}
#
# LEDA_INCL_DIR
#
if [ -n "${LEDA_SUPPORT}" -a -n "${LEDA_INCL_DIR}" ]; then
print_as_shell_comment \
"*** Fill in your LEDA include directory (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}" = '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
#
# CORE_INCL_DIR
#
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" != 'c' ]; then
print_as_shell_comment \
"*** Fill in your CORE include directory ***" \
>> ${FILE}
${_printf} "%s\\\\\n" "CORE_INCL_DIR = " >> ${FILE}
${_printf} "\t%s\n\n" \
"`_where_is 'CORE_INCL_DIR'`" \
>> ${FILE}
fi
#
# QT_MOC
#
if [ -n "${QT_SUPPORT}" ]; then
print_as_shell_comment \
"*** Fill in your Qt moc executable ***" \
>> ${FILE}
print_as_shell_comment \
"(e.g. /usr/local/lib/qt/bin/moc)" \
>> ${FILE}
${_printf} "%s\\\\\n" "QT_MOC = " >> ${FILE}
${_printf} "\t%s\n\n" "`posix_path ${QT_MOC}`" >> ${FILE}
fi
if [ -z "${QT_SUPPORT}" ]; then
print_as_shell_comment \
"*** We fake QT_MOC to let the testsuite pass ***" \
>> ${FILE}
${_printf} "%s\n\n" "QT_MOC = echo dummymoc" >> ${FILE}
fi
#
# QT_INCL_DIR
#
if [ -n "${QT_SUPPORT}" -a -n "${NEED_EXTRA_QT_IDIR}" ]; then
print_as_shell_comment \
"*** Fill in your Qt include directory ***" \
>> ${FILE}
print_as_shell_comment \
"(e.g. /usr/local/lib/qt/include)" \
>> ${FILE}
${_printf} "%s\\\\\n" "QT_INCL_DIR = " >> ${FILE}
${_printf} "\t%s\n\n" "`_where_is 'QT_INCL_DIR'`" >> ${FILE}
fi
#
# LONG_NAME_PROBLEM_CXXFLAGS
#
print_as_shell_comment \
"*** to work around the long-name-problem with sun as/ld" >> ${FILE}
if [ -n "${LONG_NAME_PROBLEM}" ]; then
${_printf} "%s\n\n" "LONG_NAME_PROBLEM_CXXFLAGS = ${LONG_NAME_PROBLEM_CXXFLAGS}" \
>> ${FILE}
else
${_printf} "%s\n\n" "LONG_NAME_PROBLEM_CXXFLAGS =" >> ${FILE}
fi
#
# CGAL_CXXFLAGS
#
${_printf} "%s\\\\\n" "CGAL_CXXFLAGS = " >> ${FILE}
makefile_print_line "\$(CUSTOM_CXXFLAGS) ${ADDITIONAL_CXXFLAGS}" >> ${FILE}
if [ -n "${GMP_SUPPORT}" ]; then
if [ -n "${GMPXX_SUPPORT}" ]; then
makefile_print_line "-DCGAL_USE_GMP -DCGAL_USE_GMPXX" >> ${FILE}
else
makefile_print_line "-DCGAL_USE_GMP" >> ${FILE}
fi
fi
if [ -n "${CORE_SUPPORT}" ]; then
makefile_print_line "-DCGAL_USE_CORE" >> ${FILE}
fi
if [ -n "${QT_SUPPORT}" ]; then
makefile_print_line "-DCGAL_USE_QT ${CGAL_QT_CXXFLAGS}" >> ${FILE}
fi
if [ -n "${LEDA_SUPPORT}" ]; then
makefile_print_line "-DCGAL_USE_LEDA -DLEDA_PREFIX" >> ${FILE}
fi
makefile_print_line "'-I\$(CGAL_INCL_CONF_DIR)'" >> ${FILE}
${_printf} "\t%s" "'-I\$(CGAL_INCL_DIR)'" >> ${FILE}
if [ -n "${GMP_SUPPORT}" ]; then
if [ "${GMP_INSTALLATION}" = 'x' -o "${GMP_INSTALLATION}" = 'e' ]; then
${_printf} "\t%s" "'-I\$(GMP_INCL_DIR)'" >> ${FILE}
fi
fi
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" != 'c' ]; then
${_printf} "\t%s" "'-I\$(CORE_INCL_DIR)'" >> ${FILE}
fi
if [ -n "${LEDA_SUPPORT}" -a -n "${LEDA_INCL_DIR}" ]; then
${_printf} "\t%s" "'-I\$(LEDA_INCL_DIR)'" >> ${FILE}
fi
if [ -n "${QT_SUPPORT}" ]; then
${_printf} "\t%s" "'-I\$(QT_INCL_DIR)'" >> ${FILE}
fi
${_printf} "\n\n" >> ${FILE}
#
# CGAL_WINLIB_CXXFLAGS
#
${_printf} "%s\\\\\n" \
"CGAL_WINLIB_CXXFLAGS = " >> ${FILE}
if [ -n "${WINDOW_INCLUDE}" ]; then
${_printf} "\t%s\n\n" \
"\$(CGAL_LIB_CXXFLAGS) ${CGAL_WINLIB_CXXFLAGS} -I${WINDOW_INCLUDE}" \
>> ${FILE}
else
${_printf} "\t%s\n\n" \
"\$(CGAL_LIB_CXXFLAGS) ${CGAL_WINLIB_CXXFLAGS}" >> ${FILE}
fi
}
# write linker flags for a CGAL include makefile
write_linker_flags()
{
makefile_header "linker flags" >> ${FILE}
${_printf} "%s%s\n" "EXE_OPT = " "${EXE_OPT}${SAVE_THE_BLANK}" >> ${FILE}
#
# LEDA_LIB_DIR
#
if [ -n "${LEDA_SUPPORT}" -a -n "${LEDA_LIB_DIR}" ]; then
print_as_shell_comment \
"*** Fill in your LEDA_lib_directory (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}" = '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
#
# CORE_LIB_DIR
#
if [ -n "${CORE_SUPPORT}" -a "${CORE_INSTALLATION}" != 'c' ]; then
print_as_shell_comment \
"*** Fill in your CORE lib directory ***" \
>> ${FILE}
print_as_shell_comment \
"(e.g. /usr/local/lib)" \
>> ${FILE}
${_printf} "%s\\\\\n" "CORE_LIB_DIR = " >> ${FILE}
${_printf} "\t%s\n\n" \
"`_where_is 'CORE_LIB_DIR'`" \
>> ${FILE}
fi
#
# QT_LIB_DIR
#
if [ -n "${QT_SUPPORT}" -a -n "${NEED_EXTRA_QT_LDIR}" ]; then
print_as_shell_comment \
"*** Fill in your Qt lib directory ***" \
>> ${FILE}
print_as_shell_comment \
"(e.g. /usr/local/lib/qt/lib)" \
>> ${FILE}
${_printf} "%s\\\\\n" "QT_LIB_DIR = " >> ${FILE}
${_printf} "\t%s\n\n" \
"`_where_is 'QT_LIB_DIR'`" \
>> ${FILE}
fi
#
# CUSTOM_LDFLAGS
#
print_as_shell_comment \
"*** Fill in any additional linker flags you need ***" \
>> ${FILE}
${_printf} "%s\n\n" "CUSTOM_LIBPATH = ${CUSTOM_LIBPATH}" \
>> ${FILE}
${_printf} "%s\n\n" "CUSTOM_LDFLAGS = ${CUSTOM_LDFLAGS}" \
>> ${FILE}
#
# LIBS
#
if [ -n "${CYGWIN_COMPILER}" ]; then
LIB_PATH="'${LIBPATH_OPT}\$(CGAL_LIB_DIR)\\\$(CGAL_OS_COMPILER)'"
RUNTIME_LIB_PATH="\$(CGAL_LIB_DIR)\\\$(CGAL_OS_COMPILER)"
else
LIB_PATH="${LIBPATH_OPT}\$(CGAL_LIB_DIR)/\$(CGAL_OS_COMPILER)"
RUNTIME_LIB_PATH="\$(CGAL_LIB_DIR)/\$(CGAL_OS_COMPILER)"
fi
LIBS="`lib_option CGAL`"
WLIBS="`lib_option CGAL`"
if [ -n "${LEDA_SUPPORT}" ] ; then
if [ -n "${LEDA_LIB_DIR}" ]; then
if [ -n "${CYGWIN_COMPILER}" ]; then
LIB_PATH="${LIB_PATH} '${LIBPATH_OPT}\$(LEDA_LIB_DIR)'"
else
LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}\$(LEDA_LIB_DIR)"
fi
RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(LEDA_LIB_DIR)"
fi
LIBS="${LIBS} `leda_lib_option P``leda_lib_option G``leda_lib_option L`"
GEOWLIBS="${WLIBS} `leda_lib_option GeoW``leda_lib_option D3``leda_lib_option W``leda_lib_option P``leda_lib_option G``leda_lib_option L` ${XLIBS}"
WLIBS="${WLIBS} `leda_lib_option W``leda_lib_option P``leda_lib_option G``leda_lib_option L` ${XLIBS}"
else
# no LEDA --> Xlibs only
WLIBS="${WLIBS} ${XLIBS}"
fi
if [ -n "${QT_SUPPORT}" ] ; then
if [ -n "${NEED_EXTRA_QT_LDIR}" ]; then
if [ -n "${WINDOWS_COMPILER}" ]; then
LIB_PATH="${LIB_PATH} '${LIBPATH_OPT}\$(QT_LIB_DIR)'"
else
LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}\$(QT_LIB_DIR)"
fi
RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(QT_LIB_DIR)"
fi
# QLIBS = LIBS + special qt libs
if [ -n "${WINDOWS_COMPILER}" ]; then
SECOND_LIB=`lib_option "${QT_SECOND_LIB}"`
QLIBS="${LIBS} `lib_option CGALQt` `lib_option qtmain` `lib_option imm32` `lib_option wsock32` `lib_option gdi32` `lib_option user32` `lib_option ole32` `lib_option winspool` `lib_option comdlg32` `lib_option ws2_32` `lib_option shell32` `lib_option advapi32` ${SECOND_LIB}"
else
QLIBS="${LIBS} `lib_option CGALQt` `lib_qt`"
fi
else
# QLIBS has to be set anyway
QLIBS="${LIBS}"
fi
if [ -n "${CORE_SUPPORT}" ]; then
if [ "${CORE_INSTALLATION}" != 'c' ]; then
if [ -n "${CYGWIN_COMPILER}" ]; then
LIB_PATH="${LIB_PATH} '${LIBPATH_OPT}\$(CORE_LIB_DIR)'"
else
LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}\$(CORE_LIB_DIR)"
fi
RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(CORE_LIB_DIR)"
fi
LIBS="${LIBS} `lib_option core++`"
GEOWLIBS="${GEOWLIBS} `lib_option core++` "
WLIBS="${WLIBS} `lib_option core++`"
QLIBS="${QLIBS} `lib_option core++`"
fi
if [ -n "${GMP_SUPPORT}" ]; then
if [ "${GMP_INSTALLATION}" = 'x' -o "${GMP_INSTALLATION}" = 'e' ]; then
if [ -n "${CYGWIN_COMPILER}" ]; then
LIB_PATH="${LIB_PATH} '${LIBPATH_OPT}\$(GMP_LIB_DIR)'"
else
LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}\$(GMP_LIB_DIR)"
fi
RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:\$(GMP_LIB_DIR)"
fi
LIBS="${LIBS} `lib_option mpfr`"
GEOWLIBS="${GEOWLIBS} `lib_option mpfr`"
WLIBS="${WLIBS} `lib_option mpfr`"
QLIBS="${QLIBS} `lib_option mpfr`"
# gmpxx must be before gmp since it depends on it.
if [ -n "${GMPXX_SUPPORT}" ]; then
LIBS="${LIBS} `lib_option gmpxx`"
GEOWLIBS="${GEOWLIBS} `lib_option gmpxx`"
WLIBS="${WLIBS} `lib_option gmpxx`"
QLIBS="${QLIBS} `lib_option gmpxx`"
fi
LIBS="${LIBS} `lib_option gmp`"
GEOWLIBS="${GEOWLIBS} `lib_option gmp` "
WLIBS="${WLIBS} `lib_option gmp`"
QLIBS="${QLIBS} `lib_option gmp`"
fi
LIBS="${LIBS} `math_ldflags`"
GEOWLIBS="${GEOWLIBS} `math_ldflags`"
WLIBS="${WLIBS} `math_ldflags`"
#
# LONG_NAME_PROBLEM_LDFLAGS
#
print_as_shell_comment \
"*** to work around the long-name-problem with sun as/ld" >> ${FILE}
if [ -n "${LONG_NAME_PROBLEM}" ]; then
${_printf} "%s\n\n" "LONG_NAME_PROBLEM_LDFLAGS = ${LONG_NAME_PROBLEM_LDFLAGS}" \
>> ${FILE}
else
${_printf} "%s\n\n" "LONG_NAME_PROBLEM_LDFLAGS =" >> ${FILE}
fi
#
# OPENGL_LIBS
#
print_as_shell_comment \
"*** the libs to link against when using OpenGL" >> ${FILE}
${_printf} "%s\n\n" "OPENGL_LIBS = ${OPENGL_LIBS}" \
>> ${FILE}
#
# CGAL_LIBPATH
#
if [ -n "${SEPARATE_LIBPATH}" ] ; then
${_printf} "CGAL_LD_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_LIBPATH =" >> ${FILE}
else
${_printf} "CGAL_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_LD_LIBPATH =" >> ${FILE}
fi
makefile_print_continuationline "\$(CUSTOM_LIBPATH)" >> ${FILE}
makefile_print_continuationline "${LIB_PATH}" >> ${FILE}
if [ -n "${RUNTIME_LINKER_FLAG}" ]; then
makefile_print_continuationline \
"${RUNTIME_LINKER_FLAG}${RUNTIME_LIB_PATH}" \
>> ${FILE}
fi
${_printf} "\n" >> ${FILE}
if [ -n "${CYGWIN_COMPILER}" ]; then
#Adding psapi.lib only for Windows needed for Memory_sizer
LIBS="${LIBS} `lib_option psapi`"
QLIBS="${QLIBS} `lib_option psapi`"
WLIBS="${WLIBS} `lib_option psapi`"
fi
#
# CGAL_LDFLAGS
#
${_printf} "\n%s\\\\\n" "CGAL_LDFLAGS = " >> ${FILE}
makefile_print_line "${START_LD_OPT}\$(CGAL_LD_LIBPATH) ${ADDITIONAL_LDFLAGS}" >> ${FILE}
makefile_print_line "\$(CUSTOM_LDFLAGS)" >> ${FILE}
${_printf} "\t%s\n\n" "${LIBS}" >> ${FILE}
#
# CGAL_WINDOW_LIBPATH
#
if [ -n "${WINDOW_DIR}" ]; then
LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}${WINDOW_DIR}"
RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:${WINDOW_DIR}"
fi
if [ -n "${SEPARATE_LIBPATH}" ]; then
${_printf} "CGAL_WINDOW_LD_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_WINDOW_LIBPATH =" >> ${FILE}
else
${_printf} "CGAL_WINDOW_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_WINDOW_LD_LIBPATH =" >> ${FILE}
fi
makefile_print_continuationline "${CUSTOM_LIBPATH}" >> ${FILE}
makefile_print_continuationline "${LIB_PATH}" >> ${FILE}
if [ -n "${RUNTIME_LINKER_FLAG}" ]; then
makefile_print_continuationline "${RUNTIME_LINKER_FLAG}${RUNTIME_LIB_PATH}" \
>> ${FILE}
fi
${_printf} "\n\n" >> ${FILE}
#
# CGAL_WINDOW_LDFLAGS
#
${_printf} "%s\\\\\n" "CGAL_WINDOW_LDFLAGS = " >> ${FILE}
#if [ -n "${LEDA_SUPPORT}" ]; then
makefile_print_line "${START_LD_OPT}\$(CGAL_WINDOW_LD_LIBPATH) ${ADDITIONAL_LDFLAGS}" >> ${FILE}
makefile_print_line "\$(CUSTOM_LDFLAGS)" >> ${FILE}
${_printf} "\t%s\n\n" "${WLIBS}" >> ${FILE}
#else
# ${_printf} "\t%s\n\n" "\$(CGAL_LDFLAGS)" >> ${FILE}
#fi
#
# CGAL_GEOWIN_LDFLAGS
#
${_printf} "%s\\\\\n" "CGAL_GEOWIN_LDFLAGS = " >> ${FILE}
if [ -n "${LEDA_SUPPORT}" ]; then
makefile_print_line "${START_LD_OPT}\$(CGAL_WINDOW_LD_LIBPATH) ${ADDITIONAL_LDFLAGS}" >> ${FILE}
makefile_print_line "\$(CUSTOM_LDFLAGS)" >> ${FILE}
${_printf} "\t%s\n\n" "${GEOWLIBS}" >> ${FILE}
else
${_printf} "\t%s\n\n" "\$(CGAL_LDFLAGS)" >> ${FILE}
fi
#
# CGAL_QT_LIBPATH
#
#if [ -n "${WINDOW_DIR}" ]; then
# LIB_PATH="${LIB_PATH} ${LIBPATH_OPT}${WINDOW_DIR}"
# RUNTIME_LIB_PATH="${RUNTIME_LIB_PATH}:${WINDOW_DIR}"
#fi
if [ -n "${SEPARATE_LIBPATH}" ]; then
${_printf} "CGAL_QT_LD_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_QT_LIBPATH =" >> ${FILE}
else
${_printf} "CGAL_QT_LIBPATH =\n\n" >> ${FILE}
${_printf} "CGAL_QT_LD_LIBPATH =" >> ${FILE}
fi
makefile_print_continuationline "${CUSTOM_LIBPATH}" >> ${FILE}
makefile_print_continuationline "${LIB_PATH}" >> ${FILE}
if [ -n "${RUNTIME_LINKER_FLAG}" ]; then
makefile_print_continuationline "${RUNTIME_LINKER_FLAG}${RUNTIME_LIB_PATH}" \
>> ${FILE}
fi
${_printf} "\n\n" >> ${FILE}
#
# CGAL_QT_LDFLAGS
#
${_printf} "%s\\\\\n" "CGAL_QT_LDFLAGS = " >> ${FILE}
#if [ -n "${QT_SUPPORT}" ]; then
makefile_print_line "${START_LD_OPT}\$(CGAL_QT_LD_LIBPATH) ${ADDITIONAL_LDFLAGS}" >> ${FILE}
makefile_print_line "\$(CUSTOM_LDFLAGS)" >> ${FILE}
${_printf} "\t%s\n\n" "${QLIBS}" >> ${FILE}
#else
# ${_printf} "\t%s\n\n" "\$(CGAL_LDFLAGS)" >> ${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/lib directory settings" \
>> ${FILE}
${_printf} "%s\n" "CGAL_INCL_DIR = `filename_for_compiler ${CGAL_INCL_DIR}`" \
>> ${FILE}
${_printf} "%s\n" "CGAL_LIB_DIR = `filename_for_compiler ${CGAL_LIB_DIR}`" \
>> ${FILE}
#
# CGAL_OS_COMPILER
#
makefile_header "os/compiler description" \
>> ${FILE}
${_printf} "%s\n" "CGAL_OS_COMPILER = `full_ostype`" >> ${FILE}
#
# filename specific stuff
#
makefile_header "filename related flags" >> ${FILE}
${_printf} "%s\n" "OBJ_EXT = ${OBJ_EXT}" >> ${FILE}
${_printf} "%s\n" "EXE_EXT = ${EXE_EXT}" >> ${FILE}
${_printf} "%s\n" "LIB_SUFFIX = ${LIB_SUFFIX}" >> ${FILE}
#
# some specific compiler flags
#
makefile_header "some specific compiler flags" >> ${FILE}
${_printf} "%s\n" "OBJ_OPT = ${OBJ_OPT}" >> ${FILE}
${_printf} "%s\n" "DEBUG_OPT = ${DEBUG_OPT}" >> ${FILE}
${_printf} "%s\n" "START_LD_OPT = ${START_LD_OPT}" >> ${FILE}
${_printf} "%s\n" "LIBPATH_OPT = ${LIBPATH_OPT}" >> ${FILE}
${_printf} "%s\n" "LIB_OPT = ${LIB_OPT}" >> ${FILE}
${_printf} "%s\n" "RANLIB = ${RANLIB}" >> ${FILE}
#
# suffixes and rules
#
makefile_header "suffixes and rules" >> ${FILE}
${_printf} "%s\n" ".SUFFIXES: ${SUFFIX_LIST} .clean" >> ${FILE}
if [ -n "${EXE_EXT}" ]; then
case ${CGAL_OS_COMPILER} in
*CYGWIN*g++*) ${_printf} "\n.o:\n" >> ${FILE};;
*) ${_printf} "\n.C:\n" >> ${FILE};;
esac
${_printf} "\t%s %s%s\n" "\$(MAKE)" '$*' "${EXE_EXT}" >> ${FILE}
fi
${_printf} "\n.C.clean:\n" >> ${FILE}
${_printf} "\trm -f \$*%s" "${EXE_EXT}" >> ${FILE}
if [ -n "${REMOVE_EXT_LIST}" ]; then
for extension in ${REMOVE_EXT_LIST}
do
${_printf} " \$*%s" "${extension}" >> ${FILE}
done
fi
case ${CGAL_OS_COMPILER} in
mips_IRIX*-6*_CC-*32-*)
${_printf} " ii_files/\$*.ii*\n" >> ${FILE};;
*)
${_printf} "\n" >> ${FILE};;
esac
${_printf} "\n" >> ${FILE}
#
# CGAL_CXX
#
makefile_header "compiler" >> ${FILE}
${_printf} "%s\n" "CGAL_CXX = `quote ${CGAL_CXX}`" >> ${FILE}
write_compiler_flags
write_linker_flags
makefile_header "commands and flags for creating libraries" \
>> ${FILE}
#
# CGAL_(WIN)LIB
#
${_printf} "%s\n" "CGAL_LIB = ${CGAL_LIBNAME}" >> ${FILE}
${_printf} "%s\n" "CGAL_WIN_EXTRA_DIR = ${CGAL_WIN_EXTRA_DIR}" >> ${FILE}
${_printf} "%s\n" "CGAL_QT_LIB = ${CGAL_QT_LIBNAME}" >> ${FILE}
${_printf} "%s\n" "CGAL_CORE_LIB = ${CORE_LIBNAME}" >> ${FILE}
#
# CGAL_LIB_CXXFLAGS
#
${_printf} "%s\\\\\n" "CGAL_LIB_CXXFLAGS = " >> ${FILE}
makefile_print_line "${CGAL_LIB_CXXFLAGS} -O2" >> ${FILE}
${_printf} "\t%s\n" "\$(CGAL_CXXFLAGS)" >> ${FILE}
#
# CGAL_LIB_LDFLAGS
#
${_printf} "%s\n\n" "CGAL_LIB_LDFLAGS = ${CGAL_LIB_LDFLAGS}" >> ${FILE}
#
# CGAL_LIB_CREATE
#
${_printf} "%s\n" "CGAL_LIB_CREATE = ${CGAL_LIB_CREATE}" >> ${FILE}
${_printf} "%s\n" "CGAL_OBJ_PREFIX = ${CGAL_OBJ_PREFIX}" >> ${FILE}
${_printf} "%s\n" "CGAL_LIB_DESTINATION = \$(CGAL_LIB_DIR)/\$(CGAL_OS_COMPILER)" >> ${FILE}
#
# CGAL_SHARED_LIB
#
${_printf} "%s\n" "CGAL_SHARED_LIB = libCGAL${SHARED_LIB_EXT}" >> ${FILE}
#
# CGAL_SHARED_LIB_CXXFLAGS
#
${_printf} "%s\\\\\n" "CGAL_SHARED_LIB_CXXFLAGS = " >> ${FILE}
makefile_print_line "${CGAL_SHARED_LIB_CXXFLAGS} -O2" >> ${FILE}
${_printf} "\t%s\n" "\$(CGAL_CXXFLAGS)" >> ${FILE}
#
# CGAL_SHARED_LIB_LDFLAGS
#
${_printf} "%s\n" \
"CGAL_SHARED_LIB_LDFLAGS = ${CGAL_SHARED_LIB_LDFLAGS}" >> ${FILE}
${_printf} "%s\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 <file> <string> <replacement>
# replaces all the lines in <file> that start with <string>
# with <replacement>
#--------------------------------------------------------------------#
replace_line()
{
if [ ! -f $1 ] ; then
${_printf} "%s\n" "Error: could not open file $1 in replace_line()"
return
fi
if eval '${_sed} "\\^$2c\\
$3${_EXTRA_NEWLINE}" $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
do
replace_line ${FILE} CGAL_MAKEFILE \
"CGAL_MAKEFILE = ${CGAL_MAKEFILE}"
done
if [ -d ${CGAL_SRC_DIR}/Core ]; then
replace_line ${CGAL_SRC_DIR}/Core/makefile \
CGAL_MAKEFILE "CGAL_MAKEFILE = ${CGAL_MAKEFILE}"
fi
if [ -d ${CGAL_SRC_DIR}/CGALQt ]; then
replace_line ${CGAL_SRC_DIR}/CGALQt/makefile \
CGAL_MAKEFILE "CGAL_MAKEFILE = ${CGAL_MAKEFILE}"
fi
}
# log via $1
generatemakefiles()
{
_check_dir_exists ${CGAL_MAKE_DIR}
_check_write ${CGAL_MAKE_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 "${INTERNAL_RELEASE}" ]; then
for FILE in `${_ls} ${CGAL_TEST_DIR}/*/makefile`; do
replace_line ${FILE} CGAL_MAKEFILE \
"CGAL_MAKEFILE = ${CGAL_MAKEFILE}"
done
fi
}
# compile $1 (= lib, sharedlib, or Win)
# 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
${_rm} -f *${OBJ_EXT}
MAKE_OPTION="-k"
if [ -n "${INTERNAL_RELEASE}" -a "$1" != "sharedlib" ]; then
MAKE_OPTION="-i"
fi
# Check if there is a special makefile file
if [ -f makefile_$1 ]; then
MAKE_OPTION="${MAKE_OPTION} -f makefile_$1"
fi
if make ${MAKE_OPTION} >${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}`
CGAL_MAKEFILE=${CGAL_MAKE_DIR}/makefile_${_libname}
}
# create appropriate dirs and makefiles
make_makefiles()
{
# generate directoryfile and makefile:
${_printf} "%s" "${_LEFTSPACE}Generating Makefiles ..."
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}
if [ -n "${ENABLE_SHARED}" ]; then
case ${CGAL_OS_COMPILER} in
*CYGWIN*)
${_printf} "%s\n" \
"${_LEFTSPACE}No shared libraries on this platform!"
;;
*) if _do_compile sharedlib; then
${_rm} -f ${CGAL_DIR}/.upgrade-tag
fi
;;
esac
fi
if [ -n "${QT_SUPPORT}" -a -d ${CGAL_SRC_DIR}/CGALQt ]; then
cd ${CGAL_SRC_DIR}/CGALQt
_do_compile Qt
fi
if [ -n "${CORE_SUPPORT}" -a -d ${CGAL_SRC_DIR}/Core ]; then
cd ${CGAL_SRC_DIR}/Core
_do_compile Core
fi
fi
write_buffer "\n"
print_filled_line
wait_for_enter
cd ${CGAL_DIR}
}
lib_menu()
{
if [ -n "${SETUP_COMPLETE}" ]; then
write_menu_information "Compiling"
make_lib_dir
make_makefiles
build_cgal
else
log_print "The setup tests failed."
log_print "Therefore, no CGAL library is compiled."
${_printf} "\n%s\n%s\n\n" \
"${_LEFTSPACE}Error: Setup tests failed." \
"${_LEFTSPACE} Please correct your setup."
print_filled_line
wait_for_enter
fi
}
print_lib_information()
{
if [ -r ${CGAL_LIB_DIR}/`full_ostype`/${CGAL_LIBNAME} ]; then
print_line "Libs built: `_get_timestamp ${CGAL_LIB_DIR}/\`full_ostype\`/${CGAL_LIBNAME}`"
else
print_line "There are no libs for this os/compiler."
fi
}
installation()
{
write_menu_information "Installing"
if [ "${CGAL_DIR}" = "${CGAL_INSTALL_DIR}" ]; then
log_print "CGAL_DIR == CGAL_INSTALL_DIR, hence no installation."
${_printf} "\n%s\n\n" \
"${_LEFTSPACE}Remark: No need to install, as CGAL_DIR == CGAL_INSTALL_DIR."
print_filled_line
wait_for_enter
return 1
fi
print_filled_line
print_empty_line
print_empty_line
print_empty_line
print_empty_line
print_filled_line
go_up_lines 4
print_line "Target Directory: ${CGAL_INSTALL_DIR}."
if [ -n "${INSTALL_INTERACTIVE}" ]; then
print_prompt "Do you want to install CGAL into this directory (y/N)? "
_read
if [ "${KEY}" != 'y' ]; then
return
fi
fi
# ok, go ahead...
go_down_lines 3; flush_buffer
_check_dir_exists_create ${CGAL_INSTALL_DIR}
# this sets $CGAL_MAKEFILE:
make_lib_dir
# install header files
_CGAL_IDIR="${CGAL_INSTALL_DIR}/include"
_check_dir_exists_create "${_CGAL_IDIR}"
_do_command \
"cd ${CGAL_INCL_DIR}; ${_tar} cf - . | (cd ${_CGAL_IDIR}; ${_tar} xf -)" \
"Install CGAL headers"
# install libraries
_CGAL_IDIR="${CGAL_INSTALL_DIR}/lib/`full_ostype`"
_check_dir_exists_create "${_CGAL_IDIR}"
_do_command \
"cd ${CGAL_LIB_DIR}/`full_ostype`; ${_tar} cf - . | (cd ${_CGAL_IDIR}; ${_tar} xf -)" \
"Install CGAL libraries"
# install binaries
_CGAL_IDIR="${CGAL_INSTALL_DIR}/bin"
_check_dir_exists_create "${_CGAL_IDIR}"
_do_command \
"cd ${CGAL_DIR}/scripts; ${_tar} cf - . | (cd ${_CGAL_IDIR}; ${_tar} xf -)" \
"Install CGAL programs"
# install makefile
_CGAL_IDIR="${CGAL_INSTALL_DIR}/make"
_check_dir_exists_create "${_CGAL_IDIR}"
CGAL_INSTALL_MAKEFILE="${_CGAL_IDIR}/`${_basename} \"${CGAL_MAKEFILE}\"`"
_do_command \
"(${_sed} \"s${CGAL_DIR}${CGAL_INSTALL_DIR}g\" \"${CGAL_MAKEFILE}\" >${CGAL_INSTALL_MAKEFILE})" \
"Install CGAL Makefile"
write_buffer "\n"
print_filled_line
wait_for_enter
cd ${CGAL_DIR}
}
install_menu()
{
set_lib_compiled_flag
if [ -z "${LIB_COMPILED}" ]; then
log_print "CGAL library not found, hence no installation."
${_printf} "\n%s\n%s\n\n" \
"${_LEFTSPACE}Error: Could not find any CGAL library for this OS/compiler." \
"${_LEFTSPACE} You have to build the CGAL library first."
print_filled_line
wait_for_enter
return 1
fi
while [ 0 ]; do
menu_header 'Install'
print_lib_information
print_empty_line
print_line "${_bold_on}<D>${_bold_off} Change Installation root directory"
print_multi_line "${CGAL_INSTALL_DIR}"
print_line "${_bold_on}<I>${_bold_off} Install CGAL"
menu_tailer 'Main Menu'
case ${KEY} in
d|D)
OLD_INSTALL_DIR="${CGAL_INSTALL_DIR}"
change_value CGAL_INSTALL_DIR
;;
i|I)
installation
;;
q|Q|b|B)
return
;;
esac
done
}
# ---------------------------------------------------------------------
# $1 is the full name of a config file in config/install/*
# (re)build one function
#
_build_one()
{
INSTALL_LOGFILE_REDIRECTION="|print_with_indent | ${_tee} -a ${INSTALL_LOGFILE}"
log_print
log_print \
"--------------------------------------------------------"
log_print "Build on `${_basename} $1`:"
log_print \
"--------------------------------------------------------"
INSTALL_LOGFILE_REDIRECTION=">>${INSTALL_LOGFILE}"
try_to_get_var_from_file COMPILER $1
if [ -n "${COMPILER}" ]; then
CUSTOM_OSTYPE_TAG="`custom_ostype_tag`"
set_ostype
set_compiler_flags
# do transition from old config files (where the OS part was very verbose)
if [ ! -r "${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}" ]; then
NEW_SYST="${SYST}"
old_guess_os
SYST="${OLD_SYST}"
set_ostype
OLD_LIBDIR="${CGAL_LIB_DIR}/`full_ostype`"
retrieve_compiler_settings
# rename old config file to not match os in the future
${_mv} "${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}" \
"${CGAL_INSTALL_CONF_DIR}/old_${CGAL_OS_COMPILER}"
SYST="${NEW_SYST}"
set_ostype
else
retrieve_compiler_settings
fi
case ${_WHAT_TO_DO} in
*rebuild*) reset_all_test_variables
test_setup;;
esac
lib_menu
installation
else
log_print "Cannot rebuild the library."
print_filled_line
print_empty_line
print_headline "Cannot build on `${_basename} $1` !"
print_headline "No COMPILER defined in config/install/..."
print_filled_line
write_buffer "\n"
flush_buffer
fi
}
# ---------------------------------------------------------------------
# (re)build one function
#
build_one()
{
guess_os log_print
case ${SYST} in
*CYGWIN*) _check_for_sysutil cygpath y;;
esac
${_printf} "\n\n"
_build_one config/install/${BUILD_ONE_CONFIG}
}
# ---------------------------------------------------------------------
# (re)build all function
#
build_all()
{
guess_os log_print
case ${SYST} in
*CYGWIN*) _check_for_sysutil cygpath y;;
esac
${_printf} "\n\n"
for i in `${_ls} ${CGAL_INSTALL_CONF_DIR}/${SYST}* 2>/dev/null`
do
_build_one $i
done
}
# ---------------------------------------------------------------------
# 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
}
# ---------------------------------------------------------------------
# upgrade menu
#
upgrade()
{
_check_read ${UPGRADE_FROM}
_check_execute ${UPGRADE_FROM}
# copy config install files
write_buffer "\n"
print_filled_line
print_headline "Upgrading from ${UPGRADE_FROM}"
print_filled_line
print_line "copying config install files"
print_filled_line
flush_buffer
log_print "copy config install files ... "
#for i in ${UPGRADE_FROM}/config/install/*; do
# # check for old format
# case "`awk 'BEGIN{FS=\".\"}/install_cgal/{print $0}' $i`"
#done
${_cp} -r ${UPGRADE_FROM}/config/install ${CGAL_DIR}/config
log_print "done."
# copy gmp header and libs
if [ -r "${UPGRADE_FROM}/include/gmp.h" ]; then
print_filled_line
print_line "!!! ATTENTION !!!"
print_line "You seem to have GMP installed in the CGAL directories."
print_line "This setup is no longer supported."
print_line "Please install gmp separately from CGAL."
print_filled_line
log_print "Error: GMP installation in CGAL directories is no longer supported."
log_print " You have to re-configure GMP support manually."
fi
print_headline "D O N E"
go_up_lines 1
print_filled_line
flush_buffer
log_print "done."
}
upgrade_menu()
{
# try to find old CGAL directories first
for try in ${CGAL_DIR}/../CGAL-2.* ${CGAL_DIR}/../CGAL-1.*; do
if [ -d "${try}" -a -r "${try}" -a -x "${try}" ]; then
UPGRADE_FROM="`cd ${try}; pwd`"
fi
done
while [ 0 ]; do
clear_screen
print_filled_line
print_headline "CGAL $CGAL_VERSION Installation Upgrade Menu"
print_line "OS: ${SYST}"
print_empty_line
print_line "${_bold_on}<U>${_bold_off} Upgrade from an existing CGAL Installation"
print_line " in ${UPGRADE_FROM:-<undefined>}"
print_line "${_bold_on}<D>${_bold_off} Change directory for upgrade"
menu_tailer 'Main Menu'
case ${KEY} in
u|U) if [ -n "${UPGRADE_FROM}" ]; then
print_empty_line
upgrade
_WHAT_TO_DO=rebuild-all
go_up_lines 2
flush_buffer
build_all
${_rm} -f ${CGAL_DIR}/.upgrade-tag
return
fi
;;
d|D) change_dir UPGRADE_FROM dir;;
q|Q) return;;
esac
done
}
# ---------------------------------------------------------------------
# support menu
#
support_menu()
{
while [ 0 ]; do
menu_header 'Support'
print_line "${_bold_on}<G>${_bold_off} GMP Menu"
print_line "${_bold_on}<C>${_bold_off} CORE Menu"
print_line "${_bold_on}<L>${_bold_off} LEDA Menu"
print_line "${_bold_on}<K>${_bold_off} Qt Menu"
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
menu_tailer 'Main Menu'
case $KEY in
g|G) gmp_menu;;
c|C) core_menu;;
l|L) leda_menu;;
k|K) qt_menu;;
t|T) go_down_lines 3
flush_buffer
test_setup;;
q|Q) return;;
esac
done
}
# ---------------------------------------------------------------------
# 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'
print_lib_information
print_empty_line
print_line "${_bold_on}<C>${_bold_off} Compiler Menu"
print_line "${_bold_on}<S>${_bold_off} Support Menu"
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
print_line "${_bold_on}<A>${_bold_off} Run all setup tests (no cache)"
print_empty_line
print_line "${_bold_on}<B>${_bold_off} Build CGAL Libraries"
print_line "${_bold_on}<I>${_bold_off} Install CGAL Libraries"
if [ -n "${INTERNAL_RELEASE}" -a -n "${LIB_COMPILED}" ]; then
print_line "${_bold_on}<R>${_bold_off} Run CGAL testsuite"
fi
if [ -f ${CGAL_DIR}/.upgrade-tag ]; then
print_line "${_bold_on}<U>${_bold_off} Upgrade from an existing CGAL installation"
fi
menu_tailer 'OS'
case $KEY in
c|C) compiler_menu;;
s|S) support_menu;;
i|I) install_menu;;
b|B)
if [ -z "${SETUP_COMPLETE}" ]; then
test_setup
fi
lib_menu
;;
u|U)
if [ -f ${CGAL_DIR}/.upgrade-tag ]; then
upgrade_menu
fi
;;
a|A)
reset_all_test_variables
go_down_lines 3
flush_buffer
if [ -n "${LEDA_SUPPORT}" ]; then
test_LEDA "notused" "${INSTALL_VERBOSE}"
fi
if [ -n "${GMP_SUPPORT}" ]; then
search_gmp "${INSTALL_VERBOSE}"
fi
if [ -n "${QT_SUPPORT}" ]; then
test_for_qt_dir "${INSTALL_VERBOSE}"
test_for_qt_moc_in_path "${INSTALL_VERBOSE}"
if [ -z "${WINDOWS_COMPILER}" ]; then
test_for_qt_incl_in_sys_incl "${INSTALL_VERBOSE}"
test_for_qt_lib_in_sys_lib "${INSTALL_VERBOSE}"
fi
fi
test_setup;;
t|T)
go_down_lines 3
flush_buffer
test_setup;;
r|R)
if [ -n "${INTERNAL_RELEASE}" -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
if [ -z "${CYGWIN_COMPILER}" ]; then
_check_execute "${1}"
else
_check_execute "${*}"
fi
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()
{
${_printf} "%s\n" " one moment, please"
if [ -n "${_ANY_OPT}" -a -n "${INSTALL_INTERACTIVE}" ]; then
${_printf} "\n%s\n" \
"WARNING: In interactive mode all command line options"
${_printf} "%s\n\n" \
" except for \"-i\", \"--prefix\", and \"--CGAL_DIR\" are ignored."
clear_buffer
fi
init_logfiles
if [ -n "${INSTALL_INTERACTIVE}" ]; then
${_printf} "."
INSTALL_LOGFILE_REDIRECTION=">>${INSTALL_LOGFILE}"
else
INSTALL_LOGFILE_REDIRECTION="| print_with_indent"
fi
check_for_utils
if [ -n "${INSTALL_INTERACTIVE}" ]; then ${_printf} "."; fi
check_conf_dir
if [ -n "${INSTALL_INTERACTIVE}" ]; then ${_printf} "."; fi
set_expr
if [ -n "${INSTALL_INTERACTIVE}" ]; then ${_printf} "."; fi
set_menu_lines
if [ -n "${INSTALL_INTERACTIVE}" ]; then
${_printf} "."
set_terminal_variables
${_printf} "."
fi
}
finish()
{
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 "${CGAL_INSTALL_CGAL} 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
#write_buffer "\nCGAL_LIB_DIR is\n${CGAL_LIB_DIR}/`full_ostype`\n"
write_buffer "\nRemember to set the CGAL_MAKEFILE environment variable, "
if [ -n "${CGAL_INSTALL_MAKEFILE}" ]; then
write_buffer "e.g., to\n${CGAL_INSTALL_MAKEFILE}\n\n"
else
write_buffer "e.g., to\n${CGAL_MAKEFILE}\n\n"
fi
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
elif [ -n "$3" ]; then
eval "$1=\"$3\""
write_buffer "${_LEFTSPACE}Set $1 to \"`value_of $1`\".\n"
return 0
else
exit_on_error "Argument \"${1}\" expected"
fi
}
_WHAT_TO_DO=''
_CONFLICT=''
_ANY_OPT=''
_awk=awk
_sed=sed
_tr=tr
_printf=printf
_rm=rm
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
;;
--prefix*|--PREFIX*|-prefix*|-PREFIX*)
if set_variable_from_command_line 'CGAL_INSTALL_DIR' "$1" "$2"; then
shift
fi
;;
--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_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'
;;
--core_incl_dir*|--CORE_INCL_DIR*|-CORE_INCL_DIR*|-core_incl_dir*)
_ANY_OPT='y'
if set_variable_from_command_line 'CORE_INCL_DIR' "$1" "$2"; then
shift
fi
CORE_INSTALLATION='e'
;;
--core_lib_dir*|--CORE_LIB_DIR*|-CORE_LIB_DIR*|-core_lib_dir*)
_ANY_OPT='y'
if set_variable_from_command_line 'CORE_LIB_DIR' "$1" "$2"; then
shift
fi
CORE_INSTALLATION='e'
;;
--qt_incl_dir*|--QT_INCL_DIR*|-qt_incl_dir*|-QT_INCL_DIR*)
_ANY_OPT='y'
if set_variable_from_command_line 'QT_INCL_DIR' "$1" "$2"; then
QT_ADVANCED_MODE='y'
shift
fi
;;
--qt_dir*|--QT_DIR*|-qt_dir*|-QT_DIR*)
_ANY_OPT='y'
if set_variable_from_command_line 'QT_DIR' "$1" "$2"; then
shift
fi
qt_dir_has_changed
;;
--qt_lib_dir*|--QT_LIB_DIR*|-qt_lib_dir*|-QT_LIB_DIR*)
_ANY_OPT='y'
if set_variable_from_command_line 'QT_LIB_DIR' "$1" "$2"; then
QT_ADVANCED_MODE='y'
shift
fi
;;
--qt_moc*|--QT_MOC*|-qt_moc*|-QT_MOC*)
_ANY_OPT='y'
if set_variable_from_command_line 'QT_MOC' "$1" "$2"; then
QT_ADVANCED_MODE='y'
shift
fi
;;
-qt_mt*|-QT_MT*|--qt_mt*|--QT_MT*)
_ANY_OPT='y'
QT_T_SUPPORT='y'
write_buffer "${_LEFTSPACE}Enable Qt Thread support.\n"
;;
-qt*|-QT*|--qt*|--QT*)
_ANY_OPT='y'
QT_SUPPORT='_QT'
write_buffer "${_LEFTSPACE}Enable Qt support.\n"
;;
--cxxflags*|--CXXFLAGS*|-CXXFLAGS*|-cxxflags*|--custom_cxxflags*|--CUSTOM_CXXFLAGS*|-CUSTOM_CXXFLAGS*|-custom_cxxflags*)
_ANY_OPT='y'
if set_variable_from_command_line 'CUSTOM_CXXFLAGS' "$1" "$2"; then
shift
fi
;;
--ldflags*|--LDFLAGS*|-LDFLAGS*|-ldflags*|--custom_ldflags*|--CUSTOM_LDFLAGS*|-CUSTOM_LDFLAGS*|-custom_ldflags*)
_ANY_OPT='y'
if set_variable_from_command_line 'CUSTOM_LDFLAGS' "$1" "$2"; then
shift
fi
;;
--ostype_tag*|--OSTYPE_TAG*|-ostype_tag*|-OSTYPE_TAG*|--custom_ostype_tag*|--CUSTOM_OSTYPE_TAG*|-custom_ostype_tag*|-CUSTOM_OSTYPE_TAG*)
_ANY_OPT='y'
if set_variable_from_command_line 'CUSTOM_OSTYPE_TAG' "$1" "$2"; then
shift
fi
check_CUSTOM_OSTYPE_TAG
;;
-LEDA*|-leda*|--leda*|--LEDA*)
_ANY_OPT='y'
LEDA_SUPPORT='_LEDA'
write_buffer "${_LEFTSPACE}Enable LEDA support.\n"
;;
-gmpxx*|-GMPXX*|--gmpxx*|--GMPXX*)
_ANY_OPT='y'
GMP_SUPPORT='_GMP'
GMPXX_SUPPORT='_GMPXX'
write_buffer "${_LEFTSPACE}Enable GMP C++ interface support.\n"
;;
-gmp*|-GMP*|--gmp*|--GMP*)
_ANY_OPT='y'
GMP_SUPPORT='_GMP'
write_buffer "${_LEFTSPACE}Enable GMP support.\n"
;;
-core*|-CORE*|--core*|--CORE*)
_ANY_OPT='y'
CORE_SUPPORT='_CORE'
if [ -z "${CORE_INSTALLATION}" ]; then
CORE_INSTALLATION='c'
fi
write_buffer "${_LEFTSPACE}Enable CORE 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'
;;
--upgrade*|-u*|-U*)
if [ -n "${_WHAT_TO_DO}" ]; then
_CONFLICT='y'
fi
if set_variable_from_command_line 'UPGRADE_FROM' "$1" "$2"; then
shift
fi
_WHAT_TO_DO='upgrade'
;;
--verbose*|-verbose*)
INSTALL_VERBOSE='y'
;;
*--version*|-V*|-v*)
# version
${_printf} "%s\n" "${CGAL_INSTALL_CGAL} 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'
;;
--rebuild*|-r*|-R*|-rb*|-RB*)
if [ -n "${_WHAT_TO_DO}" ]; then
_CONFLICT='y'
fi
_WHAT_TO_DO='rebuild'
BUILD_ONE_CONFIG=$2
shift
;;
--build*|-b*|-B*)
if [ -n "${_WHAT_TO_DO}" ]; then
_CONFLICT='y'
fi
_WHAT_TO_DO='build'
BUILD_ONE_CONFIG=$2
shift
;;
--disable-shared*)
ENABLE_SHARED=''
;;
*)
_WHAT_TO_DO='help'
;;
esac
shift
done
if [ -n "${QT_SUPPORT}" -a -z "${QT_ADVANCED_MODE}" -a -z "${QT_DIR}" ]; then
if [ -n "${QTDIR}" ]; then
QT_DIR=${QTDIR}
qt_dir_has_changed
write_buffer "remark: QT_DIR has been set to \$QTDIR (${QTDIR})"
else
write_buffer "WARNING: --QT_DIR not set whereas Qt support enable.\n"
fi
fi
if [ -n "${_CONFLICT}" ]; then
_WHAT_TO_DO='help'
fi
if [ -z "${CGAL_INSTALL_DIR}" ]; then
CGAL_INSTALL_DIR="${CGAL_DIR}"
fi
case ${_WHAT_TO_DO} in
*non-interactive*)
get_cgal_version
cgal_install_header
${_printf} "%s\n" "running non interactive mode ..."
INSTALL_INTERACTIVE=''
${_printf} "\n%s\n" \
"--------------------------------------------------------"
${_printf} "%s\n" "Locating Utilities:"
${_printf} "%s\n" \
"--------------------------------------------------------"
startup
check_conf_dir
guess_os 'print_with_indent'
case ${SYST} in
*CYGWIN*) _check_for_sysutil cygpath y;;
esac
${_printf} "\n%s\n" \
"--------------------------------------------------------"
${_printf} "%s\n" "Settings from Command Line:"
${_printf} "%s\n" \
"--------------------------------------------------------"
flush_buffer
_check_comp_executable "${COMPILER}"
INSTALL_LOGFILE_REDIRECTION=">>${INSTALL_LOGFILE}"
COMPILER="`compiler_absolute ${COMPILER}`"
INSTALL_LOGFILE_REDIRECTION='|print_with_indent'
set_ostype
set_compiler_flags
flush_buffer
INSTALL_LOGFILE_REDIRECTION=">>${INSTALL_LOGFILE}"
test_setup
lib_menu
installation
finish
;;
*upgrade*)
get_cgal_version
cgal_install_header
${_printf} "%s" "starting ${_WHAT_TO_DO} -"
startup
guess_os log_print
upgrade
finish
;;
*interactive*)
get_cgal_version
cgal_install_header
# start interactive part
${_printf} "%s" "starting interactive mode -"
INSTALL_INTERACTIVE='y'
startup
search_for_compilers
main_menu
finish
;;
*ostype*)
# architecture/os key
_uname=uname
_basename=basename
_dirname=dirname
_which=real_which
_sed=sed
_tr=tr
_cat=cat
_tee=tee
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*)
get_cgal_version
cgal_install_header
${_printf} "%s" "starting ${_WHAT_TO_DO} -"
startup
build_all
finish
;;
*build*)
get_cgal_version
cgal_install_header
${_printf} "%s" "starting ${_WHAT_TO_DO} -"
startup
build_one
finish
;;
*help*)
get_cgal_version
cgal_install_header
print_usage_information
;;
*)
get_cgal_version
cgal_install_header
print_general_information
;;
esac
exit 0
Reference in New Issue View Git Blame Copy Permalink