mirror of https://github.com/CGAL/cgal
5233 lines
148 KiB
Bash
Executable File
5233 lines
148 KiB
Bash
Executable File
#!/bin/sh
|
||
# ---------------------------------------------------------------------
|
||
# The CGAL Installation Script
|
||
# ---------------------------------------------------------------------
|
||
# $Id$
|
||
# ---------------------------------------------------------------------
|
||
#
|
||
# Copyright (c) 1997-2006 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$
|
||
# $Date$
|
||
#
|
||
# Author(s): Michael Hoffmann
|
||
|
||
|
||
# ---------------------------------------------------------------------
|
||
# some important global variables
|
||
# ---------------------------------------------------------------------
|
||
|
||
# ---------------------------------------------
|
||
# CGAL specific:
|
||
|
||
# ---------------------------------------------
|
||
CGAL_VERSION="version_to_be_determined"
|
||
# ---------------------------------------------
|
||
CGAL_INSTALL_CGAL="`basename \"${0}\"`"
|
||
# ---------------------------------------------
|
||
CGAL_INSTALL_VERSION='$Revision$'
|
||
# ---------------------------------------------
|
||
CGAL_DIR="`pwd`"
|
||
# ---------------------------------------------
|
||
CGAL_INSTALL_DIR=''
|
||
|
||
# ---------------------------------------------
|
||
# set to non-empty, if you want to view the logs of
|
||
# ALL failed tests
|
||
INSTALL_VERBOSE=''
|
||
|
||
# ---------------------------------------------
|
||
# try to autofind as many 3rd party libraries as possible.
|
||
# Set to empty, if you want to disable autofinding.
|
||
CGAL_AUTOFIND_PKGS=y
|
||
|
||
# ---------------------------------------------
|
||
# prefix of CGAL compiler specific configuration flags
|
||
CGAL_CONFIG_PREFIX='CGAL_CFG_'
|
||
|
||
# ---------------------------------------------
|
||
# 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'
|
||
|
||
# ---------------------------------------------
|
||
# indicate whether there is a "long name problem" on the current platform
|
||
LONG_NAME_PROBLEM=''
|
||
|
||
# ---------------------------------------------
|
||
# Support for 3rd party Libraries: (feature tags)
|
||
SUPPORT_FEATURES=''
|
||
|
||
# ---------------------------------------------
|
||
# Support for 3rd party Libraries: (package tags)
|
||
SUPPORT_PKGS=''
|
||
# reverse list
|
||
R_SUPPORT_PKGS=''
|
||
|
||
# ---------------------------------------------
|
||
# Required support options
|
||
SUPPORT_REQUIRED='BOOST'
|
||
|
||
# ---------------------------------------------------------------------
|
||
# 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" \
|
||
"Usage: ${CGAL_INSTALL_CGAL}
|
||
[--help | --version | -i | --interactive |
|
||
-u <dir> | --upgrade <dir> | --build-all | --rebuild-all |
|
||
--build <config> | --rebuild <config> | --disable-shared |
|
||
-ni | --non-interactive | -os]
|
||
[--verbose]
|
||
[--without-autofind]
|
||
[--prefix <dir>]
|
||
[--CGAL_DIR <dir>]
|
||
[--CXX <comp>] [--CXXFLAGS <flags>] [--LDFLAGS <flags>]
|
||
[--ostype_tag <tag>]"
|
||
for i in ${SUPPORT_PKGS}; do
|
||
${_printf} " [--with-%s]\n" "$i"
|
||
done
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
${_printf} " [--%s_INCL_DIR <dir>] [--%s_LIB_DIR <dir>]\n" "$i" "$i"
|
||
done
|
||
${_printf} "\n%s\n" \
|
||
" --help gives this message.
|
||
--version prints ${CGAL_INSTALL_CGAL} version number.
|
||
--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 are copied from there.
|
||
--build-all
|
||
builds libraries for all compilers for which a
|
||
config/install file exists.
|
||
--rebuild-all
|
||
(re)builds compiler configuration files and libraries
|
||
for all compilers for which a config/install file
|
||
exists.
|
||
--build <config>
|
||
builds libraries for the compiler specified by its
|
||
configuration file config/install/<config>.
|
||
--rebuild <config>
|
||
(re)builds the compiler configuration file and libraries
|
||
for the compiler specified by its configuration file
|
||
config/install/<config>.
|
||
--non-interactive or -ni
|
||
runs the script in non-interactive mode.
|
||
-os prints architecture/os/compiler specifications.
|
||
--verbose Give report for each test that fails
|
||
(not generally recommended).
|
||
--CGAL_DIR <dir>
|
||
Specify an explicit path to use for the CGAL directory.
|
||
--prefix <dir>
|
||
Specify an installation directory.
|
||
--without-autofind
|
||
Do not enable support for 3rd party libraries, unless
|
||
specified explicitly.
|
||
--disable-shared
|
||
Do not build shared libraries, only the static archives.
|
||
--CXX <comp> Use <comp> as a C++ compiler.
|
||
--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
|
||
}
|
||
|
||
warn_deprecated()
|
||
{
|
||
${_printf} "\n%s\n" "Warning: Option ${1} is deprecated and ignored."
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# 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 }'
|
||
}
|
||
|
||
# log_print writes to logfile only
|
||
log_to_file()
|
||
{
|
||
INSTALL_LOGFILE_REDIRECTION=">>\"${INSTALL_LOGFILE}\""
|
||
}
|
||
|
||
# log_print writes to screen only
|
||
log_to_screen()
|
||
{
|
||
INSTALL_LOGFILE_REDIRECTION="| print_with_indent"
|
||
}
|
||
|
||
# log_print writes to both logfile and screen
|
||
log_to_file_and_screen()
|
||
{
|
||
INSTALL_LOGFILE_REDIRECTION="|print_with_indent | ${_tee} -a \"${INSTALL_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}" "${TMPTMP_LOGFILE}" "${TMP_CXX_FILE}" "${INSTALL_LOGFILE}"; do
|
||
if [ -f "${i}" ]; then
|
||
${_rm} -f "${i}"
|
||
fi
|
||
done
|
||
# set SUPPORT_FEATURES and SUPPORT_PKGS
|
||
|
||
# first cleanup
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
eval "SUPPORT_PKG_${i}=''"
|
||
eval "PROVIDE_PKG_${i}=''"
|
||
done
|
||
SUPPORT_FEATURES=''
|
||
SUPPORT_PKGS=''
|
||
R_SUPPORT_PKGS=''
|
||
|
||
log_to_file_and_screen
|
||
_no_indent
|
||
log_print "Parsing support specfiles for 3rd party libraries:"
|
||
_set_indent
|
||
log_to_file
|
||
for i in "${CGAL_SUPPORT_DIR}"/S*; do
|
||
_tmp="`echo $i | ${_awk} 'BEGIN {FS=\"-\"} {print $NF}' | remove_special_chars | ${_tr} [:lower:] [:upper:]`"
|
||
if [ -z "${_tmp}" ]; then continue; fi
|
||
SUPPORT_PKGS="${SUPPORT_PKGS} ${_tmp}"
|
||
R_SUPPORT_PKGS="${_tmp} ${R_SUPPORT_PKGS}"
|
||
log_print "${_tmp}"
|
||
${_printf} "%s" "${_tmp}, "
|
||
try_to_get_var_from_file PROVIDES "${i}"
|
||
if [ -z "${PROVIDES}" ]; then continue; fi
|
||
eval "${_tmp}_PROVIDES=\"${PROVIDES}\""
|
||
# is PROVIDES already among SUPPORT_FEATURES?
|
||
for j in ${PROVIDES}; do
|
||
if [ -z "`value_of \"SUPPORT_PKG_${j}\"`" ]; then
|
||
SUPPORT_FEATURES="${SUPPORT_FEATURES} ${j}"
|
||
eval "PROVIDE_PKG_${j}=''"
|
||
eval "${j}_INCL_DIR=''"
|
||
eval "${j}_LIB_DIR=''"
|
||
eval "${j}_VERSION=''"
|
||
fi
|
||
_append_to "SUPPORT_PKG_${j}" "${_tmp}" " "
|
||
done
|
||
|
||
# generate set of variables corresponding to $_tmp
|
||
|
||
# read those from the specfile
|
||
for j in DESCRIPTION CXXFLAGS LDFLAGS LIBS REQUIRES INCOMPATIBLE \
|
||
STDINCLDIRS INCLTHING STDLIBDIRS LIBTHING
|
||
do
|
||
try_to_get_var_from_file "${j}" "${i}"
|
||
eval ${_tmp}_${j}=\"`value_of ${j}`\"
|
||
done
|
||
eval "${_tmp}_SUPPORT=''"
|
||
eval "${_tmp}_TEST_PASSED=''"
|
||
eval "${_tmp}_REQUIRED_BY=''"
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
for j in `value_of "${i}_REQUIRES"`; do
|
||
_append_to "${j}_REQUIRED_BY" " "
|
||
done
|
||
done
|
||
${_printf} "%s\n" "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 on:" \
|
||
>>"${INSTALL_RIS_LOGFILE}"
|
||
${_printf} "${_LEFTSPACE}%s\n" \
|
||
"----------------------------------------------------------" \
|
||
>>"${INSTALL_RIS_LOGFILE}"
|
||
log_print "This is ${CGAL_INSTALL_CGAL} version ${CGAL_INSTALL_VERSION}."
|
||
}
|
||
|
||
# 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_SUPPORT_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
|
||
# ls should have a -1 option to list files line-by-line
|
||
if ${_ls} -1 >/dev/null 2>&1; then
|
||
_lsone="${_ls} -1"
|
||
else
|
||
_lsone="${_ls}"
|
||
fi
|
||
_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 "${INSTALL_INTERACTIVE}" ]; then
|
||
if [ -n "${PAGER}" -a ! -x "${PAGER}" ]; then
|
||
_check_for_sysutil `$_basename "${PAGER}"` y
|
||
PAGER=`eval "echo \$\_$PAGER"`
|
||
PAGER=`eval "echo ${PAGER}"`
|
||
fi
|
||
else
|
||
PAGER="${_cat}"
|
||
fi
|
||
}
|
||
|
||
# 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}'`"
|
||
}
|
||
|
||
# Set ${TAUCS_OSTYPE} (variable indicating the platform name for TAUCS library)
|
||
# Note: This code is copied from TAUCS configure script
|
||
set_TAUCS_OSTYPE()
|
||
{
|
||
# In most cases, OSTYPE is set automatically before
|
||
# the user's shell begins, but sometimes it is
|
||
# not set or set in a way that is inconsistent
|
||
# with our usage.
|
||
TAUCS_OSTYPE=${OSTYPE}
|
||
|
||
# On SGI IRIX systems, OSTYPE is not set
|
||
# (at least in Tel-Aviv University)
|
||
if [ \( ${TAUCS_OSTYPE:-fail} = "fail" \) -a \( `uname` = "IRIX64" \) ] ; then
|
||
TAUCS_OSTYPE=irix
|
||
fi
|
||
|
||
# On Linux, OSTYPE is usually set to "linux",
|
||
# but if it is not set (or if the user unsets it),
|
||
# /bin/sh supplies its own politically-correct,
|
||
# string, which we need to normalize.
|
||
if [ ${TAUCS_OSTYPE:-fail} = "linux-gnu" ] ; then
|
||
TAUCS_OSTYPE=linux
|
||
fi
|
||
|
||
# On Cygwin, OSTYPE is set to "cygwin",
|
||
# which we need to change to "win32".
|
||
if [ ${TAUCS_OSTYPE:-fail} = "cygwin" ] ; then
|
||
TAUCS_OSTYPE=win32
|
||
fi
|
||
|
||
# If TAUCS_OSTYPE is still not set, we try to set it
|
||
# from uname, folding to lower case. This should sometimes
|
||
# work, but sometimes uname returns a value that is
|
||
# inconsistent with the way OSTYPE is set. For example, on
|
||
# Solaris, OSTYPE=solaris but uname returns SunOS.
|
||
if [ ${TAUCS_OSTYPE:-fail} = "fail" ] ; then
|
||
TAUCS_OSTYPE=`uname | tr "A-Z" "a-z"`
|
||
fi
|
||
|
||
${_printf} "\$TAUCS_OSTYPE is set to ${TAUCS_OSTYPE}" >> "${INSTALL_LOGFILE}"
|
||
}
|
||
|
||
# -------------------------------------------------------
|
||
# 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_SUPPORT_DIR="${CGAL_CONF_DIR}/support"
|
||
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"
|
||
# yet another logfile for temporary use (e.g. compiler tests)
|
||
TMPTMP_LOGFILE="${CGAL_DIR}/tmptmptmp.log"
|
||
|
||
# temporary file for confidence tests
|
||
TMP_CXX_FILE=./tmp_test
|
||
}
|
||
|
||
# initialize once
|
||
set_dirs_dependant_on_cgal_dir
|
||
|
||
# -------------------------------------------------------------------
|
||
# compiler related functions:
|
||
# -------------------------------------------------------------------
|
||
|
||
# return the cmdline-switch to add directory $1
|
||
# to the runtime linker path
|
||
rpath_directive()
|
||
{
|
||
if [ -n "${RUNTIME_LINKER_FLAG}" -a -n "${1}" ]; then
|
||
${_printf} "%s" "${RUNTIME_LINKER_FLAG}"
|
||
os_path "${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_SHARED_LIB_CREATE="\$(CGAL_CXX) -shared"
|
||
CGAL_SHARED_LIB_INSTALL_NAME=""
|
||
CGAL_WINLIB_CXXFLAGS=""
|
||
CGAL_QT_CXXFLAGS=""
|
||
WINDOW_INCLUDE=""
|
||
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
|
||
MATH_LIB="m"
|
||
OPENGL_LIBS="-lGL -lGLU"
|
||
SEPARATE_LIBPATH=""
|
||
START_LD_OPT=""
|
||
CGAL_CXX="`compiler_bin`"
|
||
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="+"
|
||
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
|
||
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=
|
||
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
|
||
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=
|
||
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
|
||
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"
|
||
;;
|
||
*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"
|
||
;;
|
||
*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"
|
||
;;
|
||
*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 "
|
||
;;
|
||
*SunOS*5.*CC*)
|
||
#### settings for sunpro compiler on solaris
|
||
ADDITIONAL_CXXFLAGS="-features=extensions -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"
|
||
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"
|
||
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"
|
||
EXE_EXT=".exe"
|
||
;;
|
||
*MINGW*g++*)
|
||
#### settings for gcc on mingw
|
||
ADDITIONAL_CXXFLAGS="-Wall"
|
||
EXE_EXT=".exe"
|
||
;;
|
||
*Darwin*g++*)
|
||
#### settings for gcc on Darwin (MacOSX)
|
||
ADDITIONAL_CXXFLAGS="-Wall"
|
||
CGAL_SHARED_LIB_CXXFLAGS="-fno-common"
|
||
CGAL_SHARED_LIB_CREATE="\$(CGAL_CXX) -dynamiclib"
|
||
# Note : The following CGAL_SHARED_LIB_INSTALL_NAME definition
|
||
# prevents re-use for other shared libs, e.g. libCGALQt.
|
||
CGAL_SHARED_LIB_INSTALL_NAME="-install_name \$(CGAL_LIB_DESTINATION)/\$(CGAL_SHARED_LIB)"
|
||
SHARED_LIB_EXT=".dylib"
|
||
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 "
|
||
CYGWIN_COMPILER="y"
|
||
SUFFIX_LIST=".obj .exe"
|
||
OBJ_EXT=".obj"
|
||
REMOVE_EXT_LIST=".obj"
|
||
DEBUG_OPT=""
|
||
EXE_OPT="-o "
|
||
EXE_EXT=".exe"
|
||
CGAL_WIN_EXTRA_DIR=mswin
|
||
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
|
||
}
|
||
|
||
# --------------------------------------------------------------------------
|
||
# 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}"
|
||
log_print "Created replacement header for ${header_name}."
|
||
fi
|
||
}
|
||
|
||
create_standard_header_replacements()
|
||
{
|
||
${_printf} "%s\n" "${_LEFTSPACE}Checking for standard header files"
|
||
|
||
#
|
||
# A global test for all std header files at once, to speed up the rest
|
||
# if a compiler is compliant.
|
||
${_cat} <<EOF6 >${TMP_CXX_FILE}.C
|
||
#include <algorithm>
|
||
#include <ostream>
|
||
#include <numeric>
|
||
#include <new>
|
||
#include <memory>
|
||
#include <map>
|
||
#include <locale>
|
||
#include <list>
|
||
#include <limits>
|
||
#include <iterator>
|
||
#include <istream>
|
||
#include <iostream>
|
||
#include <iosfwd>
|
||
#include <ios>
|
||
#include <iomanip>
|
||
#include <functional>
|
||
#include <fstream>
|
||
#include <exception>
|
||
#include <deque>
|
||
#include <cwctype>
|
||
#include <cwchar>
|
||
#include <ctime>
|
||
#include <cstring>
|
||
#include <cstdlib>
|
||
#include <cstdio>
|
||
#include <cstddef>
|
||
#include <cstdarg>
|
||
#include <csignal>
|
||
#include <csetjmp>
|
||
#include <complex>
|
||
#include <cmath>
|
||
#include <clocale>
|
||
#include <climits>
|
||
#include <ciso646>
|
||
#include <cfloat>
|
||
#include <cerrno>
|
||
#include <cctype>
|
||
#include <cassert>
|
||
#include <bitset>
|
||
#include <queue>
|
||
#include <vector>
|
||
#include <valarray>
|
||
#include <utility>
|
||
#include <typeinfo>
|
||
#include <string>
|
||
#include <streambuf>
|
||
#include <strstream>
|
||
#include <stdexcept>
|
||
#include <stack>
|
||
#include <sstream>
|
||
#include <set>
|
||
int main() { return 0; }
|
||
EOF6
|
||
if eval "`quote \`compiler_bin\`` ${ADDITIONAL_CXXFLAGS} ${TMP_CXX_FILE}.C >/dev/null 2>&1"; then
|
||
${_printf} "%s\n" " All headers at once : ok."
|
||
return;
|
||
fi
|
||
${_printf} "%s\n" " All headers at once : no."
|
||
|
||
#
|
||
# 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()
|
||
{
|
||
log_print "Running configuration tests..."
|
||
${_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="`${_basename} \"${i}\"`"
|
||
_test_name="`value_of_without \"_test_name\" \"${CGAL_CONFIG_PREFIX}\" \"\.C\"`"
|
||
_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` `math_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` does NOT seem to have an STL."
|
||
fi
|
||
${_printf} "%s\n\n" \
|
||
"#define ${CGAL_CONFIG_PREFIX}${_test_name} 1" \
|
||
>> "${_file}"
|
||
cleanup_after_compile
|
||
done
|
||
}
|
||
|
||
|
||
#---------------------------------------------------------
|
||
# flags for compiler/linker and utitlities
|
||
|
||
# escape spaces in filenames
|
||
escape_special()
|
||
{
|
||
echo "${*}" | ${_sed} 's/ /\\\ /g'
|
||
}
|
||
|
||
# double-escape spaces in filenames
|
||
multi_escape_special()
|
||
{
|
||
echo "${*}" | ${_sed} 's/ /\\\\\\\ /g'
|
||
}
|
||
|
||
posix_path()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "%s" "`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "%s" "`${_cygpath} -u \"$*\"`"
|
||
fi
|
||
}
|
||
|
||
os_path_escape()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "%s" "`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "%s" "`${_cygpath} -w \"$*\"`"
|
||
fi
|
||
}
|
||
|
||
os_path()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "%s" "${*}"
|
||
else
|
||
${_printf} "%s" "`${_cygpath} -w \"$*\"`"
|
||
fi
|
||
}
|
||
|
||
include_dir_option()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "-I%s " "`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "'-I%s' " "`${_cygpath} -w \"${*}\"`"
|
||
fi
|
||
}
|
||
|
||
libpath_option()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "${LIBPATH_OPT}%s " "`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "'${LIBPATH_OPT}%s' " "`${_cygpath} -w \"${*}\"`"
|
||
fi
|
||
}
|
||
|
||
libpath_option_pure()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "'${LIBPATH_OPT}%s' " "`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "'${LIBPATH_OPT}%s' " "$*"
|
||
fi
|
||
}
|
||
|
||
lib_option()
|
||
{
|
||
${_printf} "${LIB_OPT}%s${LIB_SUFFIX} " "$*"
|
||
}
|
||
|
||
object_file_name()
|
||
{
|
||
if [ -z "${CYGWIN_COMPILER}" ]; then
|
||
${_printf} "%s" "`escape_special \"${*}\"`${OBJ_EXT}"
|
||
else
|
||
${_printf} "%s" "'`${_cygpath} -w \"${*}\"`${OBJ_EXT}'"
|
||
fi
|
||
}
|
||
|
||
to_object_file_option()
|
||
{
|
||
if [ -z "${WINDOWS_COMPILER}" ]; then
|
||
${_printf} "%s" "-o `escape_special \"${*}\"`.o"
|
||
else
|
||
${_printf} "%s" "'-o`${_cygpath} -w \"${*}\"`'"
|
||
fi
|
||
}
|
||
|
||
output_file_option()
|
||
{
|
||
if [ -z "${WINDOWS_COMPILER}" ]; then
|
||
${_printf} "%s" "${EXE_OPT}`escape_special \"${*}\"`"
|
||
else
|
||
${_printf} "%s" "'${EXE_OPT}`${_cygpath} -w \"${*}\"`'"
|
||
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
|
||
}
|
||
|
||
#---------------------------------------------------------
|
||
# 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}"
|
||
}
|
||
|
||
#---------------------------------------------------------
|
||
# support for 3rd party libraries
|
||
|
||
# ${1} is a variable
|
||
# append ${2} to it, separate several entries by ${3}
|
||
_append_to()
|
||
{
|
||
if [ -n "${2}" ]; then
|
||
if [ -z "`value_of \"${1}\"`" ]; then
|
||
eval ${1}=\"${2}\"
|
||
else
|
||
eval ${1}=\"`value_of "${1}"`${3}${2}\"
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# ${1} is a variable
|
||
# prepend ${2} to it, separate several entries by ${3}
|
||
_prepend_to()
|
||
{
|
||
if [ -n "${2}" ]; then
|
||
if [ -z "`value_of \"${1}\"`" ]; then
|
||
eval ${1}=\"${2}\"
|
||
else
|
||
eval ${1}=\"${2}${3}`value_of "${1}"`\"
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# $1 is a list of items separated by '', replace '' by $2
|
||
split_up()
|
||
{
|
||
${_printf} "%s\n" "`value_of \"${1}\"`" | ${_sed} "s//${2}/g"
|
||
}
|
||
|
||
# enable support for package $1
|
||
# USES: iii
|
||
enable_support()
|
||
{
|
||
if [ -n "${1}" -a -z "`value_of ${1}_SUPPORT`" ]; then
|
||
eval "${1}_SUPPORT=y"
|
||
SETUP_COMPLETE=''
|
||
for iii in `value_of ${1}_PROVIDES`; do
|
||
if [ -n "`value_of PROVIDE_PKG_${iii}`" ]; then
|
||
exit_on_error "`value_of PROVIDE_PKG_${iii}` and ${1} are in conflict"
|
||
fi
|
||
eval "PROVIDE_PKG_${iii}=${1}"
|
||
done
|
||
fi
|
||
}
|
||
|
||
# enable support for package $1
|
||
# USES: iii
|
||
disable_support()
|
||
{
|
||
if [ -n "${1}" -a -n "`value_of ${1}_SUPPORT`" ]; then
|
||
eval "${1}_SUPPORT=''"
|
||
SETUP_COMPLETE=''
|
||
for iii in `value_of ${1}_PROVIDES`; do
|
||
if [ "`value_of PROVIDE_PKG_${iii}`" != "${1}" ]; then
|
||
exit_on_error "Inconsistent support settings (disable_support)"
|
||
fi
|
||
eval "PROVIDE_PKG_${iii}=''"
|
||
done
|
||
for iii in `value_of ${1}_REQUIRED_BY`; do
|
||
eval "${iii}_TEST_PASSED=''"
|
||
done
|
||
fi
|
||
}
|
||
|
||
# test for 3rd party package $1 ($2 != '' indicates verbosity)
|
||
# The test program is $3 and the variables
|
||
# tmp_cxxflags, tmp_libpathflags, and tmp_ldflags have to be preset.
|
||
# $4 provides a literal description for the test.
|
||
# The variable ${4}_VERSION is set according to the version information provided
|
||
# by the test program; if necessary, the variables ${4}_INCL/LIB_DIR are modified
|
||
# to take into account the standard directory where the package was found.
|
||
# Return 1, if test succeeds; otherwise, return 0.
|
||
# USES: ii _ok kk _ii _kk
|
||
_test_support()
|
||
{
|
||
if [ ! -r "${3}" ]; then
|
||
log_print "OK: There is no test program ${3}."
|
||
return 1
|
||
fi
|
||
${_cp} "${3}" ${TMP_CXX_FILE}.C
|
||
if [ -n "`value_of \"${1}_DESCRIPTION\"`" ]; then
|
||
DESCRIPTION="${4} (`value_of \"${1}_DESCRIPTION\"`)"
|
||
else
|
||
DESCRIPTION="${4}"
|
||
fi
|
||
while [ 0 ]; do
|
||
# a) try with current flags
|
||
log_print " Testing with default flags."
|
||
if _compile_test "${DESCRIPTION}" "${tmp_cxxflags} " "${2}" && \
|
||
_link_run_test "${DESCRIPTION}" \
|
||
"${tmp_libpathflags} `rpath_directive \"${tmp_runtimepath}\"`" \
|
||
"${tmp_ldflags} " \
|
||
"${2}" \
|
||
"no." \
|
||
"${4}_VERSION"
|
||
then
|
||
break
|
||
fi
|
||
cleanup_after_compile_leave_source
|
||
# b) try standard locations specifically specified
|
||
# (the strange processing is to handle spaces in filenames;
|
||
# what a great invention!)
|
||
log_print " Looking for ${DESCRIPTION} in standard locations..."
|
||
_ok=''
|
||
for ii in `echo \`value_of ${1}_STDINCLDIRS\` | \
|
||
${_sed} 's/ //g' | ${_awk} 'BEGIN {RS=":"}{print $0}'`
|
||
do
|
||
ii="`echo ${ii} | ${_sed} 's// /g'`"
|
||
log_print " - Looking for includes in ${ii} ..."
|
||
# we need two evals: the first one strips off the escape from wildchars,
|
||
# the second one expands it. otoh, this means we have to heavily escape
|
||
# potential spaces
|
||
ii="`multi_escape_special \"${ii}\"`/`value_of ${1}_INCLTHING`"
|
||
for kk in `eval eval ${_lsone} -d "${ii}" 2>/dev/null | ${_sed} 's/ //g'`
|
||
do
|
||
kk="`echo ${kk} | ${_sed} 's// /g'`"
|
||
kk="`${_dirname} \"${kk}\"`"
|
||
if [ ! -r "${kk}" ]; then continue; fi
|
||
log_print " - Trying ${kk}."
|
||
if _compile_test "${DESCRIPTION} with include ${kk}" \
|
||
"${tmp_cxxflags} `include_dir_option \"${kk}\"`" \
|
||
"${2}"
|
||
then
|
||
# first try without additional libdir flags, maybe its headers only...
|
||
${_printf} "%s\n%s" " ok." \
|
||
"${_LEFTSPACE}Linking $1 without extra libdir ..."
|
||
if _link_run_test \
|
||
"${DESCRIPTION}" \
|
||
"${tmp_libpathflags} `rpath_directive \"${tmp_runtimepath}\"`" \
|
||
"${tmp_ldflags} " \
|
||
"${2}" \
|
||
"no." \
|
||
"${4}_VERSION"
|
||
then
|
||
log_print " Found ${1} with INCL_DIR ${kk}."
|
||
_append_to "${4}_INCL_DIR" "${kk}" ":"
|
||
_ok=y
|
||
break
|
||
fi
|
||
# it seems we need libs also...
|
||
for _ii in `echo \`value_of ${1}_STDLIBDIRS\` | \
|
||
${_sed} 's/ //g' | ${_awk} 'BEGIN {RS=":"}{print $0}'`
|
||
do
|
||
_ii="`echo ${_ii} | ${_sed} 's// /g'`"
|
||
log_print " --- Looking for libs in ${_ii} ..."
|
||
_ii="`multi_escape_special \"${_ii}\"`/`value_of ${1}_LIBTHING`"
|
||
for _kk in `eval eval ${_lsone} -d "${_ii}" 2>/dev/null | ${_sed} 's/ //g'`
|
||
do
|
||
_kk="`echo ${_kk} | ${_sed} 's// /g'`"
|
||
_kk="`${_dirname} \"${_kk}\"`"
|
||
if [ ! -r "${_kk}" ]; then continue; fi
|
||
log_print " ---- Trying ${_kk}."
|
||
runtimepath="${tmp_runtimepath}"
|
||
_append_to runtimepath "`os_path \"${_kk}\"`" ":"
|
||
${_printf} "%s" "${_LEFTSPACE}Linking $1 with ${_kk} ..."
|
||
if _link_run_test \
|
||
"${DESCRIPTION}" \
|
||
"${tmp_libpathflags} `libpath_option \"${_kk}\"` `rpath_directive \"${runtimepath}\"`" \
|
||
"${tmp_ldflags} " \
|
||
"${2}" \
|
||
"no." \
|
||
"${4}_VERSION"
|
||
then
|
||
log_print " Found ${DESCRIPTION} with INCL_DIR ${kk} and LIB_DIR ${_kk}."
|
||
_append_to "${4}_INCL_DIR" "${kk}" ":"
|
||
_append_to "${4}_LIB_DIR" "${_kk}" ":"
|
||
_ok=y
|
||
break
|
||
fi
|
||
done
|
||
if [ -n "${_ok}" ]; then break; fi
|
||
done
|
||
fi
|
||
cleanup_after_compile_leave_source
|
||
if [ -n "${_ok}" ]; then break; fi
|
||
done
|
||
if [ -n "${_ok}" ]; then break; fi
|
||
done
|
||
if [ -n "${_ok}" ]; then break; fi
|
||
log_print "Failed: ${4} test program."
|
||
cleanup_after_compile
|
||
return 0
|
||
done
|
||
log_print "OK: ${4} test program."
|
||
cleanup_after_compile
|
||
return 1
|
||
}
|
||
|
||
# test if all requirements of pkg $1 are met.
|
||
# If any missing requirement is found, the function returns 0 and outputs it.
|
||
# Otherwise, the function returns 1.
|
||
# USES: _tmp jj
|
||
_check_requirements()
|
||
{
|
||
for jj in `value_of ${1}_REQUIRES`; do
|
||
case ${jj} in
|
||
DOLLAR_*)
|
||
_tmp="`echo ${jj} | ${_sed} 's/^DOLLAR_//'`"
|
||
if [ -z "`value_of ${_tmp}`" ]; then
|
||
echo ${1} requires variable ${_tmp}
|
||
return 0
|
||
fi;;
|
||
*)
|
||
if [ -z "`value_of PROVIDE_PKG_${jj}`" ]; then
|
||
echo ${1} requires feature ${jj}
|
||
return 0
|
||
fi;;
|
||
esac
|
||
done
|
||
return 1
|
||
}
|
||
|
||
# test if no incompatibilities w.r.t. pkg $1 are present.
|
||
# If any incompatibility is found, the function returns 0 and outputs it.
|
||
# Otherwise, the function returns 1.
|
||
# USES: _tmp jj
|
||
_check_incompatibilities()
|
||
{
|
||
for jj in `value_of ${1}_PROVIDES`; do
|
||
_tmp="`value_of PROVIDE_PKG_${jj}`"
|
||
if [ -n "${_tmp}" -a "${_tmp}" != "${1}" ]; then
|
||
echo ${1} is incompatible with package `value_of PROVIDE_PKG_${jj}`
|
||
return 0
|
||
fi
|
||
done
|
||
for jj in `value_of ${1}_INCOMPATIBLE`; do
|
||
case ${jj} in
|
||
DOLLAR_*)
|
||
_tmp="`echo ${jj} | ${_sed} 's/^DOLLAR_//'`"
|
||
if [ -n "`value_of ${_tmp}`" ]; then
|
||
echo ${1} is incompatible with variable ${_tmp}
|
||
return 0
|
||
fi;;
|
||
*)
|
||
if [ -n "`value_of PROVIDE_PKG_${jj}`" ]; then
|
||
echo ${1} is incompatible with feature ${jj}
|
||
return 0
|
||
fi;;
|
||
esac
|
||
done
|
||
return 1
|
||
}
|
||
|
||
# set the variable tmp_cxxflags for package $1
|
||
set_package_cxxflags()
|
||
{
|
||
tmp_cxxflags="`value_of \"${1}_CXXFLAGS\"`"
|
||
}
|
||
|
||
# set the variable tmp_cxxflags for feature $1
|
||
# USES: ii
|
||
set_feature_cxxflags()
|
||
{
|
||
tmp_cxxflags=''
|
||
for ii in `echo \`value_of "${1}_INCL_DIR"\` | \
|
||
${_sed} 's/ //g' | ${_awk} 'BEGIN {RS=":"}{print $0}'`
|
||
do
|
||
ii="`echo ${ii} | ${_sed} 's// /g'`"
|
||
if [ -n "${ii}" ]; then
|
||
_append_to tmp_cxxflags "`include_dir_option \"${ii}\"`" ""
|
||
fi
|
||
done
|
||
}
|
||
|
||
# set the variables tmp_libpathflags and tmp_runtimepath for feature $1.
|
||
# Attention: The linker option for the runtime-linker path is not set,
|
||
# only the path is built up in tmp_runtimepath. (Allows for adding
|
||
# additional dirs in _test_support.)
|
||
# USES: ii
|
||
set_feature_libpathflags()
|
||
{
|
||
tmp_libpathflags=''
|
||
tmp_runtimepath=''
|
||
for ii in `echo \`value_of "${1}_LIB_DIR"\` | \
|
||
${_sed} 's/ //g' | ${_awk} 'BEGIN {RS=":"}{print $0}'`
|
||
do
|
||
ii="`echo ${ii} | ${_sed} 's// /g'`"
|
||
if [ -n "${ii}" ]; then
|
||
_append_to tmp_libpathflags "`libpath_option \"${ii}\"`" ""
|
||
_append_to tmp_runtimepath "`os_path \"${ii}\"`" ""
|
||
fi
|
||
done
|
||
}
|
||
|
||
# set the variable tmp_ldflags for package $1
|
||
# USES: ii
|
||
set_package_ldflags()
|
||
{
|
||
tmp_ldflags="`value_of \"${1}_LDFLAGS\"`"
|
||
for ii in `value_of "${1}_LIBS"`; do
|
||
_append_to tmp_ldflags "`lib_option \"${ii}\"`" ""
|
||
done
|
||
}
|
||
|
||
# Test package $1 ($2 nonzero indicates verbosity)
|
||
# If successful, return 1; otherwise, return 0.
|
||
# USES: _tmp _ok ii jj kk _ii _kk
|
||
test_support_pkg()
|
||
{
|
||
if [ -n "`value_of \"${1}_SUPPORT\"`" -a -n "`value_of \"${1}_TEST_PASSED\"`" ]; then
|
||
${_printf} "%s\n" "${_LEFTSPACE}${1} test has already been passed."
|
||
return 1
|
||
fi
|
||
log_print "Testing support for ${1} ..."
|
||
# check requirements and incompatibilities
|
||
_tmp=`_check_requirements "${1}" || _check_incompatibilities "${1}"`
|
||
if [ ${?} = 0 ]; then
|
||
log_print "Failed: ${_tmp}."
|
||
return 0
|
||
fi
|
||
log_print " OK: requirements and incompatibilities."
|
||
# --------------------------
|
||
# try to build test programs
|
||
# --------------------------
|
||
real_cxxflags="`compiler_test_cxxflags`"
|
||
real_libpathflags="`compiler_test_libpathflags`"
|
||
real_ldflags="`compiler_test_ldflags`"
|
||
real_runtimepath=''
|
||
|
||
# pull in flags for required packages and features
|
||
for jj in ${SUPPORT_FEATURES}; do eval TMP_SUPPORT_${jj}=''; done
|
||
for jj in ${SUPPORT_PKGS}; do eval TMP_SUPPORT_${jj}=''; done
|
||
eval "TMP_SUPPORT_${1}=y"
|
||
for jj in ${R_SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"TMP_SUPPORT_${jj}\"`" ]; then
|
||
for kk in `value_of "${jj}_REQUIRES"`; do
|
||
case "${kk}" in
|
||
DOLLAR_*) _tmp=thisisnotused;;
|
||
*)
|
||
eval TMP_SUPPORT_${kk}=y
|
||
# also pull in the providing package
|
||
_tmp="`value_of \"PROVIDE_PKG_${kk}\"`"
|
||
if [ -z "${_tmp}" ]; then
|
||
# this should have been caught in _check_requirements
|
||
exit_on_error \
|
||
"Inconsistent support settings (test_support_pkg)"
|
||
fi
|
||
eval TMP_SUPPORT_${_tmp}=y
|
||
;;
|
||
esac
|
||
done
|
||
fi
|
||
done
|
||
# generate flags
|
||
for jj in ${SUPPORT_FEATURES}; do
|
||
if [ -n "`value_of \"PROVIDE_PKG_${jj}\"`" ]; then
|
||
set_feature_cxxflags "${jj}"
|
||
_append_to real_cxxflags "${tmp_cxxflags}" ""
|
||
set_feature_libpathflags "${jj}"
|
||
_append_to real_libpathflags "${tmp_libpathflags}" ""
|
||
_append_to real_runtimepath "${tmp_runtimepath}" ""
|
||
fi
|
||
done
|
||
for jj in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"TMP_SUPPORT_${jj}\"`" ]; then
|
||
set_package_cxxflags "${jj}"
|
||
_append_to real_cxxflags "${tmp_cxxflags}" ""
|
||
set_package_ldflags "${jj}"
|
||
_prepend_to real_ldflags "${tmp_ldflags}" ""
|
||
fi
|
||
done
|
||
tmp_ldflags="${real_ldflags}"
|
||
_append_to tmp_ldflags "`math_ldflags`" ""
|
||
# this does not change below, hence split it here already
|
||
tmp_ldflags="`split_up \"tmp_ldflags\" \" \"`"
|
||
|
||
# now test all provided features
|
||
for jj in `value_of "${1}_PROVIDES"`; do
|
||
set_feature_cxxflags "${jj}"
|
||
_prepend_to tmp_cxxflags "${real_cxxflags}" ""
|
||
set_feature_libpathflags "${jj}"
|
||
_prepend_to tmp_libpathflags "${real_libpathflags}" ""
|
||
_prepend_to tmp_runtimepath "${real_runtimepath}" ""
|
||
|
||
# split flags up
|
||
tmp_cxxflags="`split_up \"tmp_cxxflags\" \" \"`"
|
||
tmp_libpathflags="`split_up \"tmp_libpathflags\" \" \"`"
|
||
tmp_runtimepath="`split_up \"tmp_runtimepath\" \":\"`"
|
||
|
||
if _test_support "${1}" \
|
||
"${2}" \
|
||
"${CGAL_SUPPORT_DIR}/test_${jj}.C" \
|
||
"${jj}"
|
||
then
|
||
return 0
|
||
fi
|
||
done
|
||
|
||
eval "${1}_TEST_PASSED=y"
|
||
return 1
|
||
}
|
||
|
||
|
||
# test the current selection for their requirements and incompatibilities
|
||
# If any incompatibility or any missing requirement is found,
|
||
# the function returns 0 and outputs it; otherwise, the function returns 1.
|
||
# USES: i jj _tmp
|
||
test_requirements_and_incompatibilities()
|
||
{
|
||
for i in ${SUPPORT_REQUIRED}; do
|
||
if [ -z "`value_of \"PROVIDE_PKG_${i}\"`" ]; then
|
||
echo "Support for ${i} is required"
|
||
return 0
|
||
fi
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of ${i}_SUPPORT`" ]; then
|
||
if _check_requirements "${i}" || _check_incompatibilities "${i}"; then
|
||
return 0
|
||
fi
|
||
fi
|
||
done
|
||
return 1
|
||
}
|
||
|
||
#---------------------------------------------------------
|
||
# all flags
|
||
|
||
# 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
|
||
// this pleases (x)emacs font-lock-mode << e;
|
||
|
||
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
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
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
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
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}'
|
||
_tmp4="`custom_ostype_tag \"${*:-${COMPILER}}\"`"
|
||
if [ -n "${_tmp4}" ]; then ${_printf} " (%s)" "${_tmp4}"; fi
|
||
${_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_config_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()
|
||
{
|
||
_COMPILER_NUMBER=1
|
||
|
||
# first check, which config files exist
|
||
for i in `${_ls} "${CGAL_INSTALL_CONF_DIR}"/${SYST}* 2>/dev/null | ${_sed} 's/ //g'`
|
||
do
|
||
i="`echo ${i} | ${_sed} 's// /g'`"
|
||
try_to_get_var_from_config_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)
|
||
# USES: _tmp
|
||
_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:
|
||
|
||
# USES: _tmp
|
||
remove_special_chars()
|
||
{
|
||
_read
|
||
echo "$KEY" | ${_tr} -d '\\!@#$%^&*()_|~";?<>{}[]\`/ ' | ${_tr} -d "'"
|
||
}
|
||
|
||
_set_indent()
|
||
{
|
||
_LEFTSPACE=' '
|
||
}
|
||
|
||
_full_indent()
|
||
{
|
||
_LEFTSPACE=' '
|
||
}
|
||
|
||
_no_indent()
|
||
{
|
||
_LEFTSPACE=''
|
||
}
|
||
|
||
# USES: _tmp
|
||
print_with_indent()
|
||
{
|
||
if [ -z "$*" ]; then
|
||
_read
|
||
${_printf} "${_LEFTSPACE}${KEY}\n"
|
||
else
|
||
${_printf} "${_LEFTSPACE}${*}\n"
|
||
fi
|
||
}
|
||
|
||
# USES: _tmp
|
||
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:
|
||
|
||
# try to read variable $1 from file $2
|
||
# return 0, iff something went wrong
|
||
try_to_get_var_from_config_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}"
|
||
return 1
|
||
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
|
||
}
|
||
|
||
# try to read variable $1 from file $2
|
||
# 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
|
||
# leading spaces would spoil the assignment below...
|
||
_tmp2=`echo ${_tmp2} | ${_awk} 'BEGIN {FS="="} {print $2}' | \
|
||
${_tr} -s " " | ${_sed} 's/^ //'`
|
||
eval "${1}=\"${_tmp2}\""
|
||
return 1
|
||
else
|
||
log_print "WARNING: cannot find field ${1} in file ${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
|
||
cleanup_after_compile_leave_source()
|
||
{
|
||
# 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}" "${TMPTMP_LOGFILE}"
|
||
# remove moc file
|
||
${_rm} -f "${TMP_CXX_FILE}.moc"
|
||
}
|
||
|
||
# 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()
|
||
{
|
||
cleanup_after_compile_leave_source
|
||
# remove tmp C++ file
|
||
${_rm} -f "${TMP_CXX_FILE}.C"
|
||
}
|
||
|
||
# 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.')
|
||
# USES: _flags
|
||
_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
|
||
_flags="$2"
|
||
# _flags="${_flags} -c '`os_path ${TMP_CXX_FILE}.C`' `to_object_file_option ${TMP_CXX_FILE}`"
|
||
_flags="${_flags} -c '`os_path ${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
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
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
|
||
${_printf} "%s\n" " ${4:-no.}"
|
||
fi
|
||
log_print " remark: $1 test did not compile."
|
||
log_print " vvvvvvvvvvvv compiler messages below vvvvvvvvvvvv"
|
||
eval ${_awk} \'{print \"" "\",\$0}\' \"${TMP_LOGFILE}\" ${INSTALL_LOGFILE_REDIRECTION}
|
||
log_print " ^^^^^^^^^^^^ compiler messages above ^^^^^^^^^^^^"
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# cleanup after compilation
|
||
cleanup_after_link_run()
|
||
{
|
||
# remove executable and core
|
||
${_rm} -f "${TMP_CXX_FILE}" core
|
||
}
|
||
|
||
# run a link&run test named $1, return 0, iff ok
|
||
# $2 is libpath flags
|
||
# $3 is 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
|
||
_flags="`output_file_option ${TMP_CXX_FILE}` `object_file_name ${TMP_CXX_FILE}` ${START_LD_OPT} ${2} ${3}"
|
||
# link
|
||
_link="`compiler_bin`"
|
||
${_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_CXX_FILE}" >"${TMPTMP_LOGFILE}" 2>&1
|
||
j=$?
|
||
_tmp=`${_cat} "${TMPTMP_LOGFILE}" | ${_tee} -a "${TMP_LOGFILE}" | ${_awk} 'BEGIN{FS="="} /^version=/{print $2}' | remove_special_chars`
|
||
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
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
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
|
||
log_print " vvvvvvvvvvvv linker/runtime messages below vvvvvvvvvvvv"
|
||
eval ${_awk} \'{print \"" "\",\$0}\' \"${TMP_LOGFILE}\" ${INSTALL_LOGFILE_REDIRECTION}
|
||
log_print " ^^^^^^^^^^^^ linker/runtime messages above ^^^^^^^^^^^^"
|
||
cleanup_after_link_run
|
||
return 1
|
||
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
|
||
}
|
||
|
||
# print the current os/compiler in a readable fashion
|
||
# $1 is the print command
|
||
# USES: i l _tmp
|
||
print_os_setting()
|
||
{
|
||
${1} "OS:\t\t\t\t${SYST}"
|
||
${1} "COMPILER:\t\t\t`extended_compiler_description`"
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
_set_tmp_to_not_or_not "`value_of \"PROVIDE_PKG_${i}\"`"
|
||
length "${_LEFTSPACE}${i}:"
|
||
l=${?}
|
||
if [ ${l} -lt 8 ]; then
|
||
${1} "${i}:\t\t\t\t${_tmp}supported"
|
||
else
|
||
if [ ${l} -lt 16 ]; then
|
||
${1} "${i}:\t\t\t${_tmp}supported"
|
||
else
|
||
if [ ${l} -lt 24 ]; then
|
||
${1} "${i}:\t\t${_tmp}supported"
|
||
else
|
||
${1} "${i}:\t${_tmp}supported"
|
||
fi
|
||
fi
|
||
fi
|
||
done
|
||
}
|
||
|
||
set_lib_compiled_flag()
|
||
{
|
||
# does there exist a lib for this os/compiler?
|
||
if [ -r "${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}/${CGAL_LIBNAME}" ]; then
|
||
LIB_COMPILED='ok'
|
||
else
|
||
LIB_COMPILED=''
|
||
fi
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# compiler related functions
|
||
#
|
||
|
||
# try to retrieve the compiler specific settings from
|
||
# file ${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}
|
||
# USES: i j
|
||
retrieve_compiler_settings()
|
||
{
|
||
_file="${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}"
|
||
_tmp_version=${CGAL_INSTALL_VERSION}
|
||
if try_to_get_var_from_config_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
|
||
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
for j in INCL_DIR LIB_DIR VERSION; do
|
||
if try_to_get_var_from_config_file "${i}_${j}" "${_file}"; then
|
||
eval "${i}_${j}=''"
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
done
|
||
eval "PROVIDE_PKG_${i}=''"
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
for j in SUPPORT; do
|
||
if try_to_get_var_from_config_file "${i}_${j}" "${_file}"; then
|
||
eval "${i}_${j}=''"
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
done
|
||
if [ -n "`value_of \"${i}_SUPPORT\"`" ]; then
|
||
eval "${i}_TEST_PASSED=y"
|
||
for j in `value_of "${i}_PROVIDES"`; do
|
||
eval "PROVIDE_PKG_${j}=\"${i}\""
|
||
done
|
||
else
|
||
eval "${i}_TEST_PASSED=''"
|
||
fi
|
||
done
|
||
|
||
if try_to_get_var_from_config_file CUSTOM_CXXFLAGS "${_file}"; then
|
||
CUSTOM_CXXFLAGS=''
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
if try_to_get_var_from_config_file CUSTOM_LDFLAGS "${_file}"; then
|
||
CUSTOM_LDFLAGS=''
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
if try_to_get_var_from_config_file LONG_NAME_PROBLEM "${_file}"; then
|
||
LONG_NAME_PROBLEM=''
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
if try_to_get_var_from_config_file ENABLE_SHARED "${_file}"; then
|
||
ENABLE_SHARED='y'
|
||
SETUP_COMPLETE=''
|
||
fi
|
||
|
||
# legacy mode: package CORE corresponds to an external CORE
|
||
# installation now
|
||
try_to_get_var_from_config_file CORE_INSTALLATION "${_file}"
|
||
if [ ${?} -eq 1 -a "${CORE_INSTALLATION}" = "c" ]; then
|
||
if [ -n "${CORE_SUPPORT}" ]; then disable_support CORE; fi
|
||
enable_support CGALCORE
|
||
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}/${CGAL_OS_COMPILER}
|
||
store_compiler_settings()
|
||
{
|
||
_file="${CGAL_INSTALL_CONF_DIR}/${CGAL_OS_COMPILER}"
|
||
${_printf} "%s\n" "/*" >${_file}
|
||
${_printf} "%s\n" "** file: `$_basename \"${_file}\"`" >>${_file}
|
||
${_printf} "%s\n" "** Configuration file for CGAL ${CGAL_VERSION}" >>${_file}
|
||
${_printf} "%s\n" "** on `extended_compiler_description`" >>${_file}
|
||
${_printf} "%s%s\n" "** Automatically created by " \
|
||
"${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}
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
for j in INCL_DIR LIB_DIR VERSION; do
|
||
_store_install_config_variable "${i}_${j}" >>${_file}
|
||
done
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
for j in SUPPORT; do
|
||
_store_install_config_variable "${i}_${j}" >>${_file}
|
||
done
|
||
done
|
||
_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
|
||
# USES: totest
|
||
test_setup()
|
||
{
|
||
SETUP_COMPLETE=''
|
||
make_lib_dir
|
||
|
||
cd "${CGAL_TEST_CONF_DIR}"
|
||
_check_dir_exists_create "${CGAL_INCL_CONF_DIR}/${CGAL_OS_COMPILER}"
|
||
_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 "*** CGAL will work fine ***"
|
||
print_line "regardless of the outcome of these tests."
|
||
print_filled_line
|
||
flush_buffer
|
||
|
||
create_standard_header_replacements
|
||
test_compiler_specifica "${INSTALL_VERBOSE}"
|
||
|
||
for totest in ${SUPPORT_FEATURES}; 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_${totest}_VERSION 0" >> ${_file}
|
||
${_printf} "%s\n" "//#define CGAL_USE_${totest} 1" >> ${_file}
|
||
${_printf} "%s\n\n" "#endif // ! CGAL_NO_${totest}" >> ${_file}
|
||
done
|
||
|
||
CONFIG_TEST_PASSED='y'
|
||
|
||
if [ -n "${CGAL_AUTOFIND_PKGS}" ]; then autofind_packages; fi
|
||
|
||
else
|
||
# try to autofind required features
|
||
for totest in ${SUPPORT_REQUIRED}; do
|
||
if [ -z "`value_of \"PROVIDE_PKG_${totest}\"`" ]; then
|
||
log_print "Remark: ${totest} is required, but not currently enabled."
|
||
autofind_feature "${totest}"
|
||
fi
|
||
done
|
||
fi
|
||
|
||
SETUP_COMPLETE='y'
|
||
|
||
# check requirements and incompatibilities
|
||
_tmp=`test_requirements_and_incompatibilities`
|
||
if [ $? = 0 ]; then
|
||
log_print "ERROR: ${_tmp}."
|
||
write_buffer "\n"
|
||
print_filled_line
|
||
print_empty_line
|
||
print_headline "ERROR: ${_tmp}."
|
||
print_filled_line
|
||
if [ -n "${INSTALL_INTERACTIVE}" ]; then
|
||
wait_for_enter
|
||
else
|
||
flush_buffer
|
||
fi
|
||
SETUP_COMPLETE=''
|
||
return 1
|
||
fi
|
||
|
||
# check supported packages
|
||
cd "${CGAL_SUPPORT_DIR}"
|
||
for totest in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"${totest}_SUPPORT\"`" ]; then
|
||
if test_support_pkg "${totest}" verbose; then
|
||
SETUP_COMPLETE=''
|
||
else
|
||
log_print "${totest} test passed."
|
||
fi
|
||
fi
|
||
done
|
||
|
||
# set CGAL_USE and VERSION tags in compiler_config file
|
||
for totest in ${SUPPORT_FEATURES}; do
|
||
_tmp2="#define CGAL_USE_${totest} 1"
|
||
_tmp3="//#define CGAL_USE_${totest} 1"
|
||
if [ -n "`value_of \"PROVIDE_PKG_${totest}\"`" ]; then
|
||
replace_line "${_file}" "${_tmp3}" "${_tmp2}"
|
||
else
|
||
replace_line "${_file}" "${_tmp2}" "${_tmp3}"
|
||
fi
|
||
_tmp2="${totest}_VERSION"
|
||
_tmp3="`value_of ${_tmp2}`"
|
||
replace_line "${_file}" "#define CGAL_${_tmp2}" \
|
||
"#define CGAL_${_tmp2} ${_tmp3:-0}"
|
||
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
|
||
# USES: ii
|
||
reset_all_test_variables()
|
||
{
|
||
CONFIG_TEST_PASSED=''
|
||
for ii in ${SUPPORT_PKGS}; do
|
||
eval "${ii}_TEST_PASSED=''"
|
||
done
|
||
}
|
||
|
||
# load the settings for ${COMPILER},
|
||
# if a config file exists, otherwise check for STL
|
||
# USES: ii
|
||
_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_variables
|
||
else
|
||
CONFIG_TEST_PASSED='y'
|
||
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
|
||
# USES: i
|
||
menu_header()
|
||
{
|
||
_SUPPORT=''
|
||
_PRELASTSUPPORT=''
|
||
_LASTSUPPORT=''
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
_set_supported_library "${i}" "`value_of \"PROVIDE_PKG_${i}\"`"
|
||
done
|
||
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
|
||
_SUPPORT="Support for: ${_SUPPORT}."
|
||
clear_screen
|
||
print_filled_line
|
||
print_headline "CGAL $CGAL_VERSION Installation ${1} Menu"
|
||
print_line "OS: ${SYST}"
|
||
print_line "Compiler: `extended_compiler_description`"
|
||
flush_buffer
|
||
# print supported stuff nicely
|
||
echo "${_SUPPORT}" | ${_awk} "BEGIN {RS=\" \"; l=0; c=\"\" } {if (l+length(\$1) > 55) { printf \"${_MENU_LINE_EMPTY}\\r${_LEFTSPACE}** %s\\n\",c; c=\" \" \$1; l=13+length(\$1) } else { if (length(c)==0) { l+=length(\$1); c=\$1 } else { l+=length(\$1)+1; c=c \" \" \$1 } } } END { if (length(c)>0) { printf \"${_MENU_LINE_EMPTY}\\r${_LEFTSPACE}** %s\\n\",c } }"
|
||
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
|
||
# USES: _tmp
|
||
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
|
||
# USES: _tmp
|
||
change_value()
|
||
{
|
||
go_up_lines 1
|
||
print_prompt "New $1: "
|
||
_read
|
||
eval "$1=\"${KEY}\""
|
||
}
|
||
|
||
# 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
|
||
# ($1 is the name of the next-higher menu)
|
||
|
||
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 "$1"
|
||
|
||
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 'Compiler 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
|
||
CUSTOM_OSTYPE_TAG=`echo ${CUSTOM_OSTYPE_TAG} | remove_special_chars`
|
||
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
|
||
}
|
||
|
||
# $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."
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
${_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
|
||
${PAGER:-${_cat}} "${TMP_LOGFILE}"
|
||
${_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
|
||
}
|
||
|
||
# print elements from variable $1 (separated by ) on a multiline
|
||
makefile_print_from_var()
|
||
{
|
||
_tmp="`value_of \"${1}\"`"
|
||
if [ -n "${_tmp}" ]; then
|
||
echo "${_tmp}" | ${_awk} 'BEGIN {RS=""}{printf " \\\n\t%s",$0}'
|
||
fi
|
||
}
|
||
|
||
# USES: i _tmp
|
||
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}
|
||
|
||
#
|
||
# CUSTOM_CXXFLAGS
|
||
#
|
||
print_as_shell_comment \
|
||
"*** Fill in any additional compiler flags you need ***" \
|
||
>> ${FILE}
|
||
${_printf} "%s\n\n" "CUSTOM_CXXFLAGS = ${CUSTOM_CXXFLAGS}" >> ${FILE}
|
||
|
||
#
|
||
# THIRD PARTY CXXFLAGS
|
||
#
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
if [ -n "`value_of \"PROVIDE_PKG_${i}\"`" ]; then
|
||
print_as_shell_comment "*** compiler flags for feature ${i} ***" >> ${FILE}
|
||
${_printf} "%s" "${i}_CXXFLAGS = " >> ${FILE}
|
||
set_feature_cxxflags "${i}"
|
||
makefile_print_from_var tmp_cxxflags >> ${FILE}
|
||
${_printf} "\n\n" >> ${FILE}
|
||
fi
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"${i}_SUPPORT\"`" ]; then
|
||
print_as_shell_comment "*** compiler flags for package ${i} ***" >> ${FILE}
|
||
${_printf} "%s" "${i}_PKG_CXXFLAGS = " >> ${FILE}
|
||
set_package_cxxflags "${i}"
|
||
makefile_print_from_var tmp_cxxflags >> ${FILE}
|
||
${_printf} "\n\n" >> ${FILE}
|
||
fi
|
||
done
|
||
|
||
#
|
||
# 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" "CGAL_CXXFLAGS = " >> ${FILE}
|
||
makefile_print_continuationline "${ADDITIONAL_CXXFLAGS}" >> ${FILE}
|
||
makefile_print_continuationline "\$(CUSTOM_CXXFLAGS)" >> ${FILE}
|
||
makefile_print_continuationline "'-I\$(CGAL_INCL_CONF_DIR)'" >> ${FILE}
|
||
makefile_print_continuationline "'-I\$(CGAL_INCL_DIR)'" >> ${FILE}
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
if [ -n "`value_of \"PROVIDE_PKG_${i}\"`" ]; then
|
||
makefile_print_continuationline "\$(${i}_CXXFLAGS)" >> ${FILE}
|
||
fi
|
||
done
|
||
for i in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"${i}_SUPPORT\"`" ]; then
|
||
makefile_print_continuationline "\$(${i}_PKG_CXXFLAGS)" >> ${FILE}
|
||
fi
|
||
done
|
||
${_printf} "\n\n" >> ${FILE}
|
||
|
||
#
|
||
# CGAL_WINLIB_CXXFLAGS
|
||
#
|
||
${_printf} "%s\\\\\n" "CGAL_WINLIB_CXXFLAGS = " >> ${FILE}
|
||
${_printf} "\t%s\n\n" "\$(CGAL_LIB_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
|
||
# USES: i
|
||
write_linker_flags()
|
||
{
|
||
makefile_header "linker flags" >> ${FILE}
|
||
|
||
print_as_shell_comment \
|
||
"*** Flag to define the name of the produced executable ***" \
|
||
>> ${FILE}
|
||
${_printf} "%s%s\n\n" "EXE_OPT = " "${EXE_OPT}${SAVE_THE_BLANK}" >> ${FILE}
|
||
|
||
#
|
||
# THIRD PARTY LIBPATHFLAGS
|
||
#
|
||
RUNTIME_PATH=''
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
if [ -n "`value_of \"PROVIDE_PKG_${i}\"`" ]; then
|
||
print_as_shell_comment "*** libpath flags for feature ${i} ***" >> ${FILE}
|
||
${_printf} "%s" "${i}_LIBPATHFLAGS = " >> ${FILE}
|
||
set_feature_libpathflags "${i}"
|
||
_append_to RUNTIME_PATH "${tmp_runtimepath}" ""
|
||
makefile_print_from_var tmp_libpathflags >> ${FILE}
|
||
${_printf} "\n\n" >> ${FILE}
|
||
fi
|
||
done
|
||
|
||
#
|
||
# CGAL_LIBPATHFLAGS
|
||
#
|
||
print_as_shell_comment "*** libpath flags for CGAL ***" >> ${FILE}
|
||
${_printf} "%s\\\\\n\t" "CGAL_LIBPATHFLAGS = " >> ${FILE}
|
||
libpath_option_pure `concat_path "\\\$(CGAL_LIB_DIR)" "\\\$(CGAL_OS_COMPILER)"` >> ${FILE}
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
if [ -n "`value_of \"PROVIDE_PKG_${i}\"`" ]; then
|
||
makefile_print_continuationline "\$(${i}_LIBPATHFLAGS)" >> ${FILE}
|
||
fi
|
||
done
|
||
if [ -n "${RUNTIME_LINKER_FLAG}" ]; then
|
||
RUNTIME_PATH="`split_up \"RUNTIME_PATH\" \":\"`"
|
||
if [ -z "${RUNTIME_PATH}" ]; then
|
||
makefile_print_continuationline \
|
||
"${RUNTIME_LINKER_FLAG}`concat_path \"\\\$(CGAL_LIB_DIR)\" \"\\\$(CGAL_OS_COMPILER)\"`" \
|
||
>> ${FILE}
|
||
else
|
||
makefile_print_continuationline \
|
||
"${RUNTIME_LINKER_FLAG}`concat_path \"\\\$(CGAL_LIB_DIR)\" \"\\\$(CGAL_OS_COMPILER)\"`:${RUNTIME_PATH}" \
|
||
>> ${FILE}
|
||
fi
|
||
fi
|
||
${_printf} "\n\n" >> ${FILE}
|
||
|
||
#
|
||
# CUSTOM_LDFLAGS
|
||
#
|
||
print_as_shell_comment \
|
||
"*** Fill in any additional linker flags you need ***" \
|
||
>> ${FILE}
|
||
${_printf} "%s\n\n" "CUSTOM_LDFLAGS = ${CUSTOM_LDFLAGS}" >> ${FILE}
|
||
|
||
#
|
||
# 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} "%s\n\n" "CGAL_LD_LIBPATH =" >> ${FILE}
|
||
${_printf} "%s\n\n" "CGAL_LIBPATH = \$(CGAL_LIBPATHFLAGS)" >> ${FILE}
|
||
else
|
||
${_printf} "%s\n\n" "CGAL_LIBPATH =" >> ${FILE}
|
||
${_printf} "%s\n\n" "CGAL_LD_LIBPATH = \$(CGAL_LIBPATHFLAGS)" >> ${FILE}
|
||
fi
|
||
|
||
#
|
||
# THIRD PARTY LDFLAGS
|
||
#
|
||
for i in ${SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"${i}_SUPPORT\"`" ]; then
|
||
print_as_shell_comment "*** linker flags for package ${i} ***" >> ${FILE}
|
||
${_printf} "%s" "${i}_LDFLAGS = " >> ${FILE}
|
||
set_package_ldflags "${i}"
|
||
makefile_print_from_var tmp_ldflags >> ${FILE}
|
||
${_printf} "\n\n" >> ${FILE}
|
||
fi
|
||
done
|
||
|
||
#
|
||
# CGAL_CGAL_LDFLAGS
|
||
#
|
||
print_as_shell_comment "*** linker flags for CGAL ***" >> ${FILE}
|
||
${_printf} "%s" "CGAL_CGAL_LDFLAGS =" >> ${FILE}
|
||
makefile_print_continuationline "${START_LD_OPT}\$(CGAL_LD_LIBPATH) ${ADDITIONAL_LDFLAGS}" >> ${FILE}
|
||
makefile_print_continuationline "\$(CUSTOM_LDFLAGS)" >> ${FILE}
|
||
makefile_print_continuationline "`lib_option \"CGAL\"`" >> ${FILE}
|
||
${_printf} "\n\n" >> ${FILE}
|
||
|
||
#
|
||
# CGAL_LDFLAGS
|
||
#
|
||
${_printf} "%s" "CGAL_LDFLAGS =" >> ${FILE}
|
||
makefile_print_continuationline "\$(CGAL_CGAL_LDFLAGS)" >> ${FILE}
|
||
# FIXME: this special treatment is not so nice...
|
||
if [ -d "${CGAL_SRC_DIR}/Core" -a "${PROVIDE_PKG_CORE}" = "CGALCORE" ]; then
|
||
makefile_print_continuationline "`lib_option \"core++\"`" >> ${FILE}
|
||
fi
|
||
# FIXME: this special treatment is not so nice...
|
||
if [ -d "${CGAL_SRC_DIR}/CGALQt" -a -n "${PROVIDE_PKG_QT}" ]; then
|
||
makefile_print_continuationline "`lib_option \"CGALQt\"`" >> ${FILE}
|
||
fi
|
||
for i in ${R_SUPPORT_PKGS}; do
|
||
if [ -n "`value_of \"${i}_SUPPORT\"`" ]; then
|
||
makefile_print_continuationline "\$(${i}_LDFLAGS)" >> ${FILE}
|
||
fi
|
||
done
|
||
if [ -n "${CYGWIN_COMPILER}" ]; then
|
||
# Adding psapi.lib only for Windows needed for Memory_sizer
|
||
makefile_print_continuationline "`lib_option psapi`" >> ${FILE}
|
||
fi
|
||
if [ -n "${MATH_LIB}" ]; then
|
||
makefile_print_continuationline "`math_ldflags`" >> ${FILE}
|
||
fi
|
||
${_printf} "\n\n" >> ${FILE}
|
||
|
||
|
||
print_as_shell_comment " The following flags are obsolete" >> ${FILE}
|
||
${_printf} "%s\n\n" "CGAL_WINDOW_LDFLAGS = \$(CGAL_LDFLAGS)" >> ${FILE}
|
||
${_printf} "%s\n\n" "CGAL_GEOWIN_LDFLAGS = \$(CGAL_LDFLAGS)" >> ${FILE}
|
||
${_printf} "%s\n\n" "CGAL_QT_LDFLAGS = \$(CGAL_LDFLAGS)" >> ${FILE}
|
||
|
||
}
|
||
|
||
# create the include makefile for current configuration
|
||
# USES: i _tmp
|
||
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 = `os_path \"${CGAL_INCL_DIR}\"`" >> ${FILE}
|
||
${_printf} "%s\n" "CGAL_LIB_DIR = `os_path \"${CGAL_LIB_DIR}\"`" >> ${FILE}
|
||
|
||
#
|
||
# CGAL_OS_COMPILER
|
||
#
|
||
makefile_header "os/compiler description" >> ${FILE}
|
||
${_printf} "%s\n" "CGAL_OS_COMPILER = ${CGAL_OS_COMPILER}" >> ${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
|
||
|
||
#
|
||
# QT_MOC
|
||
#
|
||
print_as_shell_comment "*** Qt meta object compiler executable ***" >> ${FILE}
|
||
if [ -n "`value_of \"PROVIDE_PKG_QT\"`" ]; then
|
||
${_printf} "%s\\\\\n" "QT_MOC = " >> ${FILE}
|
||
${_printf} "\t%s\n\n" "`posix_path \"${QTDIR}/bin/moc\"`" >> ${FILE}
|
||
else
|
||
print_as_shell_comment " (No Qt; therefore, we fake it...)" >> ${FILE}
|
||
${_printf} "%s\n\n" "QT_MOC = echo dummymoc" >> ${FILE}
|
||
fi
|
||
|
||
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}
|
||
${_printf} "%s\n" "CGAL_CORE_SHARED_LIB = libcore++${SHARED_LIB_EXT}" >> ${FILE}
|
||
${_printf} "%s\n" "CGAL_QT_SHARED_LIB = libCGALQt${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} ${CGAL_SHARED_LIB_INSTALL_NAME} -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
|
||
${_rm} -f "$1"
|
||
${_mv} "$1.TEMP" "$1"
|
||
else
|
||
${_printf} "%s\n" "Error sed replacement failed in replace_line()"
|
||
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
|
||
|
||
for FILE in `${_ls} "${CGAL_EXAMPLE_DIR}"/*/makefile 2>/dev/null | ${_sed} 's/ //g'`; do
|
||
FILE="`echo ${FILE} | ${_sed} 's// /g'`"
|
||
replace_line "${FILE}" CGAL_MAKEFILE "CGAL_MAKEFILE = `multi_escape_special \"${CGAL_MAKEFILE}\"`"
|
||
done
|
||
|
||
if [ -d "${CGAL_TEST_DIR}" ]; then
|
||
for FILE in `${_ls} "${CGAL_TEST_DIR}"/*/makefile 2>/dev/null | ${_sed} 's/ //g'`; do
|
||
FILE="`echo ${FILE} | ${_sed} 's// /g'`"
|
||
replace_line "${FILE}" CGAL_MAKEFILE "CGAL_MAKEFILE = `multi_escape_special \"${CGAL_MAKEFILE}\"`"
|
||
done
|
||
fi
|
||
|
||
}
|
||
|
||
# compile $1 $2
|
||
# $1 = libCGAL, libCore, libCGALQt ...
|
||
# $2 = static, shared
|
||
# return 0, iff success
|
||
_do_compile()
|
||
{
|
||
${_printf} "%s" "${_LEFTSPACE}Building $1 $2..."
|
||
if [ -f "${COMPILE_LOGFILE}" -a ! -w "${COMPILE_LOGFILE}" ]; then
|
||
${_rm} -f "${COMPILE_LOGFILE}"
|
||
fi
|
||
${_rm} -f *"${OBJ_EXT}"
|
||
MAKE_OPTION="-k CGAL_MAKEFILE=$CGAL_MAKEFILE"
|
||
|
||
case "$2" in
|
||
static)
|
||
MAKE_OPTION="${MAKE_OPTION} CXXFLAGS=\$(CGAL_LIB_CXXFLAGS) static_lib";;
|
||
shared)
|
||
MAKE_OPTION="${MAKE_OPTION} CXXFLAGS=\$(CGAL_SHARED_LIB_CXXFLAGS) shared_lib";;
|
||
esac
|
||
|
||
if make ${MAKE_OPTION} >"${COMPILE_LOGFILE}" 2>&1; then
|
||
log_print "Compilation of $1 $2 ${_libname} succeeded."
|
||
${_printf} "%s\n" " done."
|
||
ANY_LIB_COMPILED='y'
|
||
return 0
|
||
else
|
||
log_print "Compilation of $1 $2 ${_libname} failed."
|
||
log_print "vvvvvvvvvvvv error messages below vvvvvvvvvvvv"
|
||
eval ${_cat} \"${COMPILE_LOGFILE}\" ${INSTALL_LOGFILE_REDIRECTION}
|
||
log_print "^^^^^^^^^^^^ error messages above ^^^^^^^^^^^^"
|
||
${_printf} "\n%s\n" "${_LEFTSPACE}Compilation of $1 $2 failed."
|
||
${_printf} "%s\n" "${_LEFTSPACE}You will be shown a log now ..."
|
||
print_filled_line
|
||
wait_for_enter
|
||
${PAGER:-${_cat}} "${COMPILE_LOGFILE}"
|
||
write_buffer "\n"
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# make lib dir
|
||
make_lib_dir()
|
||
{
|
||
_libname="${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}"
|
||
_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."
|
||
}
|
||
|
||
# USES: i _tmp
|
||
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"
|
||
}
|
||
|
||
# USES: i _tmp
|
||
build_cgal()
|
||
{
|
||
cd "${CGAL_SRC_DIR}/CGAL"
|
||
if _do_compile libCGAL static; 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!";;
|
||
*) _do_compile libCGAL shared;;
|
||
esac
|
||
fi
|
||
# FIXME: Should this be hardcoded here?
|
||
# Move CGALQt into libCGAL?
|
||
if [ -d "${CGAL_SRC_DIR}/CGALQt" -a -n "${PROVIDE_PKG_QT}" ]; then
|
||
cd "${CGAL_SRC_DIR}/CGALQt"
|
||
_do_compile libCGALQt static
|
||
# _do_compile libCGALQt shared # Not yet ready
|
||
fi
|
||
if [ -d "${CGAL_SRC_DIR}/Core" -a "${PROVIDE_PKG_CORE}" = "CGALCORE" ]; then
|
||
cd "${CGAL_SRC_DIR}/Core"
|
||
_do_compile libCore static
|
||
# _do_compile libCore shared # Not yet ready
|
||
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
|
||
if [ -z "${INSTALL_INTERACTIVE}" ]; then
|
||
exit 1
|
||
fi
|
||
fi
|
||
}
|
||
|
||
print_lib_information()
|
||
{
|
||
if [ -r "${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}/${CGAL_LIBNAME}" ]; then
|
||
print_line "Libs built: `_get_timestamp \"${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}/${CGAL_LIBNAME}\"`"
|
||
else
|
||
print_line "There are no libs for this os/compiler."
|
||
fi
|
||
}
|
||
|
||
# USES: _tmp
|
||
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/${CGAL_OS_COMPILER}"
|
||
_check_dir_exists_create "${_CGAL_IDIR}"
|
||
_do_command \
|
||
"cd \"${CGAL_LIB_DIR}/${CGAL_OS_COMPILER}\"; ${_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
|
||
# USES: ii
|
||
_build_one()
|
||
{
|
||
log_to_file_and_screen
|
||
log_print
|
||
log_print \
|
||
"--------------------------------------------------------"
|
||
log_print "Build on `${_basename} \"$1\"`:"
|
||
log_print \
|
||
"--------------------------------------------------------"
|
||
log_to_file
|
||
try_to_get_var_from_config_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}/${CGAL_OS_COMPILER}"
|
||
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
|
||
${_printf} "\n\n"
|
||
_build_one config/install/${BUILD_ONE_CONFIG}
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------
|
||
# (re)build all function
|
||
#
|
||
build_all()
|
||
{
|
||
guess_os log_print
|
||
${_printf} "\n\n"
|
||
for i in `${_ls} "${CGAL_INSTALL_CONF_DIR}"/${SYST}* 2>/dev/null | ${_sed} 's/ //g'`
|
||
do
|
||
i="`echo ${i} | ${_sed} 's// /g'`"
|
||
_build_one "$i"
|
||
done
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# test menu
|
||
#
|
||
# (It is now an undocumented feature, but Andreas still uses it.)
|
||
|
||
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_${CGAL_OS_COMPILER}" \
|
||
>> "${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
|
||
${PAGER:-${_cat}} "${TEST_LOGFILE}"
|
||
write_buffer "\n"
|
||
print_filled_line
|
||
cd "${CGAL_DIR}"
|
||
wait_for_enter
|
||
return
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# upgrade
|
||
#
|
||
|
||
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."
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# support menu
|
||
#
|
||
|
||
# translate a given integer $1 from [1..24]
|
||
# into the corresponding char from [1..9,A..P]
|
||
_int_to_char()
|
||
{
|
||
if [ ${1} -lt 10 ]; then
|
||
echo ${1}
|
||
else
|
||
echo ${1} | ${_awk} '{printf "%c\n",$1+55}'
|
||
fi
|
||
}
|
||
|
||
# $1 is the feature
|
||
support_feature_menu()
|
||
{
|
||
while [ 0 ]; do
|
||
menu_header "${1}"
|
||
print_line "${_bold_on}<0>${_bold_off} Auto-find library"
|
||
print_line "${_bold_on}<1>${_bold_off} Set ${1}_INCL_DIR"
|
||
_tmp3="`value_of \"${1}_INCL_DIR\"`"
|
||
print_multi_line "${_tmp3:-<not set>}"
|
||
print_line "${_bold_on}<2>${_bold_off} Set ${1}_LIB_DIR"
|
||
_tmp3="`value_of \"${1}_LIB_DIR\"`"
|
||
print_multi_line "${_tmp3:-<not set>}"
|
||
ii=3
|
||
_tmp3="`value_of PROVIDE_PKG_${1}`"
|
||
for jj in `value_of "SUPPORT_PKG_${1}"`; do
|
||
_tmp2="`value_of \"${jj}_DESCRIPTION\"`"
|
||
if [ -n "${_tmp2}" ]; then
|
||
_tmp2="${jj} (${_tmp2})"
|
||
else
|
||
_tmp2="${jj}"
|
||
fi
|
||
if [ "${_tmp3}" = "${jj}" ]; then
|
||
print_line "${_bold_on}<`_int_to_char ${ii}`>${_bold_off} Disable ${_tmp2}"
|
||
print_multi_line "--> provides ${1} support currently."
|
||
else
|
||
print_line "${_bold_on}<`_int_to_char ${ii}`>${_bold_off} Use ${_tmp2}"
|
||
fi
|
||
eval "${_EXPR} ${ii} + 1"
|
||
ii=${_result}
|
||
done
|
||
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
|
||
menu_tailer 'Support Menu'
|
||
|
||
case $KEY in
|
||
t|T) go_down_lines 3
|
||
flush_buffer
|
||
test_setup;;
|
||
q|Q) return;;
|
||
0) go_down_lines 3
|
||
flush_buffer
|
||
autofind_feature "${1}" ''
|
||
if [ -z "`value_of \"PROVIDE_PKG_${1}\"`" ]; then
|
||
write_buffer "\n"
|
||
print_filled_line
|
||
print_empty_line
|
||
print_headline "Sorry, could not find ${1}."
|
||
wait_for_enter
|
||
fi
|
||
;;
|
||
1) change_value "${1}_INCL_DIR"
|
||
eval "`value_of \"PROVIDE_PKG_${1}\"`_TEST_PASSED=''"
|
||
SETUP_COMPLETE=''
|
||
;;
|
||
2) change_value "${1}_LIB_DIR"
|
||
eval "`value_of \"PROVIDE_PKG_${1}\"`_TEST_PASSED=''"
|
||
SETUP_COMPLETE=''
|
||
;;
|
||
*)
|
||
ii=3
|
||
for jj in `value_of "SUPPORT_PKG_${1}"`; do
|
||
if [ "${KEY}" = "`_int_to_char ${ii}`" ]; then
|
||
_tmp3="`value_of PROVIDE_PKG_${1}`"
|
||
disable_support "${_tmp3}"
|
||
if [ "${_tmp3}" != "${jj}" ]; then
|
||
enable_support "${jj}"
|
||
eval "${jj}_TEST_PASSED=''"
|
||
fi
|
||
break
|
||
fi
|
||
eval "${_EXPR} ${ii} + 1"
|
||
ii=${_result}
|
||
done;;
|
||
esac
|
||
done
|
||
|
||
}
|
||
|
||
autofind_packages()
|
||
{
|
||
log_print "Trying to autofind 3rd party libraries..."
|
||
for pkg in ${SUPPORT_PKGS}; do
|
||
test_support_pkg "${pkg}" ''
|
||
if [ $? -eq 1 ]; then enable_support "${pkg}"; fi
|
||
done
|
||
}
|
||
|
||
# try to autofind a package that provides feature $1
|
||
autofind_feature()
|
||
{
|
||
if [ -z "`value_of \"PROVIDE_PKG_${1}\"`" ]; then
|
||
log_print "Trying to auto-find ${1}..."
|
||
for pkg in `value_of "SUPPORT_PKG_${1}"`; do
|
||
test_support_pkg "${pkg}" ''
|
||
if [ $? -eq 1 ]; then enable_support "${pkg}"; fi
|
||
done
|
||
fi
|
||
}
|
||
|
||
support_menu()
|
||
{
|
||
while [ 0 ]; do
|
||
menu_header 'Support'
|
||
print_line "${_bold_on}<0>${_bold_off} Auto-find all libraries"
|
||
i=1
|
||
for j in ${SUPPORT_FEATURES}; do
|
||
print_line "${_bold_on}<`_int_to_char ${i}`>${_bold_off} ${j} Menu"
|
||
eval "${_EXPR} ${i} + 1"
|
||
i=${_result}
|
||
done
|
||
|
||
print_line "${_bold_on}<T>${_bold_off} Test (and save) setup"
|
||
menu_tailer 'Main Menu'
|
||
|
||
KEY=`echo "${KEY}" | ${_tr} [:lower:] [:upper:]`
|
||
case $KEY in
|
||
t|T) go_down_lines 3
|
||
flush_buffer
|
||
test_setup;;
|
||
q|Q) return;;
|
||
0) go_down_lines 3
|
||
flush_buffer
|
||
autofind_packages;;
|
||
*)
|
||
i=1
|
||
for j in ${SUPPORT_FEATURES}; do
|
||
if [ "${KEY}" = "`_int_to_char ${i}`" ]; then
|
||
support_feature_menu "${j}"
|
||
break
|
||
fi
|
||
eval "${_EXPR} ${i} + 1"
|
||
i=${_result}
|
||
done;;
|
||
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 [ -d "${CGAL_TEST_DIR}" -a -n "${LIB_COMPILED}" ]; then
|
||
print_line "${_bold_on}<R>${_bold_off} Run CGAL testsuite"
|
||
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
|
||
;;
|
||
a|A)
|
||
reset_all_test_variables
|
||
go_down_lines 3
|
||
flush_buffer
|
||
test_setup;;
|
||
t|T)
|
||
go_down_lines 3
|
||
flush_buffer
|
||
test_setup;;
|
||
r|R)
|
||
if [ -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 "${INSTALL_INTERACTIVE}" ]; then
|
||
${_printf} "."
|
||
log_to_file
|
||
else
|
||
log_to_screen
|
||
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
|
||
guess_os 'log_print'
|
||
case ${SYST} in
|
||
*CYGWIN*) _check_for_sysutil cygpath y;;
|
||
esac
|
||
${_printf} "\n%s\n" \
|
||
"--------------------------------------------------------"
|
||
${_printf} "%s\n" "Settings from Command Line/Environment:"
|
||
${_printf} "%s\n" \
|
||
"--------------------------------------------------------"
|
||
flush_buffer
|
||
if [ -n "${INSTALL_INTERACTIVE}" -a -n "${INSTALL_VERBOSE}" ]; then
|
||
write_buffer "\n\n"
|
||
print_filled_line
|
||
wait_for_enter
|
||
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}/${CGAL_OS_COMPILER}\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
|
||
#
|
||
|
||
set_compiler_from_command_line()
|
||
{
|
||
_check_comp_executable "${COMPILER}"
|
||
log_to_file
|
||
COMPILER="`compiler_absolute ${COMPILER}`"
|
||
if [ -z "${INSTALL_INTERACTIVE}" ]; then log_to_screen; fi
|
||
set_ostype
|
||
set_compiler_flags
|
||
}
|
||
|
||
# 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
|
||
}
|
||
|
||
# ---------------------------------------------------------------------
|
||
# Here starts the main part
|
||
#
|
||
|
||
_WHAT_TO_DO=''
|
||
_CONFLICT=''
|
||
_awk=awk
|
||
_tee=tee
|
||
_sed=sed
|
||
_tr=tr
|
||
_printf=printf
|
||
_rm=rm
|
||
CGAL_INSTALL_VERSION="`_install_version_number`"
|
||
|
||
# Set ${TAUCS_OSTYPE} (variable indicating the platform name for TAUCS library)
|
||
set_TAUCS_OSTYPE
|
||
|
||
# first quickly process "trivial" commandline options
|
||
# (starting the whole parsing process would slowdown too much...)
|
||
case ${*} in
|
||
-version*|--version*|-VERSION*|--version*)
|
||
${_printf} "%s\n" "${CGAL_INSTALL_CGAL} is ${CGAL_INSTALL_VERSION}."
|
||
exit 0
|
||
;;
|
||
-ostype_tag*|--ostype_tag*|-OSTYPE_TAG*|--OSTYPE_TAG*) _tmp=thisisnotused;;
|
||
-os*|--os*|-OS*|--OS*)
|
||
_WHAT_TO_DO='ostype'
|
||
# legacy mode: used to have a compulsory compiler argument
|
||
if [ -n "$2" ]; then
|
||
case $2 in
|
||
# not sure whether it's ok to have empty statement here...
|
||
-*) _tmp=thisisnotused;;
|
||
*) COMPILER=$2; shift;;
|
||
esac
|
||
fi
|
||
shift
|
||
;;
|
||
esac
|
||
|
||
if [ -z "${_WHAT_TO_DO}" ]; then
|
||
init_logfiles
|
||
log_to_file
|
||
initial_check
|
||
|
||
# --- begin parsing commandline options ---
|
||
while [ ${#} -gt 0 ]; do
|
||
# make everything lowercase and strip possible leading -- to -
|
||
_arg="`echo ${*} | ${_tr} [:lower:] [:upper:] | ${_sed} 's/^--/-/'`"
|
||
case ${_arg} in
|
||
-CGAL_DIR*)
|
||
if set_variable_from_command_line 'CGAL_DIR' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
set_dirs_dependant_on_cgal_dir
|
||
initial_check
|
||
shift; continue
|
||
;;
|
||
-PREFIX*)
|
||
if set_variable_from_command_line 'CGAL_INSTALL_DIR' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
shift; continue
|
||
;;
|
||
-WITHOUT-AUTOFIND*)
|
||
CGAL_AUTOFIND_PKGS=''
|
||
shift; continue
|
||
;;
|
||
esac
|
||
MATCH=''
|
||
for i in ${SUPPORT_FEATURES}; do
|
||
case ${_arg} in
|
||
-${i}_INCL_DIR*|-${i}_INCLDIR*)
|
||
if set_variable_from_command_line "${i}_INCL_DIR" "$1" "$2"; then
|
||
shift
|
||
fi
|
||
MATCH=y
|
||
;;
|
||
-${i}_LIB_DIR*|-${i}_LIBDIR*)
|
||
if set_variable_from_command_line "${i}_LIB_DIR" "$1" "$2"; then
|
||
shift
|
||
fi
|
||
MATCH=y
|
||
;;
|
||
esac
|
||
if [ -n "${MATCH}" ]; then break; fi
|
||
done
|
||
if [ -n "${MATCH}" ]; then shift; continue; fi
|
||
for i in ${R_SUPPORT_PKGS}; do
|
||
case ${_arg} in
|
||
-WITH-${i}*)
|
||
enable_support "${i}"
|
||
write_buffer "${_LEFTSPACE}Enable ${i} support.\n"
|
||
MATCH=y
|
||
;;
|
||
esac
|
||
if [ -n "${MATCH}" ]; then break; fi
|
||
done
|
||
if [ -n "${MATCH}" ]; then shift; continue; fi
|
||
case ${_arg} in
|
||
-QT_DIR*)
|
||
warn_deprecated ${1}
|
||
if set_variable_from_command_line 'QT_DIR' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-QT_MOC*)
|
||
warn_deprecated ${1}
|
||
if set_variable_from_command_line 'QT_MOC' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-QT*) warn_deprecated ${1};;
|
||
-CXXFLAGS*|-CUSTOM_CXXFLAGS*)
|
||
if set_variable_from_command_line 'CUSTOM_CXXFLAGS' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-CXX*)
|
||
# legacy mode: COMPILER might have been set from -ni
|
||
if [ -n "${COMPILER}" ]; then
|
||
_CONFLICT='y'
|
||
fi
|
||
if set_variable_from_command_line 'COMPILER' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-LDFLAGS*|-CUSTOM_LDFLAGS*)
|
||
if set_variable_from_command_line 'CUSTOM_LDFLAGS' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-OSTYPE_TAG*|-CUSTOM_OSTYPE_TAG*)
|
||
if set_variable_from_command_line 'CUSTOM_OSTYPE_TAG' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
CUSTOM_OSTYPE_TAG=`echo ${CUSTOM_OSTYPE_TAG} | remove_special_chars`
|
||
;;
|
||
-OS*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='ostype'
|
||
# legacy mode: used to have a compulsory compiler argument
|
||
if [ -n "$2" ]; then
|
||
case $2 in
|
||
# not sure whether it's ok to have empty statement here...
|
||
-*) _tmp=thisisnotused;;
|
||
*) COMPILER=$2; shift;;
|
||
esac
|
||
fi
|
||
;;
|
||
-NON-INTERACTIVE*|-NI*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='non-interactive'
|
||
# legacy mode: used to have a compulsory compiler argument
|
||
if [ -n "$2" ]; then
|
||
case $2 in
|
||
-*) _tmp=thisisnotused;;
|
||
*) COMPILER=$2; shift;;
|
||
esac
|
||
fi
|
||
;;
|
||
-I*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='interactive'
|
||
;;
|
||
-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*) INSTALL_VERBOSE='y';;
|
||
-V*)
|
||
${_printf} "%s\n" "${CGAL_INSTALL_CGAL} is ${CGAL_INSTALL_VERSION}."
|
||
exit 0
|
||
;;
|
||
-REBUILD-ALL*|-RA*|-RBA*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='rebuild-all'
|
||
;;
|
||
-BUILD-ALL*|-BA*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='build-all'
|
||
;;
|
||
-REBUILD*|-R*|-RB*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='rebuild'
|
||
if set_variable_from_command_line 'BUILD_ONE_CONFIG' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-BUILD*|-B*)
|
||
if [ -n "${_WHAT_TO_DO}" ]; then _CONFLICT='y'; fi
|
||
_WHAT_TO_DO='build'
|
||
if set_variable_from_command_line 'BUILD_ONE_CONFIG' "$1" "$2"; then
|
||
shift
|
||
fi
|
||
;;
|
||
-DISABLE-SHARED*) ENABLE_SHARED='';;
|
||
*) _WHAT_TO_DO='help';;
|
||
esac
|
||
shift
|
||
done
|
||
# --- end of parsing commandline options ---
|
||
fi
|
||
|
||
# ---------------------------------------------------------------------
|
||
# process environment variables
|
||
#
|
||
|
||
if [ -z "${CUSTOM_CXXFLAGS}" -a -n "${CXXFLAGS}" ]; then
|
||
CUSTOM_CXXFLAGS="${CXXFLAGS}"
|
||
write_buffer "${_LEFTSPACE}Set CUSTOM_CXXFLAGS from \$CXXFLAGS.\n"
|
||
fi
|
||
if [ -z "${CUSTOM_LDFLAGS}" -a -n "${LDFLAGS}" ]; then
|
||
CUSTOM_LDFLAGS="${LDFLAGS}"
|
||
write_buffer "${_LEFTSPACE}Set CUSTOM_LDFLAGS from \$LDFLAGS.\n"
|
||
fi
|
||
if [ -z "${COMPILER}" -a -n "${CXX}" ]; then
|
||
COMPILER="${CXX}"
|
||
write_buffer "${_LEFTSPACE}Set COMPILER from \$CXX.\n"
|
||
fi
|
||
${_printf} "${_BUF}" >> "${INSTALL_LOGFILE}"
|
||
|
||
# ---------------------------------------------------------------------
|
||
# postprocess commandline settings
|
||
#
|
||
|
||
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
|
||
if [ -z "${COMPILER}" ]; then exit_on_error "No compiler specified"; fi
|
||
set_compiler_from_command_line
|
||
flush_buffer
|
||
log_to_file
|
||
${_printf} "\n%s\n" \
|
||
"--------------------------------------------------------"
|
||
${_printf} "%s\n" "Configuring CGAL:"
|
||
${_printf} "%s\n" \
|
||
"--------------------------------------------------------"
|
||
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
|
||
if [ -z "${COMPILER}" ]; then
|
||
search_for_compilers
|
||
if [ ${_COMPILER_NUMBER} -gt 2 ]; then
|
||
compiler_choose_menu 'Main Menu'
|
||
fi
|
||
else
|
||
_COMPILER_NUMBER=1
|
||
set_compiler_from_command_line
|
||
_register_compiler "${COMPILER}"
|
||
_set_support
|
||
fi
|
||
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
|
||
${_printf} "%s\n" "${CGAL_OS_COMPILER}"
|
||
;;
|
||
*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
|
||
|