mirror of https://github.com/CGAL/cgal
1679 lines
71 KiB
TeX
1679 lines
71 KiB
TeX
%%
|
|
%% *** CGAL Installation Guide ***
|
|
%%
|
|
%% file: installation.tex
|
|
%%
|
|
%% authors: Michael Hoffmann, Dima Pasechnik and Wieger Wesselink
|
|
%%
|
|
%% $Revision$ $Date$
|
|
%%
|
|
|
|
%% macro for GNU
|
|
\newcommand{\gnu}{\textsc{Gnu}}
|
|
|
|
%% macro for QT
|
|
\newcommand{\qt}{\textsc{Qt}}
|
|
|
|
%% macro for GMP
|
|
\newcommand{\gmp}{\textsc{Gmp}}
|
|
|
|
%% macro for Core
|
|
\newcommand{\core}{\textsc{Core}}
|
|
|
|
%% macro for Windows-specific installation
|
|
\newcommand{\MSInst}{Windows-specific Installation}
|
|
|
|
%% macro for g++
|
|
\newcommand{\Gcc}[1]{\gnu~\texttt{g++}~{\rm #1}}
|
|
\newcommand{\gccurl}{\path'http://gcc.gnu.org/'}
|
|
|
|
%% macro for SUNPRO CC
|
|
\newcommand{\sunprocc}[1]{\textsc{Sunpro}~\texttt{CC}~{\rm #1}}
|
|
\newcommand{\sunproccurl}{\path'http://www.sun.com/software/Developer-products/cplusplus/'}
|
|
|
|
%% macro for SGI CC
|
|
\newcommand{\mipsprocc}{\textsc{SGI}~Mips(Pro)~\texttt{CC}}
|
|
\newcommand{\mipsprourl}{\path'http://www.sgi.com/developers/devtools/languages/mipspro.html'}
|
|
|
|
%% macro for Borland C++
|
|
\newcommand{\bcc}[1]{\textsc{Borland}~\texttt{C++}~{\rm #1}}
|
|
\newcommand{\bccurl}{\path'http://www.inprise.com/bcppbuilder/'}
|
|
|
|
%% macro for Microsoft Visual C++
|
|
\newcommand{\msvc}[1]{\textsc{MS}~Visual~\texttt{C++}~{\rm #1}}
|
|
\newcommand{\msvcurl}{\path'http://msdn.microsoft.com/visualc/'}
|
|
|
|
%% macro for Intel C++ Compiler
|
|
\newcommand{\icl}[1]{\textsc{Intel}~\texttt{C++}~{\rm #1}}
|
|
\newcommand{\iclurl}{\path'http://developer.intel.com/software/products/compilers/'}
|
|
|
|
%% macro for Microsoft Windows
|
|
\newcommand{\mswin}{\textsc{MS}~Windows}
|
|
|
|
%% macro for CGAL release number
|
|
%% \newcommand{\cgalrelease}{2.3}
|
|
|
|
%% macro for CGAL directory
|
|
\newcommand{\cgaldir}{\texttt{CGAL-\cgalrelease}}
|
|
|
|
%% macro for YOUR CGAL directory :)
|
|
\newcommand{\yourcgaldir}{$<$\textit{insert your \cgaldir\ dir}$>$}
|
|
|
|
%% macro for CGAL install config directory
|
|
\newcommand{\cgalinstconfdir}{\cgaldir\texttt{/config/install}\index{directories!config/install@\texttt{config/install}}}
|
|
|
|
%% macros for WWW pages
|
|
\newcommand{\cgalhomepage}{\path'http://www.cgal.org'}
|
|
\newcommand{\gmppage}{\path'http://www.gnu.org/software/gmp'}
|
|
\newcommand{\corepage}{\path'http://www.cs.nyu.edu/exact/core/'}
|
|
\newcommand{\ledapage}{\path'http://www.mpi-sb.mpg.de/LEDA'}
|
|
\newcommand{\trolltechpage}{\path'http://www.trolltech.com'}
|
|
\newcommand{\qtpage}{\path'http://doc.trolltech.com/'}
|
|
\newcommand{\qtmocpage}{\path'http://doc.trolltech.com/moc.html'}
|
|
|
|
%% write index in typewriter type. (c) Susan :-)
|
|
\newcommand{\TTindex}[1]{\index{#1@{\tt #1}}}
|
|
\newcommand{\TTsubindex}[2]{\index{#1@{\tt #1}!{#2}}}
|
|
\newcommand{\TTsubindextwo}[2]{\index{#1!#2@{\tt #2} }}
|
|
|
|
\lcHtml{\chapter{Installation}}
|
|
\section{Introduction}
|
|
|
|
\cgal\ stands for \textit{Computational Geometry Algorithms Library}.
|
|
It is a software library written in \CC, whose development started in
|
|
an {\sc Esprit Ltr} project. The goal of \cgal\ is to make the large
|
|
body of geometric algorithms developed in the field of computational
|
|
geometry available for industrial application.
|
|
|
|
This document describes how to install \cgal\ on Unix-like systems.
|
|
Besides that, you will find some information about the makefile
|
|
structure of \cgal\ and the support for using \cgal\ together with
|
|
other software libraries, such as the \gnu\ Multiple Precision library
|
|
\gmp\footnote{\gmppage}, the \core\ library\footnote{\corepage} for
|
|
robust numerical and geometric computation, \leda, the Library of
|
|
Efficient Datatypes and Algorithms\footnote{\ledapage}, or
|
|
Trolltech's\footnote{\trolltechpage} \qt\ toolkit.
|
|
|
|
\section{Prerequisites}\label{sec:prerequisites}
|
|
|
|
In order to build the \cgal\ libraries you need a \CC\ compiler. Most
|
|
recent compilers on Unix platforms and \mswin\ are supported, provided
|
|
that they reasonnably conform to the ISO 14882 standard for \CC.
|
|
|
|
\cgaldir\ supports the following compilers/operating systems:
|
|
|
|
\begin{center}\index{compilers!supported}\index{supported compilers}
|
|
\renewcommand{\arraystretch}{1.3}
|
|
\gdef\lcTabularBorder{2}
|
|
\begin{tabular}{|l|l|} \hline
|
|
\textbf{compiler} & \textbf{operating system}\\\hline\hline
|
|
\mipsprocc\ 7.3 (n32 and 64) \footnotemark[7]
|
|
& IRIX 6.5\\\hline
|
|
\Gcc{2.95.3, 3.0, 3.1, 3.2, 3.3} \footnotemark[9]
|
|
& IRIX 6.5 / Solaris 2.6+ / Linux 2.x /
|
|
\mswin\ 95/98/2000/XP/NT4\footnotemark[10]\\\hline
|
|
\sunprocc{5.3, 5.4, 5.5} \footnotemark[11]
|
|
& Solaris 2.6+\\\hline
|
|
\msvc{7.1} (\textsc{.NET}) \footnotemark[12]
|
|
& \mswin\ 95/98/2000/XP/NT4\footnotemark[10]\\\hline
|
|
\icl{7.1} \footnotemark[13]
|
|
& \mswin\ 95/98/2000/XP/NT4\footnotemark[10]\\\hline
|
|
%% \bcc{5.5.1} \footnotemark[13]
|
|
%% & \mswin\ 95/98/2000/XP/NT4\footnotemark[10]\\\hline
|
|
\end{tabular}
|
|
\end{center}
|
|
\footnotetext[7]{\mipsprourl}\addtocounter{footnote}{1}
|
|
\footnotetext[9]{\gccurl}\addtocounter{footnote}{1}
|
|
\footnotetext[10]{with Cygwin
|
|
(\path~http://www.cygwin.com~)}\addtocounter{footnote}{1}
|
|
\footnotetext[11]{\sunproccurl}\addtocounter{footnote}{1}
|
|
\footnotetext[12]{\msvcurl}\addtocounter{footnote}{1}
|
|
\footnotetext[13]{\iclurl}\addtocounter{footnote}{1}
|
|
%%\footnotetext[13]{\bccurl}\addtocounter{footnote}{1}
|
|
\addtocounter{footnote}{1}
|
|
|
|
If you are going to install \cgal\ using
|
|
Cygwin\footnote{\path~http://www.cygwin.com~}, please read
|
|
Section~\ref{sec:cygwin} first.
|
|
|
|
For the \sunprocc{5.3} compiler, the latest patch set, in particular
|
|
Patch 111685-05, is required. You can check with \texttt{CC~-V} which
|
|
compiler version you have installed. It should read
|
|
\begin{verbatim}
|
|
CC: Sun WorkShop 6 update 2 C++ 5.3 Patch 111685-05 2002/02/03
|
|
\end{verbatim}
|
|
or later.
|
|
|
|
Note that \Gcc{2.96/97} are not official \texttt{gcc} releases that
|
|
are neither supported by the \texttt{GCC}
|
|
team\footnote{\path'http://gcc.gnu.org/gcc-2.96.html'} nor by \cgal.
|
|
Please upgrade to \Gcc{3}, if you happen to have this compiler.
|
|
|
|
\section{Getting \cgal} \label{sec:gettingcgal}
|
|
\index{CGAL@\cgal!getting}\index{getting \cgal}
|
|
|
|
The \cgal\ library can be downloaded from the \cgal\
|
|
homepage:\index{CGAL@\cgal!homepage}
|
|
\begin{quote}
|
|
\cgalhomepage
|
|
\end{quote}
|
|
and go to the `Download' section. Just follow the instructions on this
|
|
page to obtain your copy of the library.
|
|
|
|
After you have downloaded the file containing the \cgal\ library, you
|
|
have to decompress it. Use the commands
|
|
|
|
\begin{verbatim}
|
|
gunzip <filename>.tar.gz
|
|
tar xvf <filename>.tar
|
|
\end{verbatim}
|
|
|
|
Alternatively, your browser might be able to invoke the right
|
|
decompression program by itself.
|
|
|
|
In both cases the directory \cgaldir\ will be created. This directory
|
|
contains the following subdirectories:\index{directories!structure}
|
|
|
|
\begin{center}
|
|
\renewcommand{\arraystretch}{1.3}
|
|
\gdef\lcTabularBorder{2}
|
|
\begin{tabular}{|l|l|} \hline
|
|
\textbf{directory} & \textbf{contents}\\\hline\hline
|
|
\texttt{auxiliary} & packages that can optionally be used with \cgal\\\hline
|
|
\texttt{config} & configuration files for install script\\\hline
|
|
\texttt{demo} & demo programs (some of them need \leda, geomview
|
|
or other third-party products)\\\hline
|
|
\texttt{doc\_html} & documentation (HTML)\\\hline
|
|
\texttt{doc\_pdf} & documentation (PDF)\\\hline
|
|
\texttt{doc\_ps} & documentation (Postscript)\\\hline
|
|
\texttt{examples} & example programs\\\hline
|
|
\texttt{include} & header files\\\hline
|
|
\texttt{lib} & (shared) object libraries\\\hline
|
|
\texttt{make} & files with platform dependent makefile settings\\\hline
|
|
\texttt{scripts} & some useful scripts (e.g. for creating makefiles)\\\hline
|
|
\texttt{src} & source files\\\hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
The directory \texttt{auxiliary} contains a distribution of the \gnu\
|
|
Multiple Precision library \gmp\footnote{\gmppage}. The directory
|
|
\texttt{src/Core} contains a distribution of the \core\
|
|
library\footnote{\corepage} for robust numerical and geometric
|
|
computation. Both libraries are not part of \cgal\ and have their own
|
|
licenses.
|
|
|
|
\subsection{Visualization}\label{sec:vis}
|
|
|
|
The programs in the \texttt{demo} directory provide visual output.
|
|
Most of these use \ccc{CGAL::Qt_widget}, a widget and some helper
|
|
classes that allow to interact with two dimensional \cgal\ objects in
|
|
\qt\ based applications.\index{visualization!Qt}
|
|
|
|
If you have \leda\ installed, you might want to use
|
|
\ccc{CGAL::Window_stream} as an interface between two dimensional
|
|
\cgal\ objects and a \ccc{leda_window}. To be able to use the
|
|
\ccc{Window_stream}, you need do nothing more than compile \cgal\ with
|
|
\leda\ support.\index{visualization!LEDA}
|
|
|
|
Some demo programs for 3D structures require the geomview program for
|
|
visualisation.\index{visualization!geomview} This is available from
|
|
\path'http://www.geomview.org' (note that it does not run on \mswin).
|
|
|
|
\section{Installing \cgal}
|
|
|
|
The directory \cgaldir\ contains a Bourne shell script called
|
|
\texttt{install\_cgal}\TTindex{install\_cgal}
|
|
\index{scripts!\texttt{install\_cgal}}. The script can be run in two
|
|
modes: a menu-driven interactive mode and a non-interactive mode.
|
|
Normally you should use the interactive mode, but in case you run into
|
|
problems with it or do not like it for some reason, you can still use
|
|
the non-interactive mode.
|
|
|
|
We first describe a sample installation in section
|
|
\ref{sec:sample-inst}. This provides you with an overview on how the
|
|
interactive installation works. If you want more detailed information
|
|
about specific menus and their options, take a look at section
|
|
\ref{sec:interactive-mode}. Finally, for the non-interactive mode
|
|
refer to section \ref{sec:non-interactive}.
|
|
|
|
If you want to use \leda\ together with \cgal, have a look at
|
|
section~\ref{sec:leda}.
|
|
|
|
\section{A Sample Installation}\label{sec:sample-inst}
|
|
|
|
In this section we sketch an example installation on a \textsc{Sun}
|
|
running Solaris~2.9 with the \Gcc{3.3} compiler. For a complete
|
|
description of the different menus and their options refer to section
|
|
\ref{sec:interactive-mode}.
|
|
|
|
\subsection{Starting the script}
|
|
|
|
Go to the \cgaldir\ directory and enter the command
|
|
\begin{verbatim}
|
|
./install_cgal -i
|
|
\end{verbatim}
|
|
|
|
You get a message indicating the \cgal\ version you are going to
|
|
install and that you are running the interactive mode. Then it takes
|
|
some time while the script locates a number of utility programs. You
|
|
will not get informed about this\footnote{If you are that curious what
|
|
happens exactly, have a look at the file
|
|
\texttt{\cgaldir/install.log}.\TTindex{install.log}}, but see some
|
|
dots written to the screen indicating progress.
|
|
|
|
{\ccTexHtml{\scriptsize}{}
|
|
\begin{alltt}
|
|
--------------------------------------------------------
|
|
This is the install script for CGAL \cgalrelease
|
|
--------------------------------------------------------
|
|
|
|
starting interactive mode - one moment, please
|
|
.......
|
|
|
|
Choosing compiler GNU 3.3.2.
|
|
|
|
\end{alltt}}
|
|
|
|
If there is any compiler installed on your system and accessible
|
|
through your \texttt{PATH} environment variable that is supported by
|
|
\cgal, one of these compilers is chosen. If there is more than one
|
|
compiler installed on your system (and supported by \cgal), you may
|
|
choose to use a different compiler from the compiler menu (cf.
|
|
Section~\ref{sec:compiler-menu}).
|
|
|
|
A menu similar to the following will appear on your screen.\index{main
|
|
menu}\index{menus!main}
|
|
|
|
{\ccTexHtml{\scriptsize}{} \label{pic:main-menu}
|
|
\begin{alltt}
|
|
****************************************************************
|
|
** CGAL 3.0 Installation Main Menu **
|
|
** ------------------------------- **
|
|
** **
|
|
** OS: sparc_SunOS-5.9 **
|
|
** Compiler: GNU 3.3.2 **
|
|
** Support for: no other library. **
|
|
** **
|
|
** Compiler is supported by CGAL. **
|
|
** The setup has not been tested. **
|
|
** **
|
|
** There are no libs for this os/compiler. **
|
|
** **
|
|
** <C> Compiler Menu **
|
|
** <S> Support Menu **
|
|
** <T> Test (and save) setup **
|
|
** <A> Run all setup tests (no cache) **
|
|
** **
|
|
** <B> Build CGAL Libraries **
|
|
** **
|
|
** <Q> Back to OS **
|
|
** **
|
|
** Your Choice: **
|
|
** **
|
|
****************************************************************
|
|
\end{alltt}}
|
|
|
|
The first lines below the headline contain some kind of status report:
|
|
current OS and compiler, and which third-party software libraries are
|
|
supported (such as \gmp, \core, \leda, or \qt). Moreover you can see
|
|
that the current setup has not yet been tested, and that there do not
|
|
exist \cgal\ libraries for this OS/compiler combination in the \cgal\
|
|
lib directory by now.
|
|
|
|
\subsection{Building the \cgal\ libraries}\label{sec:test-the-setup}
|
|
|
|
In a first step, you should test the current setup by typing ``{\tt
|
|
t}''. Then a number of tests are done to check whether your compiler
|
|
supports certain language constructs or has specific bugs. There is
|
|
quite a number of these tests, so this step may take a while. For each
|
|
test you should get a message what particularly is tested at the
|
|
moment and what the result is.
|
|
|
|
{\ccTexHtml{\scriptsize}{}
|
|
\begin{verbatim}
|
|
****************************************************************
|
|
** The following lines show results of configuration tests. **
|
|
** Some of the tests might fail, since many compilers are **
|
|
** still not completely ANSI/ISO compliant. **
|
|
** Since we worked around the arising problems, **
|
|
** *** CGAL will work fine *** **
|
|
** regardless of the outcome of these tests. **
|
|
****************************************************************
|
|
Checking for standard header files
|
|
algorithm ... ok.
|
|
|
|
<many lines omitted>
|
|
|
|
Testing for VC7_PRIVATE_TYPE_BUG ... ok.
|
|
Saving current setup ... done.
|
|
\end{verbatim}
|
|
}
|
|
|
|
If all these tests have been completed successfully, the current
|
|
settings are saved into a file that resides in the directory
|
|
\cgalinstconfdir. Thus, if you run the install script a second time
|
|
for this OS/compiler, you will not have to go through the whole
|
|
config-/test cycle again, but the configuration will be retrieved from
|
|
the corresponding config file instead.
|
|
|
|
\subsection{Building the \cgal\ libraries}\label{sec:build-the-libs}
|
|
|
|
We are now ready to build the \cgal\ libraries. Just type ``{\tt b}''
|
|
to start compilation. Building consists of three steps:
|
|
\begin{enumerate}
|
|
\item writing the include makefile,
|
|
\item compiling the static libraries \textit{and}
|
|
\item compiling the shared libraries.
|
|
\end{enumerate}
|
|
The include makefile\index{include makefile} encapsulates the OS-- and
|
|
compiler-specific settings and should be included (hence the name) in
|
|
all makefiles that compile \cgal\ applications. If everything went ok,
|
|
the output should look as follows. (Otherwise, you should have a look
|
|
at the error messages from compiler or linker.)
|
|
|
|
{\ccTexHtml{\scriptsize}{}
|
|
\begin{verbatim}
|
|
****************************************************************
|
|
** **
|
|
** Compiling CGAL 3.0 **
|
|
** ------------------ **
|
|
** **
|
|
****************************************************************
|
|
|
|
OS: sparc_SunOS-5.9
|
|
COMPILER: GNU 3.3.2
|
|
GMP: not supported
|
|
GMPXX: not supported
|
|
CORE: not supported
|
|
LEDA: not supported
|
|
Qt: not supported
|
|
|
|
Generating Makefiles ... done.
|
|
Building CGAL_lib ... done.
|
|
Building CGAL_sharedlib ... done.
|
|
|
|
****************************************************************
|
|
** Please press <ENTER> to continue. **
|
|
****************************************************************
|
|
\end{verbatim}}
|
|
{
|
|
}
|
|
|
|
That's all, it's done. Press ``\texttt{<ENTER>}'' to return to the
|
|
main menu and proceed by installing for a different compiler (go to
|
|
the compiler menu and choose ``\texttt{c}'' to get a list of supported
|
|
compilers detected on your system), or with \gmp, \core, \leda, or
|
|
\qt\ support (go to the \gmp, \core, \leda, or \qt\ menu,
|
|
respectively). Another option is to simply quit the install script by
|
|
typing ``\texttt{q}''. When leaving the script, you get a list of
|
|
successful builds during the session. Furthermore, the script prints
|
|
the setting of \texttt{CGAL\_MAKEFILE} for the last active
|
|
configuration. Remember to set this environment variable before
|
|
compiling \cgal\ applications. On bourne shell derivatives, you would
|
|
type in our example
|
|
\begin{alltt}
|
|
export CGAL_MAKEFILE=\cgaldir/make/makefile_sparc_SunOS-5.6_g++-2.95.3
|
|
\end{alltt}
|
|
while for \texttt{csh} descendants the syntax is
|
|
\begin{alltt}
|
|
setenv CGAL_MAKEFILE \cgaldir/make/makefile_sparc_SunOS-5.6_g++-2.95.3
|
|
\end{alltt}
|
|
In Section~\ref{sec:makefiles} you can find more information on the
|
|
\cgal\ makefile structure, and how to set \texttt{CGAL\_MAKEFILE} when
|
|
using \cgal\ on several platforms.
|
|
|
|
%% TODO: some remark regarding visualization
|
|
%% If you want to use the visualization provided by
|
|
%% \ccc{CGAL::Window_stream} (Section~\ref{sec:vis}) and you do not have
|
|
%% the \leda\ libraries installed, or do not want to use them with \cgal,
|
|
%% you should now proceed to Section~\ref{sec:cgalwin} and install the
|
|
%% \texttt{CGALWin} library.
|
|
|
|
%% Now it would be a good idea to print and read the document ``Getting
|
|
%% Started with \cgal'' that can be found in various formats in the
|
|
%% \texttt{doc\_html}, \texttt{doc\_pdf} and \texttt{doc\_ps}
|
|
%% directories.
|
|
|
|
\section{The interactive mode}\label{sec:interactive-mode}
|
|
\index{interactive installation}\index{installation!interactive}
|
|
\TTsubindex{install\_cgal}{interactive mode}
|
|
|
|
To run the install script in the interactive mode, go to the \cgaldir\
|
|
directory and enter the command
|
|
\begin{verbatim}
|
|
./install_cgal -i
|
|
\end{verbatim}
|
|
|
|
After initialization during which certain utility programs are located
|
|
and your system is searched for compilers supported by \cgal, you get
|
|
into the \cgal\ installation \textit{main menu} (see page
|
|
\pageref{pic:main-menu} for a picture).
|
|
|
|
From the main menu you can reach a number of different sub-menus, of
|
|
which the most important maybe is the \textit{compiler menu}. This is
|
|
where you can choose the compiler you want to work with and set custom
|
|
compiler or linker options. The compiler menu is described in
|
|
Section~\ref{sec:compiler-menu}.
|
|
|
|
If you want to use \gmp, \core, \leda, or \qt\ with \cgal, you will
|
|
have to go to the \textit{gmp menu} (cf. Section~\ref{sec:gmp-menu}),
|
|
\textit{core menu} (cf. Section~\ref{sec:core-menu}), \textit{leda
|
|
menu} (cf. Section~\ref{sec:leda-menu}), or \textit{qt menu} (cf.
|
|
Section~\ref{sec:qt-menu}), respectively.
|
|
|
|
Finally you can build the \cgal\ libraries by typing \texttt{b}.
|
|
However, it is recommended to run the \textit{setup test} -- which is
|
|
available in all menus as option \texttt{t} -- before. The setup test
|
|
includes an \stl\ test, a \gmp\ test, a \core\ test, a \leda\ test,
|
|
and a \qt\ test. But not all tests are performed always; e.g., the
|
|
\gmp\ test is only done, if you enabled \gmp\ support. The install
|
|
script keeps track of the tests passed and only tests again, if you
|
|
change the setup in a way that might affect the test result. If you
|
|
want to redo \textit{all} tests, you have to choose option
|
|
``\texttt{a}'' from the main menu. This also retests for
|
|
\gmp/\leda/\qt\ installations in system directories. Otherwise, this
|
|
is only done the first time you enable gmp/\leda/\qt\ support for an
|
|
OS/compiler combination.
|
|
|
|
\subsection{Files created during installation}\label{sec:filescreated}
|
|
|
|
The install script stores all relevant settings for an OS/compiler
|
|
combination in the directory
|
|
\begin{center}
|
|
\texttt{\cgalinstconfdir/$<$\textit{CGAL-OS-description}$>$}
|
|
\end{center}
|
|
where $<$\textit{CGAL-OS-description}$>$ identifies your OS/compiler
|
|
combination in a way specified in section \ref{sec:os-compiler-id}.
|
|
\footnote{Note that these files are only OS/compiler specific, i.e.
|
|
there are no different files for with and without \leda\ support.}
|
|
This saves you typing everything again, if you upgrade
|
|
\index{upgrading \cgal}\index{CGAL@\cgal!upgrade} \cgal\ or another
|
|
package that makes recompiling the \cgal\ libraries necessary.
|
|
|
|
Besides the config files, \texttt{install\_cgal} uses several
|
|
temporary files during interactive installation. Most of them are
|
|
removed after use, but some are not, since it might be helpful to keep
|
|
some information about the last run. You can keep or delete them as
|
|
you like, as they are not needed anymore once the script terminated.
|
|
A list of these files (all are plain ASCII and reside in \cgaldir)
|
|
follows.
|
|
\begin{center}\index{files!temporary}\index{logfiles}
|
|
\renewcommand{\arraystretch}{1.3}
|
|
\gdef\lcTabularBorder{2}
|
|
\begin{tabular}{|l|l|} \hline
|
|
\textbf{filename} & \textbf{content}\\\hline\hline
|
|
\texttt{install.log}\TTindex{install.log} &
|
|
detailed overall protocol\\\hline
|
|
\texttt{install.completed}\TTindex{install.completed} &
|
|
list of systems for which \cgal\ libraries
|
|
have been built\\\hline
|
|
\texttt{compile.log}\TTindex{compile.log} &
|
|
output of the last compiler call\\\hline
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\subsection{The Compiler Menu}\label{sec:compiler-menu}
|
|
\index{compiler menu}\index{menus!compiler}
|
|
|
|
Here is the place to set the compiler specific options, such as the
|
|
compiler to use (if more than one has been detected) and custom
|
|
compiler or linker flags.\bigskip
|
|
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf Compiler Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$C$>$] Choose the compiler to be used from the list of
|
|
detected compilers. You can also register other compilers, if they
|
|
have not been detected automatically.\index{compilers!choosing}
|
|
\item[$<$F$>$] Set custom compiler flags. These are the first flags
|
|
given to the compiler in every call. Under normal circumstances
|
|
there should be no need to set any such
|
|
flag.\index{compilers!setting custom flags}
|
|
\item[$<$L$>$] Set custom linker flags. These are the first flags
|
|
given to the linker in every call. Under normal circumstances
|
|
there should be no need to set any such flag.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\subsection{The Support Menu}\label{sec:support-menu}
|
|
\index{support menu}\index{menus!support}
|
|
|
|
This menu provides the starting point to setup the support for
|
|
third-party software libraries such as \gmp, \core, \leda, or \qt.
|
|
\bigskip
|
|
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf Support Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$G$>$] Setup support for the \gnu\ Multiple Precision library
|
|
\gmp.\index{GMP@\gmp!enable support}
|
|
\item[$<$C$>$] Setup support for the \core\ library for robust
|
|
numerical and geometric computation.\index{CORE@\core!enable
|
|
support}
|
|
\item[$<$L$>$] Setup support for \leda, the Library of Efficient
|
|
Datatypes and Algorithms.\index{LEDA@\leda!enable support}
|
|
\item[$<$K$>$] Setup support for Trolltech's \qt\
|
|
toolkit.\index{Qt!enable support}
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\subsection{The GMP Menu}\label{sec:gmp-menu}
|
|
\index{GMP@\gmp!menu}\index{menus!\gmp}
|
|
|
|
This menu is to set \gmp\ (\gnu\ Multiple Precision Library) specific
|
|
options, if you plan to use \gmp\ together with \cgal. In case you do
|
|
not already have \gmp\ installed on your system, a \gmp\ distribution
|
|
is shipped with \cgal. You can find it in the {\tt auxiliary}
|
|
directory. The menu provides an option to install \gmp\ in your \cgal\
|
|
directory tree\footnote{This option on \msvc\ just unpacks a
|
|
pre-compiled library that comes with \cgal.}, but -- of course --
|
|
you can also install \gmp\ independently from \cgal.
|
|
|
|
If \gmp\ support is enabled for the first time, the script tests
|
|
whether \gmp\ is installed in standard system directories or in the
|
|
\cgal\ tree. If this test does not succeed, you have to supply
|
|
directories containing the \gmp\ header files
|
|
(\texttt{GMP\_INCL\_DIR})\TTindex{GMP\_INCL\_DIR} and \gmp\ libraries
|
|
({\tt GMP\_LIB\_DIR})\TTindex{GMP\_LIB\_DIR}. Even if the tests are
|
|
passed, you still have the option to set these directories
|
|
differently.
|
|
|
|
If you decide to install the \gmp\ distribution shipped with \cgal\
|
|
from the install script, \gmp\ will be configured by calling its
|
|
\textit{configure} script. \gmp\ being a C library, it requires a C
|
|
compiler. Its \textit{configure} script usually does a good job at
|
|
finding a C compiler on the system, but it also gives the possibility
|
|
to specify it by setting the environment variable \textit{CC} before
|
|
calling \textit{configure}. If you want the \cgal\ install script to
|
|
build \gmp\ and specify the C compiler to be used, you can also to the
|
|
same, by setting the \textit{CC} environment variable (see the \gmp\
|
|
installation documentation for details). If you need a more complex
|
|
configuration of \gmp, we recommend that you install \gmp\ yourself
|
|
separately.
|
|
|
|
If \gmp\ support is enabled, you may additionnally enable support for
|
|
GMPXX, \gmp's built-in C++ interface, from the \gmp\ menu. Note that
|
|
this is not supported by all C++ compilers, you should check the \gmp\
|
|
manual for more information. Once you choose to have GMPXX support,
|
|
then if you install \gmp\ from the CGAL tree, \gmp\ will be configured
|
|
with C++ support.\bigskip
|
|
|
|
\index{GMP@\gmp!installing}\index{GMP@\gmp!enable support}
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf GMP Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$C$>$] Install the \gmp\ distribution shipped with \cgal\ in
|
|
the \cgal\ directory tree.
|
|
\item[$<$G$>$] Enable/Disable \gmp\ support in \cgal.
|
|
\item[$<$X$>$] Enable/Disable GMPXX support in \cgal.
|
|
\item[$<$I$>$] (\textit{present if \gmp\ support is enabled)} Set the
|
|
include directory for \gmp.
|
|
\item[$<$L$>$] (\textit{present if \gmp\ support is enabled)} Set the
|
|
directory containing the \gmp\ libraries.
|
|
\item[$<$M$>$] (\textit{present if \gmp\ support is enabled, there is a \gmp\
|
|
installation in system directories or in the \cgal\ tree and {\tt
|
|
GMP\_INCL\_DIR} or \texttt{GMP\_LIB\_DIR} have been set)} Use \gmp\
|
|
installation from system directories / \cgal\ tree.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\subsection{The CORE Menu}\label{sec:core-menu}
|
|
\index{CORE@\core!menu}\index{menus!\core}
|
|
|
|
This menu is to set \core\ specific options, if you plan to use \core\
|
|
together with \cgal. Since \core\ requires \gmp, you have to enable
|
|
\gmp\ support together with \core\ support. Refer to
|
|
Section~\ref{sec:gmp-menu} for how to setup \gmp\ support for \cgal.
|
|
|
|
The current \core\ release is shipped together with \cgal. If \core\
|
|
support is enabled, the \core\ library is built and installed together
|
|
with the \cgal\ libraries. Hence, if you enable \core\ support, you
|
|
have to (re)build the \cgal\ libraries afterwards (cf.
|
|
Section~\ref{sec:build-the-libs}). Another option is to use a \core\
|
|
installation that is independent from \cgal. For this you have to
|
|
supply directories containing the \core\ header files
|
|
(\texttt{CORE\_INCL\_DIR})\TTindex{CORE\_INCL\_DIR} and the \core\
|
|
library ({\tt CORE\_LIB\_DIR})\TTindex{CORE\_LIB\_DIR}. \bigskip
|
|
|
|
\index{CORE@\core!installing}\index{CORE@\core!enable support}
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf CORE Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$C$>$] Enable/Disable \core\ support in \cgal.
|
|
\item[$<$I$>$] (\textit{present if \core\ support is enabled)} Set the
|
|
include directory for \core.
|
|
\item[$<$L$>$] (\textit{present if \core\ support is enabled)} Set the
|
|
directory containing the \core\ library.
|
|
\item[$<$Z$>$] (\textit{present if \core\ support is enabled and {\tt
|
|
CORE\_INCL\_DIR} or \texttt{CORE\_LIB\_DIR} have been set)} Use
|
|
\core\ installation from \cgal\ directories.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\subsection{The \leda\ Menu}\label{sec:leda-menu}
|
|
\index{LEDA@\leda!menu}\index{menus!\leda}
|
|
|
|
This is the place to set \leda\ specific options, if you plan to use
|
|
\leda\ together with \cgal\ (see also Section~\ref{sec:leda}). In
|
|
order to enable \leda\ support in \cgal, \leda\ has to be installed on
|
|
your system.
|
|
|
|
If \leda\ support is enabled the first time, the script tests whether
|
|
\leda\ is installed in standard system directories. If this test does
|
|
not succeed, you have to supply directories containing the \leda\
|
|
header files (\texttt{LEDA\_INCL\_DIR})\TTindex{LEDA\_INCL\_DIR} and
|
|
\leda\ libraries ({\tt LEDA\_LIB\_DIR})\TTindex{LEDA\_LIB\_DIR}. Even
|
|
if the tests are passed, you still have the option to set these
|
|
directories differently.\bigskip
|
|
|
|
\index{LEDA@\leda!enable support}
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf \leda\ Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$E$>$] Enable/Disable \leda\ support in \cgal.
|
|
\item[$<$I$>$] (\textit{present if \leda\ support is enabled)} Set the
|
|
include directory for \leda .
|
|
\item[$<$J$>$] (\textit{present if \leda\ support is enabled, \leda\ headers
|
|
have been found in a system include directory and {\tt
|
|
LEDA\_INCL\_DIR} has been set)} Use \leda\ header from system
|
|
include directory.
|
|
\item[$<$L$>$] (\textit{present if \leda\ support is enabled)} Set the
|
|
directory containing the \leda\ libraries.
|
|
\item[$<$M$>$] (\textit{present if \leda\ support is enabled, \leda\
|
|
libs have been found in a system lib directory and
|
|
\texttt{LEDA\_LIB\_DIR} has been set)} Use \leda\ libraries from
|
|
system lib directory.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\subsection{The Qt Menu}\label{sec:qt-menu}
|
|
\index{Qt!menu}\index{menus!Qt}
|
|
|
|
This menu is to set \qt\ specific options, if you plan to use \qt\
|
|
together with \cgal . Note that for use with \cgal, \qt\ version 2.2
|
|
(or later) if required. In order to enable \qt\ support in \cgal, \qt\
|
|
has to be installed on your system first. Unlike for \gmp, there is no
|
|
option to install \qt\ from the \cgal\ installation script. For
|
|
information on \qt, please refer to
|
|
\begin{quote}
|
|
\qtpage
|
|
\end{quote}
|
|
|
|
\begin{ccAdvanced}
|
|
The \qt\ menu has a basic mode and an advanced one. If your \qt\
|
|
installation is standard, you shouldn't have to go into the advanced
|
|
mode.
|
|
|
|
The \qt\ menu starts in basic mode, unless \qt\ is installed in
|
|
standard system directories (because in that case, the advanced mode
|
|
is quicker).
|
|
\end{ccAdvanced}
|
|
|
|
\subsubsection{Basic mode (to use with a standard Qt installation)}
|
|
|
|
If \qt\ support is enabled the first time, the script tests whether
|
|
the \texttt{\$QTDIR} environment variable points to a valid \qt\
|
|
directory. is installed in standard system directories. If that is
|
|
not the case, you have to supply the \qt\ directory containing your
|
|
\qt\ installation. Even if the test passed, you still have the option
|
|
to set this directory differently. If your \qt\ installation is not
|
|
standard, you would have to go into the advanced mode.\bigskip
|
|
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf Qt basic Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$K$>$] Enable/Disable Qt support in \cgal.\index{Qt!enable
|
|
support}
|
|
\item[$<$A$>$] (\textit{present if Qt support is enabled)} Go to the
|
|
advanced mode
|
|
\item[$<$D$>$] (\textit{present if Qt support is enabled}) Set the
|
|
Qt directory.
|
|
\item[$<$E$>$] (\textit{present if Qt support is enabled,
|
|
\texttt{\$QTDIR} points to a valid Qt directory and {\tt QT\_DIR}
|
|
has been set}) Use \texttt{\$QTDIR} as Qt directory.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
|
|
\begin{ccAdvanced}
|
|
\subsubsection{Advanced mode (to use with a non-standard Qt
|
|
installation) }
|
|
|
|
In that mode, you have to specify separately directories containing
|
|
the \qt\ header files (\texttt{QT\_INCL\_DIR})\TTindex{QT\_INCL\_DIR}
|
|
and the \qt\ library (\texttt{QT\_LIB\_DIR})\TTindex{QT\_LIB\_DIR},
|
|
and the path to the MOC\footnote{\qtmocpage} executable
|
|
(\texttt{QT\_MOC})\TTindex{QT\_MOC} unless they are in system
|
|
directories. Even in that case, you still have the option to set them
|
|
differently.
|
|
|
|
\fbox{
|
|
\begin{minipage}{.95\linewidth}
|
|
\vspace{2pt}
|
|
\centerline{{\large{\bf Qt advanced Menu}}}
|
|
\vspace{2pt}
|
|
\begin{description}
|
|
\item[$<$K$>$] Enable/Disable Qt support in \cgal.\index{Qt!enable
|
|
support}
|
|
\item[$<$B$>$] (\textit{present if Qt support is enabled)} Go to the
|
|
basic mode
|
|
\item[$<$I$>$] (\textit{present if Qt support is enabled}) Set the
|
|
directory containing Qt headers.
|
|
\item[$<$J$>$] (\textit{present if Qt support is enabled, Qt headers
|
|
are in system directories and {\tt QT\_INCL\_DIR} has been set})
|
|
Use Qt headers from system include directories.
|
|
\item[$<$L$>$] (\textit{present if Qt support is enabled}) Set the
|
|
directory containing Qt library.
|
|
\item[$<$M$>$] (\textit{present if Qt support is enabled, Qt library
|
|
is in system directories and {\tt QT\_LIB\_DIR} has been set})
|
|
Use Qt library from system library directories.
|
|
\item[$<$O$>$] (\textit{present if Qt support is enabled}) Set the
|
|
path to MOC executable.
|
|
\item[$<$P$>$] (\textit{present if Qt support is enabled, MOC is in path and {\tt QT\_MOC} has been set})
|
|
Use Qt MOC executable in path.
|
|
\end{description}
|
|
\vspace{2pt}
|
|
\end{minipage}
|
|
\hfill}
|
|
|
|
\end{ccAdvanced}
|
|
|
|
\section{The non-interactive mode}\label{sec:non-interactive}
|
|
\index{non-interactive
|
|
installation}\index{installation!non-interactive}
|
|
\TTsubindex{install\_cgal}{non-interactive mode}
|
|
|
|
To run the install script in the non-interactive mode, go to the
|
|
\cgaldir\ directory and enter the command
|
|
\begin{verbatim}
|
|
./install_cgal -ni <compiler>
|
|
\end{verbatim}
|
|
where \texttt{<compiler>} is the C++ compiler
|
|
executable.\index{compilers!choosing}\\ You can either specify a full
|
|
path, e.g. \texttt{/usr/local/bin/g++}, or just the basename, e.g.
|
|
\texttt{g++}, which means the script searches your \texttt{PATH} for
|
|
the compiler location. If your compiler call contains whitespaces it
|
|
has to be quoted, e.g. \texttt{./install\_cgal -ni "CC -n32"}. The
|
|
options given this way become part of your \cgal-OS
|
|
description\index{OS description} (see section
|
|
\ref{sec:os-compiler-id}) which is useful e.g. to distinguish between
|
|
different compilers using the same frontend (\mipsprocc\ on
|
|
\texttt{IRIX6}).
|
|
|
|
There are a number of additional command line options to customize
|
|
your \cgal\ setup which are discussed below. You should read the
|
|
corresponding paragraphs before you continue, especially if one or
|
|
more of the following conditions apply to you:
|
|
\begin{itemize}
|
|
\item you want to use \gmp\ together with \cgal\
|
|
(Section~\ref{sec:gmp-setup}),
|
|
\item you want to use \gmp's built-in C++ interface together with
|
|
\cgal\ (Section~\ref{sec:gmpxx-setup}),
|
|
\item you want to use \core\ together with \cgal\
|
|
(Section~\ref{sec:core-setup}),
|
|
\item you want to use \leda\ together with \cgal\
|
|
(Section~\ref{sec:leda-setup}),
|
|
\item you want to use \qt\ together with \cgal\
|
|
(Section~\ref{sec:qt-setup}).
|
|
\end{itemize}
|
|
|
|
Once you started the script, it should give you a message indicating
|
|
the \cgal\ version you are going to install and that you are running
|
|
the non-interactive mode. Then it proceeds by locating some utility
|
|
programs, determining your OS and compiler version and displaying the
|
|
settings you gave via command line. Your compiler is also checked for
|
|
a number of bugs resp. support of certain language features; a message
|
|
\texttt{ok} always indicates that your compiler works as it should,
|
|
that is, a feature is supported or a bug is \textit{not} present. On
|
|
the other hand, \texttt{no} or \texttt{unfortunately} indicate a lack
|
|
of support or the presence of a bug.
|
|
|
|
Finally the current setup is summarized, system specific directories
|
|
for makefiles and libraries are created (if they did not exist before)
|
|
and a new include makefile is written into the makefile directory. If
|
|
there already exists a makefile for the current OS/compiler
|
|
combination, it is backed up and you should get a corresponding
|
|
message.
|
|
|
|
To compile the \cgal\ libraries go now to the \texttt{src} directory.
|
|
Then type \texttt{make -f makefile\_lib} to compile the \cgal\ object
|
|
library and \texttt{make -f makefile\_sharedlib} to compile the \cgal\
|
|
shared object library. If you want to make changes to the makefiles
|
|
first, see section \ref{sec:makefiles} for an explanation of the
|
|
makefile structure of \cgal.
|
|
|
|
If you enabled \core\ support and want to use the \core\ distribution
|
|
shipped with \cgal, go to the \texttt{src/Core} directory and type
|
|
\texttt{make -f makefile\_Core} to compile the \core\ library.
|
|
|
|
If you enabled \qt\ support, go to the \texttt{src/CGALQt} directory
|
|
and type \texttt{make -f makefile\_Qt} to compile the \cgal\ \qt\
|
|
support library.
|
|
|
|
%%When this is finished it would be a good idea to print and read the
|
|
%%`Getting Started with \cgal'\index{CGAL@\cgal!getting started} document
|
|
%%\texttt{getting\_started.ps} that can be found in the \texttt{doc\_ps}
|
|
%%directory.
|
|
|
|
\subsection{Setting up support for GMP}\label{sec:gmp-setup}
|
|
\index{GMP@\gmp!enable support}
|
|
|
|
By default there is no support for \gmp, but you can change this
|
|
easily by use of the command line option ``\texttt{-gmp}''. If \gmp\ is
|
|
installed in system directories on your system, you are already done
|
|
now. If this is not the case, you have to supply the directories
|
|
containing the \gmp\ header files (``\texttt{--GMP\_INCL\_DIR}
|
|
\textit{$<$dir$>$}'')\TTindex{GMP\_INCL\_DIR} and the \gmp\ library
|
|
(``\texttt{--GMP\_LIB\_DIR}
|
|
\textit{$<$dir$>$}'')\TTindex{GMP\_LIB\_DIR}.
|
|
|
|
\subsection{Setting up support for GMPXX}\label{sec:gmpxx-setup}
|
|
\index{GMPXX@\texttt{GMPXX}!enable support}
|
|
|
|
By default there is no support for GMPXX, \gmp's built-in C++
|
|
interface, but you can change this easily by use of the command line
|
|
option ``\texttt{-gmpxx}''. The only requirement for this to work is
|
|
that \gmp\ support is enabled correctly.
|
|
|
|
\subsection{Setting up support for CORE}\label{sec:core-setup}
|
|
\index{CORE@\core!enable support}
|
|
|
|
By default there is no support for \core, but you can change this
|
|
easily by use of the command line option ``\texttt{-core}''. If you
|
|
want to use the \core\ distribution shipped with \cgal, this is all
|
|
you have to do. Otherwise, you also have to supply the directories
|
|
containing the \core\ header files (``\texttt{--CORE\_INCL\_DIR}
|
|
\textit{$<$dir$>$}'')\TTindex{CORE\_INCL\_DIR} and the \core\ library
|
|
(``\texttt{--CORE\_LIB\_DIR}
|
|
\textit{$<$dir$>$}'')\TTindex{CORE\_LIB\_DIR}.
|
|
|
|
\subsection{Setting up \leda\ support}\label{sec:leda-setup}
|
|
\index{LEDA@\leda!enable support}
|
|
|
|
See also section \ref{sec:leda}. By default there is no support for
|
|
\leda, but you can change this easily by use of the command line
|
|
option ``\texttt{-leda}''. If \leda\ is installed in system
|
|
directories on your system, you should indicate this by setting the
|
|
flags ``{\tt --leda-sys-incl}'' resp. ``\texttt{--leda-sys-lib}''. If
|
|
this is not the case, you have to supply the directories containing
|
|
the \leda\ header files (``\texttt{--LEDA\_INCL\_DIR}
|
|
\textit{$<$dir$>$}'')\TTindex{LEDA\_INCL\_DIR} resp. the \leda\
|
|
libraries for your compiler (``\texttt{--LEDA\_LIB\_DIR} {\it
|
|
$<$dir$>$}''\TTindex{LEDA\_LIB\_DIR}).
|
|
|
|
\subsection{Setting up support for Qt}\label{sec:qt-setup}
|
|
\index{Qt!enable support}
|
|
|
|
By default there is no support for \qt, but you can change this easily
|
|
by use of the command line option ``\texttt{-qt}''. If \qt\ is
|
|
installed in system directories on your system or the \texttt{\$QTDIR}
|
|
environment variable points to the \qt\ directory, you are already
|
|
done now. If this is not the case, you have to supply either the \qt\
|
|
directory (``\texttt{--QT\_DIR}~\textit{$<$dir$>$}'')\TTindex{QT\_DIR}
|
|
if your \qt\ installation is standard, either directories containing
|
|
the \qt\ header files
|
|
(``\texttt{--QT\_INCL\_DIR}~\textit{$<$dir$>$}'')\TTindex{QT\_INCL\_DIR}
|
|
and the \qt\ library
|
|
(``\texttt{--QT\_LIB\_DIR}~\textit{$<$dir$>$}'')\TTindex{QT\_LIB\_DIR},
|
|
and the path to the MOC\footnote{\qtmocpage} executable
|
|
(``\texttt{--QT\_MOC} \textit{$<$exe$>$}'')\TTindex{QT\_MOC} if your
|
|
\qt\ installation is not standard.
|
|
|
|
\subsection{Setting custom compiler/linker flags}\label{sec:custom-setup}
|
|
\index{compilers!setting custom flags}
|
|
|
|
You can supply custom compiler and linker flags using the options
|
|
\mbox{(``\texttt{--CUSTOM\_CXXFLAGS}
|
|
\textit{$<$flags$>$}'')\TTindex{CUSTOM\_CXXFLAGS}} and
|
|
\mbox{(``\texttt{--CUSTOM\_LDFLAGS}
|
|
\textit{$<$flags$>$}'')\TTindex{CUSTOM\_LDFLAGS}}. These are the
|
|
first flags given to the compiler/linker in every call.
|
|
|
|
\textit{Note:} Do not forget to quote your options in case they
|
|
contain spaces. Example:
|
|
\begin{verbatim}
|
|
./install_cgal -ni g++ --CUSTOM_CXXFLAGS "-I/my/include -O2"
|
|
\end{verbatim}
|
|
|
|
\subsection{Other Options}\label{sec:other-options}
|
|
|
|
There are some less important features of the install script we will
|
|
summarize here.
|
|
|
|
First of all, you can get the version number of \texttt{install\_cgal}
|
|
with option ``\texttt{--version}''. Note that all other options are
|
|
ignored in this case.\TTsubindex{install\_cgal}{version number}
|
|
|
|
Second there is an option ``\texttt{-os \textit{$<$compiler$>$}}''
|
|
where \textit{$<$compiler$>$} is your \CC\ compiler. This allows you
|
|
to determine your \cgal-OS description\index{OS description} (see section
|
|
\ref{sec:os-compiler-id}). The compiler can either be given by an
|
|
absolute path like
|
|
\begin{verbatim}
|
|
./install_cgal -os /usr/local/gcc-2.95.3/sun/bin/g++
|
|
\end{verbatim}
|
|
or just by denoting its basename, as long as it is on your path:
|
|
\begin{verbatim}
|
|
./install_cgal -os CC
|
|
\end{verbatim}
|
|
The option is intended for testing purposes and automatic detection of
|
|
the correct include makefile (see also section \ref{sec:makefiles}).
|
|
|
|
Finally, there exists an option
|
|
``\texttt{--verbose}''\TTsubindex{install\_cgal}{verbose mode} that
|
|
can be set in interactive mode as well as in non-interactive mode.
|
|
When set you get a detailed summary of error messages occurring during
|
|
\textit{any} compiler test (determining \stl\ version etc.). Normally
|
|
you only get these messages, if a required test (such as the general
|
|
\stl\ test) fails, otherwise you are just informed, \textit{if} it
|
|
succeeded or not. This option is not recommended for general use, but
|
|
it can be useful to check why a certain test fails that was expected
|
|
to be passed.
|
|
|
|
\section{Upgrading a previous \cgal\ installation}
|
|
\label{sec:upgrade}\index{upgrading \cgal}\index{CGAL@\cgal!upgrade}
|
|
|
|
In case you already have a previous release of \cgal\ installed on
|
|
your system, you might like to reuse your configuration files and
|
|
\gmp\ installations. Simply use the following command to copy them
|
|
into the right place:\TTsubindex{install\_cgal}{upgrade option}
|
|
\begin{verbatim}
|
|
./install_cgal --upgrade <OLD_CGAL_DIR>
|
|
\end{verbatim}
|
|
where \texttt{<OLD\_CGAL\_DIR>} is the root directory of your existing
|
|
\cgal\ installation\\ (e.g. \texttt{/pub/local/CGAL-2.4}). You can
|
|
then build all libraries for the actual operating system that existed
|
|
in your previous \cgal\ installation with
|
|
\TTsubindex{install\_cgal}{rebuild-all option}
|
|
\begin{verbatim}
|
|
./install_cgal --rebuild-all
|
|
\end{verbatim}
|
|
|
|
If you want to install \cgal\ for more than one operating system in
|
|
the same directory structure, you have to run the latter command
|
|
(\texttt{rebuild-all}) once on each operating system.
|
|
|
|
Using \texttt{--build-all} instead of \texttt{--rebuild-all} will save
|
|
you the time of the configuration tests, and will only rebuild the libraries.
|
|
|
|
If you want to install only one configuration on a given operating system,
|
|
you can specify its name (the base name of a file in \cgalinstconfdir) with
|
|
the option \texttt{--rebuild <config>} or \texttt{--build <config>}.
|
|
|
|
\textbf{Note} that some compilers that have been supported in previous
|
|
\cgal\ releases might not be supported in \cgal-\cgalrelease\ anymore,
|
|
see section \ref{sec:prerequisites}. Trying to build
|
|
\cgal-\cgalrelease\ with these compilers will most probably fail. You
|
|
can solve this problem by deleting the obsolete config files (see
|
|
section \ref{sec:filescreated}) from \cgalinstconfdir\ before issuing
|
|
the \texttt{rebuild-all} command.
|
|
|
|
Similarly, you might want to use compilers with \cgal-\cgalrelease\
|
|
that have not been supported in previous releases. For these compilers
|
|
please follow the usual procedure as described in section
|
|
\ref{sec:interactive-mode} or \ref{sec:non-interactive}.
|
|
|
|
\section{Identifying OS and Compiler}\label{sec:os-compiler-id}
|
|
\index{OS description}\index{identifying OS and compiler}
|
|
|
|
Since \cgal\ supports several different operating systems and
|
|
compilers, this is also reflected in the structure of the \cgal\
|
|
directory tree. Each OS/compiler combination has its own lib directory
|
|
under \texttt{\cgaldir/lib}) (and analogously its own include
|
|
makefile\index{include makefile} in \texttt{\cgaldir/make}) named as
|
|
determined by the following scheme.
|
|
\begin{center}
|
|
\textit{$<$arch$>$\texttt{\_}$<$os$>$\texttt{-}$<$os-version$>$\texttt{\_}$<$comp$>${\tt
|
|
-}$<$comp-version$>$}[\texttt{\_}LEDA]
|
|
\end{center}
|
|
|
|
\begin{description}
|
|
\item[$<$arch$>$] is the system architecture as defined by ``{\tt
|
|
uname -p}'' or ``\texttt{uname -m}'',
|
|
\item[$<$os$>$] is the operating system as defined by ``\texttt{uname
|
|
-s}'',
|
|
\item[$<$os-version$>$] is the operating system version as defined by
|
|
``\texttt{uname -r}'',
|
|
\item[$<$comp$>$] is the basename of the compiler executable (if it
|
|
contains spaces, these are replaced by "-") \textit{and}
|
|
\item[$<$comp-version$>$] is the compiler's version number (which
|
|
unfortunately can not be derived in a uniform manner, since it is
|
|
quite compiler specific).
|
|
\end{description}
|
|
|
|
The suffix \texttt{\_}LEDA is appended to indicate \leda\ support.
|
|
|
|
We call the resulting string \cgal-OS description.\\ Examples are
|
|
\texttt{mips\_IRIX-6.2\_CC-7.2} or {\tt
|
|
sparc\_SunOS-5.5\_g++-2.95.3\_LEDA}.\\ You can use the install script
|
|
to get your \cgal-OS description, see section \ref{sec:other-options}.
|
|
|
|
\section{The \cgal\ makefile structure}\label{sec:makefiles}
|
|
\index{makefile structure}
|
|
|
|
The \cgal\ distribution contains the following makefiles:
|
|
\begin{itemize}
|
|
\item \texttt{\cgaldir/src/makefile\_lib} for compiling the \cgal\
|
|
object library \texttt{libCGAL.a},
|
|
|
|
\item \texttt{\cgaldir/src/makefile\_sharedlib} for compiling the
|
|
\cgal\ shared object library \texttt{libCGAL.so},
|
|
|
|
\item \texttt{\cgaldir/examples/makefile} as sample makefile
|
|
\textit{and}
|
|
|
|
\item \texttt{\cgaldir/examples/*/makefile} for compiling the \cgal\
|
|
example programs.
|
|
\end{itemize}
|
|
|
|
All these makefiles are generic: they can be used for more than one
|
|
compiler. To achieve this, the first section of each makefile
|
|
contains an include statement that looks as follows:
|
|
|
|
\begin{verbatim}
|
|
CGAL_MAKEFILE = /users/jannes/CGAL-3.0/make/makefile_<CGAL-OS description>
|
|
include $(CGAL_MAKEFILE)
|
|
\end{verbatim}
|
|
%$
|
|
|
|
The file \texttt{CGAL\_MAKEFILE}\TTindex{CGAL\_MAKEFILE} is an include
|
|
file\index{include makefile} with platform dependent makefile
|
|
settings. The abbreviation \texttt{<CGAL-OS description>} (see section
|
|
\ref{sec:os-compiler-id} for details) is used to identify the
|
|
operating system and compiler for which the settings hold. For
|
|
example, the file \texttt{makefile\_mips\_IRIX64-6.5\_CC-n32-7.30}
|
|
contains makefile settings for the IRIX 6.5 operating system and the
|
|
\mipsprocc\ 7.3 compiler. These include files are automatically
|
|
generated by the \texttt{install\_cgal} script and they are all
|
|
located in the \texttt{\cgaldir/make} directory. For convenience, the
|
|
\texttt{install\_cgal} script will substitute the include makefile
|
|
that was generated most recently.
|
|
|
|
If you want to compile an application or an object library with a
|
|
different compiler, the only thing you need to do is to substitute
|
|
another include makefile for the \texttt{CGAL\_MAKEFILE} variable. An
|
|
alternative way to do this is to create an environment variable
|
|
\texttt{CGAL\_MAKEFILE}. To pass the value of the environment variable
|
|
to the makefile you can either comment out the \texttt{CGAL\_MAKEFILE}
|
|
line in the makefile or use an appropriate command line option for the
|
|
make utility. A comfortable way to set \texttt{CGAL\_MAKEFILE} is by
|
|
using \texttt{install\_cgal~-os} (see section
|
|
\ref{sec:other-options}). E.g. if your compiler is \texttt{g++}, you
|
|
would type
|
|
\begin{alltt}
|
|
CGAL_MAKEFILE=`\yourcgaldir/install_cgal -os g++`
|
|
\end{alltt}
|
|
in bourne shell resp.
|
|
\begin{alltt}
|
|
setenv CGAL_MAKEFILE `\yourcgaldir/install_cgal -os g++`
|
|
\end{alltt}
|
|
in csh derivatives.
|
|
|
|
\textit{Tip:} Include the setting of \texttt{CGAL\_MAKEFILE} into your
|
|
shell startup script (e.g. \texttt{.}(\texttt{t})\texttt{cshrc} for
|
|
(\texttt{t})\texttt{csh} or \texttt{.bashrc} for \texttt{bash}).
|
|
|
|
All makefiles contain sections with compiler and linker flags. You
|
|
can add your own flags here. For example, you might want to add the
|
|
flag \texttt{-DCGAL\_NO\_PRECONDITIONS} to turn off precondition
|
|
checking. The flags \texttt{\$(CGAL\_CXXFLAGS)} and
|
|
\texttt{\$(CGAL\_LDFLAGS)} should never be removed.
|
|
|
|
The default extension for \cgal\ source files is \texttt{.C}. The
|
|
last section of the makefiles contains a suffix rule that tells the
|
|
compiler how to create a \texttt{.o}-file from a \texttt{.C}-file. If
|
|
you want to use the default rule that is defined by the make utility,
|
|
you may want to remove this suffix rule. However, note that this may
|
|
have consequences for the makefile variables \texttt{CGAL\_CXX} and
|
|
\texttt{CXXFLAGS}.
|
|
|
|
\section{Compiling a \cgal\ application}
|
|
\index{building applications}
|
|
\index{compiling applications}
|
|
|
|
The directory \texttt{\cgaldir/examples} contains a small program
|
|
(example.C) and a sample makefile with some comments. The
|
|
\texttt{CGAL\_MAKEFILE} variable in this makefile (see section
|
|
\ref{sec:makefiles}) is automatically substituted by the
|
|
\texttt{install\_cgal} script and equals the most recently generated
|
|
include makefile in the \texttt{\cgaldir/make} directory. After the
|
|
installation of \cgal\ this sample makefile is ready for use. Just
|
|
type '\texttt{make example}' to compile the program
|
|
\texttt{example.C}. There is a script for conveniently creating
|
|
makefiles for \cgal\ applications, see
|
|
section~\ref{sec:create_cgal_makefile}.
|
|
|
|
Furthermore the directories \texttt{\cgaldir/examples} and
|
|
\texttt{\cgaldir/demo} contain many subdirectories with non-graphical
|
|
and graphical example programs. In all these directories you will
|
|
find a makefile that is ready for use.
|
|
|
|
\section{Installation on Cygwin}\label{sec:cygwin}
|
|
\index{Cygwin!installation on}\index{installation!on Cygwin}
|
|
|
|
Cygwin is a free Unix-like environment for MS-Windows, distributed by
|
|
Cygnus Solutions. For our tests we have used version 1.3.2 and
|
|
$B$-20.1.
|
|
|
|
It consists of a port of a large number of GNU tools, such as bash,
|
|
make, gcc, gas, file utilities, etc, as well as tools ensuring an
|
|
ability to emulate Unix-like access to resources, for instance mount.
|
|
For a comprehensive introduction and details, see
|
|
\path~http://www.cygwin.com/~ .
|
|
|
|
Make sure that the link \texttt{/bin/sh.exe} exists. If not, create
|
|
it:
|
|
\begin{verbatim}
|
|
cd /bin
|
|
ln -s bash.exe sh.exe
|
|
\end{verbatim}
|
|
|
|
\subsection{Pathnames}
|
|
\index{Cygwin!pathnames}
|
|
|
|
Cygwin has a UNIX-like way of navigating hard drives, NFS shares, etc.
|
|
This is also the way in which directories and pathnames have to given
|
|
to the installation script. They are automatically converted to
|
|
Win32-style pathnames when given to the compiler or linker.
|
|
|
|
The main difference is that directories are seperated by slash (``/'')
|
|
rather than by backslash (``$\backslash$''). The other difference is
|
|
concerned with specifying drives. One way is to use POSIX-style
|
|
pathnames that map Win32-style drives (\texttt{A:}, \texttt{B:}) to
|
|
\texttt{//a/\ldots}, \texttt{//b/\ldots} respectively. For instance,
|
|
the path
|
|
\texttt{D:$\backslash$Mystuff$\backslash$Mydir$\backslash$LEDA}
|
|
translates to \texttt{//d/Mystuff/Mydir/LEDA}.
|
|
|
|
Alternatively, it can be done using the mount utility, that can be
|
|
used to establish a map between Win32-style drives and the Unix-like
|
|
style. More precisely, it maps the forest of the directories/files on
|
|
Win32-drives to a tree with the root that is usually located at the top
|
|
level of the boot drive, say \texttt{C:}. The root location can be
|
|
seen by typing \texttt{mount} command without parameters. For
|
|
instance, if \texttt{D:} is mounted on
|
|
\texttt{C:$\backslash$ddrive}\footnote{by typing \texttt{mount D:
|
|
/ddrive}} then the path
|
|
\texttt{D:$\backslash$Mystuff$\backslash$Mydir$\backslash$LEDA}
|
|
translates to \texttt{/ddrive/Mystuff/Mydir/LEDA}.
|
|
|
|
\paragraph{Upper/lower case and spaces in file names}
|
|
Behavior of Cygwin in this regard might be different from the \mswin\
|
|
behavior. In particular, using spaces in filenames should better be
|
|
avoided.
|
|
|
|
\paragraph{Links, shortcuts, etc} should be avoided as well.
|
|
|
|
\subsection{\msvc{}-setup}
|
|
\index{Cygwin!setup for \msvc{}}
|
|
\index{msvc@\msvc{}!setup on cygwin}
|
|
|
|
A number of environment variables has to be set (or updated)
|
|
in order to use the installation.
|
|
|
|
\texttt{PATH} should contain \msvc{} command line tools locations.
|
|
The environment variables \texttt{INCLUDE} and \texttt{LIB} should
|
|
point to the location of \msvc{} header files and to the location of
|
|
the \msvc{} libraries, respectively. The interface for doing this is
|
|
different for NT and for Win9*.
|
|
|
|
\paragraph{\mswin-NT4.0.}
|
|
\index{Cygwin!setup on NT4}
|
|
|
|
One can set the corresponding environment variables using the
|
|
usual NT interface\footnote{open MyComputer, press right mouse button,
|
|
select Properties, select Environment, set the relevant variables}.
|
|
Alternatively, they can be set in the \texttt{.bashrc} file for the
|
|
particular user, or in the system-wide \texttt{bash} customization
|
|
file (usually \texttt{/etc/bashrc}).
|
|
|
|
The result should look roughly as follows, assuming that
|
|
\texttt{C:$\backslash$PROGRA$\sim$1$\backslash$MICROS$\sim$2$\backslash$}
|
|
is the location of the \msvc{} installation.
|
|
\begin{verbatim}
|
|
LIB=C:\PROGRA~1\MICROS~2\VC98\LIB
|
|
INCLUDE=C:\PROGRA~1\MICROS~2\VC98\INCLUDE
|
|
\end{verbatim}
|
|
and \texttt{PATH} should contain
|
|
\begin{verbatim}
|
|
/PROGRA~1/MICROS~2/Common/msdev98/BIN:
|
|
/PROGRA~1/MICROS~2/VC98/BIN:/PROGRA~1/MICROS~2/Common/TOOLS:
|
|
/PROGRA~1/MICROS~2/Common/TOOLS/WINNT
|
|
\end{verbatim}
|
|
|
|
\paragraph{\mswin-9*.}
|
|
\index{Cygwin!setup on \mswin-9*}
|
|
|
|
First, the memory for environment variables has to be increased.
|
|
Select the Cygwin icon from the Start-menu, press the right mouse
|
|
button and choose \textit{Properties}. Go to \textit{Memory}, select
|
|
\textit{Initial Environment}, set it to at least 2048 and
|
|
\textit{apply} the changes.
|
|
|
|
Second, edit the file \texttt{cygwin.bat} (or \texttt{cygnus.bat} in
|
|
Cygwin~0.9), located in the cygwin main directory and add the line
|
|
\begin{verbatim}
|
|
call C:\PROGRA~1\MICROS~2\VC98\Bin\MSCVARS32.BAT
|
|
\end{verbatim}
|
|
where
|
|
\nonlinkedpath'C:\PROGRA~1\MICROS~2\'
|
|
%\texttt{C:$\backslash$PROGRA$\sim$1$\backslash$MICROS$\sim$2$\backslash$}
|
|
has to be customized according to where \msvc{} is installed on your
|
|
system. Depending on the version of \msvc{} you might have to replace
|
|
\texttt{MSCVARS32.BAT} by \texttt{VCVARS32.BAT}.
|
|
|
|
\lcTex{\begin{appendix}}
|
|
|
|
\section{Using \cgal\ and \leda}\label{sec:leda}
|
|
\index{LEDA@\leda!support in \cgal}
|
|
\cgal\ supports \leda\ in the following ways.
|
|
|
|
\begin{enumerate}
|
|
\item There are support functions defined for the \leda\ number types
|
|
\texttt{big\_float}, \texttt{integer}, \texttt{rational} and
|
|
\texttt{real} (see the files \texttt{<CGAL/leda\_*>}).
|
|
\item For all two-dimensional geometric objects there are input/output
|
|
operators for a \texttt{leda\_window}.
|
|
\item For all two-dimensional geometric objects there are output
|
|
operators to a \texttt{leda\_ps\_file}.
|
|
\item The registration functions needed to interact with a
|
|
\texttt{leda\_geowin} are defined for all geometric objects from the
|
|
\cgal\ kernel.
|
|
\item \cgal\ defines the following \leda-related compiler flags when
|
|
\leda\ is used: \texttt{CGAL\_USE\_LEDA} and \texttt{LEDA\_PREFIX}.
|
|
\end{enumerate}
|
|
|
|
The include makefiles in the \texttt{\cgaldir/make} directory
|
|
corresponding to \leda\ can be recognized by the suffix
|
|
``\texttt{\_LEDA}''.
|
|
|
|
\section{Compiler workarounds}
|
|
\index{compilers!workarounds}\index{workaround flags}
|
|
|
|
In \cgal, a number of compiler flags is defined. All of them start
|
|
with the prefix \texttt{CGAL\_CFG}. These flags are used to work
|
|
around compiler bugs and limitations. For example, the flag
|
|
\texttt{CGAL\_CFG\_NO\_LONG\_LONG} denotes that the compiler does not
|
|
know the type \texttt{long long}.
|
|
|
|
For each compiler a file \texttt{<CGAL/compiler\_config.h>}
|
|
\index{files!\texttt{compiler\_config.h}} is defined, with the correct
|
|
settings of all flags. This file is generated automatically by the
|
|
\texttt{install\_cgal} script, and it is located in the compiler
|
|
specific include directory. This directory can be found below
|
|
\texttt{include/CGAL/config/};
|
|
\index{directories!include/CGAL/config@\texttt{include/CGAL/config}}
|
|
\index{directories!compiler specific}\index{compiler specific include
|
|
directory} it is named according to the compiler's \cgal-OS
|
|
description (cf. Section~\ref{sec:os-compiler-id}).
|
|
|
|
The test programs used to generate the \texttt{compiler\_config.h}
|
|
file can be found in \nonlinkedpath'CGAL-3.0/config/testfiles'.
|
|
\index{directories!config/testfiles@\texttt{config/testfiles}} Both
|
|
\texttt{compiler\_config.h} and the test programs contain a short
|
|
description of the problem. In case of trouble with one of the
|
|
\texttt{CGAL\_CFG} flags, it is a good idea to take a look at it.
|
|
|
|
Within \cgal, the file \texttt{<CGAL/basic.h>}
|
|
\index{files!\texttt{basic.h}} manages all configuration problems. In
|
|
particular, it includes the file \texttt{CGAL/compiler\_config.h}. It
|
|
is therefore \textbf{important that \texttt{<CGAL/basic.h>} is always
|
|
included before any other file}. In most cases you do not have to do
|
|
anything special for this, because many \cgal\ files (in particular,
|
|
\texttt{<CGAL/Cartesian.h>} and \texttt{<CGAL/Homogeneous.h>}) already
|
|
take care of including \texttt{<CGAL/basic.h>} first. Nevertheless it
|
|
is a good idea to always start your \cgal\ programs with including
|
|
\texttt{<CGAL/basic.h>}.
|
|
|
|
\subsection{Standard Header Replacements}
|
|
\index{compilers!missing standard header files} %
|
|
\index{standard header replacements} %
|
|
\index{missing standard header files}
|
|
|
|
Some compilers do still not provide a complete standard library. In
|
|
particular they fail to provide the \texttt{C++} wrappers for files
|
|
from the standard \ccc{C} library, like \texttt{cstddef} for
|
|
\texttt{stddef.h}. The \cgal\ install scripts checks for all standard
|
|
header files and generates a simple wrapper file in the \cgal\ include
|
|
directory for those that are missing. These wrapper files include the
|
|
corresponding \texttt{C} header files and add all symbols required by
|
|
the \texttt{C++} standard into namespace \ccc{std}. You can turn off
|
|
the additions to namespace \ccc{std} by defining the macro
|
|
\ccc{CGAL_NO_STDC_NAMESPACE}.
|
|
\index{CGAL\_NO\_STDC\_NAMESPACE@\texttt{CGAL\_NO\_STDC\_NAMESPACE}}
|
|
|
|
\section{Compiler Optimizations}\label{sec:compiler-optimisations}
|
|
\index{compilers!optimization}
|
|
\index{optimization compiler flags}
|
|
|
|
You may have noticed that we do not set optimizer flags as \texttt{-O}
|
|
by default in the include makefiles(see section~\ref{sec:makefiles} for
|
|
a description of the makefile structure in \cgal). The main reason
|
|
for not doing this is that compilers run much more stable without. On
|
|
the other hand, most if not all \cgal\ programs will run considerably
|
|
faster when compiled with optimizations! So if you are going for
|
|
performance, you should/have to add \texttt{-O}, \texttt{-O3} or maybe
|
|
more specific optimizer flags (please refer to the compiler
|
|
documentation for that) to the \texttt{CXXFLAGS} variable in your
|
|
application makefile:
|
|
\begin{alltt}
|
|
#---------------------------------------------------------------------#
|
|
# compiler flags
|
|
#---------------------------------------------------------------------#
|
|
# The flag CGAL_CXXFLAGS contains the path to the compiler and is defined
|
|
# in the file CGAL_MAKEFILE. You may add your own compiler flags to CXXFLAGS.
|
|
|
|
CXXFLAGS = $(CGAL_CXXFLAGS) -O
|
|
\end{alltt}
|
|
%$
|
|
|
|
\section{Troubleshooting}\label{sec:troubleshooting}
|
|
\index{troubleshooting}
|
|
|
|
This section contains some remarks about known problems and the
|
|
solutions we propose. If your problem is not listed here, please have
|
|
a look at the \cgal\ homepage:
|
|
\begin{alltt}
|
|
\cgalhomepage
|
|
\end{alltt}
|
|
or send an email to \texttt{contact@cgal.org}.
|
|
|
|
\subsection{Compiler version test execution failed}
|
|
\label{sec:compvertestfails}
|
|
\index{Compiler version test}\index{compilers!version test}
|
|
|
|
Possibly already during the startup of the install script, the
|
|
execution of the compiler version test might fail with the following
|
|
(or similar) error message.
|
|
\begin{verbatim}
|
|
ld.so.1: ./tmp_test: fatal: libstdc++.so.5:
|
|
open failed: No such file or directory
|
|
\end{verbatim}
|
|
This means that the standard \CC\ library for your compiler is
|
|
installed in a directory that is not on your current runtime linker
|
|
path. You can solve this problem by adding the directory containing
|
|
\texttt{libstdc++.so} to your runtime linker path, usually
|
|
represented by the environment variable \texttt{LD\_LIBRARY\_PATH}.
|
|
|
|
For example, if you have a standard \texttt{gcc} installation below
|
|
\texttt{/software/gcc-3.3.2/}, you would type
|
|
\begin{alltt}
|
|
export LD_LIBRARY_PATH=/software/gcc-3.3.2/lib:$LD_LIBRARY_PATH
|
|
\end{alltt}
|
|
for bourne shell alikes, while for \texttt{csh} descendants the syntax
|
|
is
|
|
\begin{alltt}
|
|
setenv LD_LIBRARY_PATH /software/gcc-3.3.2/lib:$LD_LIBRARY_PATH
|
|
\end{alltt}
|
|
You might want to add this command to your shell startup file.
|
|
|
|
Alternatively, you can build the runtime linker path into the
|
|
executables by setting corresponding custom linker flags (cf.
|
|
Section~\ref{sec:compiler-menu}).
|
|
|
|
\subsection{Defect in the G++ 3.2 ABI}
|
|
\label{sec:gcc32abi}
|
|
\index{gcc@\texttt{g++} 3.2 ABI}\index{compilers!gcc@\texttt{g++} 3.2 ABI}
|
|
|
|
Some versions of \texttt{gcc}, for example \Gcc{3.3.0}, have problems
|
|
in their \CC-ABI, that surface in error messages similar to the
|
|
following.
|
|
%
|
|
\begin{verbatim}
|
|
error: due to a defect in the G++ 3.2 ABI, G++ has assigned
|
|
the same mangled name to two different types.
|
|
\end{verbatim}
|
|
%
|
|
If this occurs to you, please seriously consider upgrading your
|
|
compiler. This issue is fixed starting from \Gcc{3.3.1}.
|
|
Alternatively, you can add \texttt{-fabi-version=0} to your custom
|
|
compiler flags\footnote{Thanks to Christopher Intemann for pointing
|
|
this out.}. In interactive mode, this is done via the Compiler Menu,
|
|
as described in Section~\ref{sec:compiler-menu}. Afterwards rebuild
|
|
the libraries. But note that changing the \textsc{Abi} might have side
|
|
effects. Hence, a compiler upgrade is the recommended fix here.
|
|
|
|
\subsection{The ``Long-Name-Problem'' on IRIX6}\label{sec:longnameirix}
|
|
\index{problems with long names}\index{long name problem}
|
|
|
|
The system assembler and linker on IRIX6 cannot handle symbols with
|
|
more than 4096 characters. But this number can be exceeded when one
|
|
starts nesting templates into each other. So if you encounter strange
|
|
assembler or linker errors like
|
|
\begin{alltt}
|
|
as: Error: /var/tmp/ccPBl5vJ.s, line 41289: Truncating token:
|
|
<some ridiculously long token snipped>
|
|
\end{alltt}
|
|
there is a good chance that you suffer from this ``long-name''
|
|
problem.
|
|
|
|
In contrast to Solaris, using the \gnu\ binutils does not work, since
|
|
\texttt{gas} has not been ported to IRIX6 yet. The solution proposed
|
|
in the GCC
|
|
faq\footnote{\path'http://gcc.gnu.org/cgi-bin/fom.cgi?file=41'} is to
|
|
compile with the (experimental) option \texttt{-fsquangle}, that
|
|
enables compression of symbol names. This option was experimental and
|
|
has disappeared in GCC 3.0, where the ABI has been improved. So this
|
|
is only interesting for GCC 2.95.3.
|
|
|
|
Citing from the above FAQ:
|
|
|
|
\begin{alltt}
|
|
Note that this option is still under development, and subject to
|
|
change. Since it modifies the name mangling mechanism, you'll need to
|
|
build libstdc++ and any other C++ libraries with this option enabled.
|
|
Furthermore, if this option changes its behavior in the future, you'll
|
|
have to rebuild them all again. :-(
|
|
|
|
This option can be enabled by default by initializing
|
|
`flag_do_squangling' with `1' in `gcc/cp/decl2.c' (it is not
|
|
initialized by default), then rebuilding GCC and any C++ libraries.
|
|
\end{alltt}
|
|
|
|
\subsection{The ``Long-Name-Problem'' on Solaris}\label{sec:longnamesolaris}
|
|
\index{problems with long names}\index{long name problem}
|
|
|
|
The system assembler and linker on Solaris 2.5 and 2.6 cannot handle
|
|
symbols with more than 1024 characters. But this number is quickly
|
|
exceeded where one starts nesting templates into each other. So if you
|
|
encounter strange assembler or linker errors like
|
|
\begin{alltt}
|
|
/usr/ccs/bin/as: "/var/tmp/cc0B5iGc.s", line 24:
|
|
error: can't compute value of an expression involving an external symbol
|
|
\end{alltt}
|
|
there is a good chance that you suffer from this ``long-name''
|
|
problem.
|
|
|
|
A solution is to install the \gnu -binutils\footnote{see
|
|
\path'http://www.gnu.org/software/binutils/'} and to tell the
|
|
compiler that it shall use the \gnu-- instead of the native tools.
|
|
From the compiler-menu (described in section \ref{sec:compiler-menu})
|
|
you can set the corresponding option through the custom compiler
|
|
flags, i.e. for \texttt{gcc} you would add
|
|
\begin{alltt}
|
|
-B/my/path/to/gnu/binutils/bin
|
|
\end{alltt}
|
|
assuming you installed the \gnu -binutils executables in
|
|
\texttt{/my/path/to/gnu/binutils/bin}.
|
|
|
|
If you cannot (or do not want to) install \gnu -binutils, there is a
|
|
workaround that lets you compile, link and run your programs, but it
|
|
prevents debugging, since the executables have to be stripped. In
|
|
short the workaround is to compile with \texttt{-g} and to link with
|
|
\texttt{-z nodefs -s} on Solaris, \texttt{-U -s} on IRIX,
|
|
respectively.
|
|
|
|
In order to still have portable makefiles (see
|
|
section\ref{sec:makefiles}), we define flags
|
|
\texttt{LONG\_NAME\_PROBLEM\_CXXFLAGS} and
|
|
\texttt{LONG\_NAME\_PROBLEM\_LDFLAGS} in the include makefiles which
|
|
are empty except for the Solaris platform where they are set as stated
|
|
above. In order to use these flags, edit your application makefile and
|
|
add the flags to \texttt{CXXFLAGS} resp. \texttt{LDFLAGS} as indicated
|
|
below.
|
|
\begin{alltt}
|
|
#---------------------------------------------------------------------#
|
|
# compiler flags
|
|
#---------------------------------------------------------------------#
|
|
# The flag CGAL_CXXFLAGS contains the path to the compiler and is defined
|
|
# in the file CGAL_MAKEFILE. You may add your own compiler flags to CXXFLAGS.
|
|
|
|
CXXFLAGS = $(LONG_NAME_PROBLEM_CXXFLAGS) $(CGAL_CXXFLAGS)
|
|
|
|
#---------------------------------------------------------------------#
|
|
# linker flags
|
|
#---------------------------------------------------------------------#
|
|
# The flag CGAL_LDFLAGS contains common linker flags and is defined
|
|
# in the file CGAL_MAKEFILE. You may add your own linker flags to CXXFLAGS.
|
|
|
|
LDFLAGS = $(LONG_NAME_PROBLEM_LDFLAGS) $(CGAL_LDFLAGS)
|
|
\end{alltt}
|
|
|
|
\subsection{\leda\ and \stl\ conflicts}\label{subs:ledastlconfl}
|
|
|
|
If you are using an old version of \leda, the combination of \leda\
|
|
and \stl\ may give some problems. In order to avoid them, it is highly
|
|
recommended to use the latest \leda\ release, since this is what we
|
|
test \cgal\ with.
|
|
|
|
\index{LEDA@\leda!on \bcc}\index{LEDA@\leda!on \msvc}
|
|
With \msvc\ or \bcc, \leda\ has to be compiled and used with the
|
|
\texttt{LEDA\_STD\_HEADERS} flag set. \cgal\ uses \CC\ standard
|
|
conformant headers\footnote{the ones that do not have \texttt{.h}
|
|
suffix}, while \leda\ can also work with the old-style header files;
|
|
but mixing the styles is strictly forbidden. Before compiling \leda\,
|
|
edit the file \texttt{\$(LEDAROOT)/incl/LEDA/system.h} and uncomment
|
|
the \texttt{\#define} in the following fragment there.
|
|
\begin{alltt}
|
|
// use c++ std headers
|
|
//#define LEDA_STD_HEADERS
|
|
\end{alltt}
|
|
|
|
\paragraph{\msvc-specific problems.}
|
|
|
|
Also, the \leda\ and \cgal\ libraries have to be compiled with the
|
|
same options controlling the use of debugging and multithreading.
|
|
\footnote{\msvc\ compilation/linking options \texttt{-ML, -MT, -MD,
|
|
-MLD, -MTD, -MDD}}
|
|
|
|
If a binary release of \leda{} is used, make sure that it is one of
|
|
them that uses new-style headers. Namely, among the self-extracting
|
|
executables, choose one of these that have the name ending with
|
|
\texttt{-std.exe}.
|
|
|
|
\subsection{\msvc{}-specific \CC\ problems}
|
|
\index{msvc@\msvc{}!specific \CC\ problems}
|
|
|
|
\subsubsection{\msvc{6.0}}
|
|
|
|
This compiler version is no longer supported starting with \cgal\ 3.0.
|
|
|
|
\subsubsection{\msvc{7.0} (\textsc{.NET})}
|
|
|
|
This compiler version is no longer supported starting with \cgal\ 3.1.
|
|
|
|
\medskip
|
|
|
|
\textbf{Other problems.}
|
|
|
|
Here goes an incomplete list of problems encountered, and
|
|
\cgal-specific workarounds, if available. Compiler error messages are
|
|
meant to be hints only, and do not pretend to be complete, as well.
|
|
\begin{enumerate}
|
|
%
|
|
\item Compiler does not support the Koenig
|
|
lookup. That is, it does not search in the namespace of the arguments for
|
|
the function. See
|
|
\texttt{config/testfiles/CGAL\_CFG\_NO\_KOENIG\_LOOKUP.C}. \label{msvc::koenig}
|
|
%
|
|
\item Internal compiler errors can sometimes be avoided by increasing
|
|
the amount of memory available to the compiler. Use \texttt{-Zm<number>}
|
|
option. In \cgal\ makefiles it is set to \texttt{-Zm900}, meaning
|
|
``using 900\% out of the usual memory limit''. \label{msvc::Zm}
|
|
%
|
|
\item \texttt{[...]/VC98/INCLUDE/xlocnum(268) :
|
|
error C2587: '\_U' :\\
|
|
illegal use of local variable as default parameter} can
|
|
occur\footnote{For instance, in \cgal\ \texttt{Min\_circle}
|
|
package}. The only workaround we know is to redefine the macro
|
|
\texttt{\_VIRTUAL} in \texttt{<xlocnum>}\footnote{Yes, in the \msvc\
|
|
header! You need not edit the actual file though. Copy it to
|
|
a directory that is searched ahead of the other directories.
|
|
DISCLAIMER:
|
|
{\em We do not know if the actions described in this footnote are
|
|
legal in your country. You are on your own here.}}
|
|
to be empty. Search for\\
|
|
\texttt{\#define~\_VIRTUAL~virtual} there and replace it by
|
|
\texttt{\#define~\_VIRTUAL~}. \label{msvc::VIRTUAL}
|
|
%
|
|
\item Various matching failures for overloaded functions and ctors.
|
|
Use dummy parameters.
|
|
%
|
|
\item Avoid multiple forward declarations.
|
|
%
|
|
\item If necessary, simplify template parameters by using extra
|
|
\texttt{typedef}s.
|
|
\end{enumerate}
|
|
|
|
\section{Scripts}
|
|
|
|
\subsection{\texttt{create\_makefile}}\label{sec:create_cgal_makefile}
|
|
\TTindex{create\_makefile}\index{scripts!\texttt{create\_makefile}}
|
|
|
|
The bourne-shell script \texttt{create\_makefile} is contained in the
|
|
\cgaldir\texttt{/scripts} directory. It can be used to create
|
|
makefiles for compiling \cgal\ applications. Executing
|
|
\texttt{create\_makefile} in an application directory creates a
|
|
\texttt{makefile} containing rules for every \texttt{*.C} file there.
|
|
|
|
In order to use this makefile, you have to specify the \cgal\ include
|
|
makefile (see section~\ref{sec:makefiles}) to be used. This can be
|
|
done be either setting the environment variable
|
|
\texttt{CGAL\_MAKEFILE} or by editing the line
|
|
\begin{alltt}
|
|
# CGAL_MAKEFILE = ENTER_YOUR_INCLUDE_MAKEFILE_HERE
|
|
\end{alltt}
|
|
of the created makefile. First remove the ``\texttt{\#}'' at the
|
|
beginning of the line and then replace the text after ``\texttt{=}''
|
|
by the location of the include makefile.
|
|
|
|
Finally type \texttt{make} to compile the application programs.
|
|
|
|
\lcTex{\end{appendix}}
|
|
|
|
%%
|
|
%% EOF
|
|
%%
|
|
|
|
|