This section explains how to compile and install the Cogitant library from source. Different procedures must be followed depending on the operating system and the compiler. The table below sums up the different architectures and compilers with which the library has been tested.
|GNU/Linux||Debian Wheezy (testing) x86_64||GNU C++ 4.5.3||5.2.91|
|-||-||GNU C++ 4.6.0||5.2.91|
|-||-||Intel C++ 13.0.1||5.2.91|
|MS Windows||7||Microsoft Visual C++ 2010 Express (10.0.30139.1)||5.2.91|
|-||XP||Microsoft Visual C++ 2008 Express SP1 (9.0.30729.1SP)||5.2.90|
|-||2000||Microsoft Visual C++ 2005 Express (8.0.50727)||5.2.91|
|-||-||Cygwin GNU C++ 4.5.0||5.2.90|
|-||-||Mingw GNU C++ 4.5.2||5.2.90|
|Mac OS||10.7.4||GNU C++ 4.2.1-LLVM (Xcode 4.3.3)||5.2.91|
|-||-||GNU C++ 4.7.2 (Macports)||5.2.91|
|-||-||GNU C++ 4.8.0 (Macports)||5.2.91|
|-||-||LLVM Clang 3.2 (Macports)||5.2.91|
|OpenSolaris||2009.06||GNU C++ 4.3.2||5.2.6|
|-||-||Sun Studio Express 12 (2009.03)||5.2.3|
|Solaris||5.10 (sun4u)||GNU C++ 3.4.5||5.2.4|
|FreeBSD||8.2 (i386)||GNU C++ 4.2.1||5.2.91|
Note: This information concerns only basic classes of Cogitant (namespace cogitant), but neither the classes of the client/server architecture, nor the drawing and interfacing classes with Java.
The instructions for compiling described below refer to the basic classes of the library. If you wish to use extensions (client/server architecture, graph design and edition, CommonC++ interfacing, wxWidgets or Java), the compilation is done in much the same way, but specific options must be provided to the compiling mechanism. In order to know in detail these options, you can refer to the section Graphs drawing - compilation and to the section Client-server architecture - compilation.
Two methods are available for the compiling of Cogitant. Depending on the operating system, you must use one method or another. The first method is to use a script
configure, a familiar approach to users of Unix-based systems (from now on simply called Unix). This method has the advantage of being basic, but the disadvantage of being available only for Unix, because it requires the presence of an interpreter of shell scripts (
sh). The other method is to use Cmake (http://www.cmake.org) whose main advantage is to be available both for Unix and MS Windows, but this method requires the installation of Cmake before launching the compiling of Cogitant.
Cogitant uses the classical mechanism for compiling under Unix (
./configure, make, make install). If you are familiar with this mechanism, there is no need to read this section. Note that Cmake can also be used under Unix, refer to section Installing with Cmake for more information. Make sure you have a C++ compiler installed before going further. Under MacOS, install Xcode, which can be downloaded for free from Apple website (http://developer.apple.com/technology/xcode.html).
First, you must unpack the archive containing the source. To do so, proceed as follows:
This will create a directory
cogitant-5.x.x containing the source of the library, but also the header files, documentation and example programs. You have now to compile the source in order to build the library file, which can later be linked to your applications. Before that, you have to configure the compiling this way:
The call to
configure (which is a script file located in the
cogitant directory) creates a number of files, enabling the construction of the library. You can pass a number of parameters to this script in order to setup the compiling. Most of these settings can help settling details of the compiling and it is often unnecessary to alter them unless you know what you are doing. Note that a parameter is often used, it is
– prefix, which allows you to specify in which directory the result of the compilation will be installed. By default, it is the
/usr/local directory (header files are installed in
/usr/local/include, the library in
/usr/local/lib, etc.), however if you do not have the rights (root) on this directory, you need to specify a different directory (
./configure –prefix=/home/ users/me/usr for example). In this case, you must set the value of environment variables
LD_LIBRARY_PATH in order to simply use the library. The purpose of this documentation is not to describe the use of Unix, we do not describe handlings to be done to achieve this result and consider in the future that the files of the platform are correctly installed in reachable directories in the various search directories (e.g. it is the default if you do not use the
–prefix parameter). Refer to a "Unix guru" you know if you do not feel able to perform these operations: Cogitant is used like any other library, and any Unix guru worthy of the name knows how to create a tree
usr specific to a user.
Once the configuration is done, it is possible to launch the compiling of the library in the following manner:
Compiling takes some time, varying obviously according to the capabilities of your hardware. If the compiling is done without incident, you can now install the library in the directories selected at the time of the
configure call, for that, just type:
And it's over, now you can compile your own programs that use the library, and for that, please refer to the section Programm compiling using Cogitant.
You need to use the GNU tools rather than Sun tools. The names of the GNU tools are usually prefixed by
g under SunOS. For example, to uncompress the archive, use the GNU tar rather than the Sun tar (
gtar zxvf cogitant-5.x.x.tar.gz). Similarly, to compile the source of the library use the GNU make (
gmake followed by
gmake install). Depending on the installation, it may be required to specify the make command to be used for the call of the Makefiles of the lower levels, for that, type
gmake MAKE=gmake. If the compiling immediately ends with an error, you may have to regenerate some files. For that, type
configures detects the default compiler and the compiling is done with this compiler, usually version 4.x of GNU C++. Nevertheless, it is possible to force the script
configure to use a different compiler. To do this, simply set environment variables
CXX before running the script. These two variables must have as value respectively the name of the C compiler used, and the name of the C++ compiler. If needed, these names must be prefixed by a path if executables are not included in the
Using GNU C++ 4.x under Debian testing/unstable
The default compiler of recent versions of Debian testing/unstable is gcc 4.6. Besides, it is recommended that you use this version of the compiler. If you wish to use an older version (4.x) or higher (4.6) of the compiler, you must use the following commands (after ascertaining this version has been properly installed, of course).
Obviously if you use [t]csh, you must use
setenv instead of
Note that the compiler executables names given above match a Debian distribution. These names may differ depending on the system. Note that it is however better to use versions >= 4.1 of the GNU compiler and that best performances are from version 4.4.
Using Intel C++ compiler
Intel C++ compiler may be freely downloaded for a non commercial use at: http://software.intel.com/en-us/articles/non-commercial-software-download/ (Intel C++ Composer XE for Linux)
Assuming the compiler is installed in the directory
Using Sun Studio compiler
Assuming the compiler is installed in
Using LLVM Clang compiler
Assuming the compiler is
Note that if you have already launched the
configure script, you should delete the file
config.cache before launching the
configure script again with the new values for
configure script can receive arguments that allow you to configure how Cogitant is compiled.
./configure –help returns the argument list, some of which being common to all configuration scripts generated by the infernal couple autoconf/automake, others being specific to Cogitant. Among the specific arguments, we'll cite a few.
–enable-optimize(and its opposite
–disable-optimize) generates a more efficient code, at the expense of a longer compiling.
–disable-assert(and its opposite
–enable-assert) deletes checkouts done in Cogitant, and enables a faster execution of operations, and must therefore be used when the program code that you develop on Cogitant was debugged.
Cmake is the second compiling method of Cogitant, but unlike the use of
configure, this method requires the installation of an additional application: Cmake. Nevertheless, the application is available packaged in any modern Unix systems. In order to check that cmake is properly installed, just type
cmake –version in a shell. The version 2.6.3 (at least) of Cmake is required.
Here we describe the compiling of Cogitant with Cmake in a subdirectory of the directory
cmake. Obviously, this name is just an example.
ccmake is a simplified interface for configuring the compiling. Once
ccmake loaded, type
c to display configuration options. The screen appearing then allows you to select Cogitant modules to be constructed (Java Interfacing, for example) and the compiling configuration (
CMAKE_BUILD_TYPE can take the value
Release for an optimized compiling and
Debug for a compilation with debugging information). Press
c (after having, if needed, modified certain values) to launch the configuration, then
g to generate makefiles. Indeed, the
ccmake command generates makefiles matching to the selected configuration, so it only remains to compile Cogitant with a basic:
Note that Cmake can also handle other compilers such as Intel C++, for this, you have to define the environment variables in the way given above before calling
ccmake. Finally, note that the
cmake command can be used in place of
ccmake and allows you to set compiling arguments on the command line rather than in an interface, which can be useful for automating the Cogitant construction. Refer to the documentation of cmake (http://www.cmake.org/HTML/RunningCMake.html) for more information.
This compiler is the recommended one on MS Windows because it is, unlike previous versions, a compiler almost respecting the norm. Nevertheless, solutions based on free software tools must not be forgotten using Cygwin and Mingw which are described below. The approach described here is valid for the Express version of the compiler, which has the advantage of being free, but the approach can be adapted easily to commercial versions of the compiler.
The compiler is available for free from Microsoft's website at the following address: http://www.microsoft.com/france/msdn/vstudio/express/visualc/default.mspx
If you use version 2008, you just have to install Cmake. But if using version 2005, you have to, after installing the compiler, install the SDK platform (which is not required with the commercial version, as the SDK is supplied on the installation media). This SDK can also be downloaded for free from Microsoft's website. There are many SDK platforms available on the website, you can choose the version Server 2003 R2 available at http://www.microsoft.com/downloads/details.aspx?FamilyId=0BAF2B35-C656-4969-ACE8-E4C0C0716ADB&displaylang=en . If you are still using MS Windows 2000, this version will not install, but you can still install the previous version: http://www.microsoft.com/downloads/details.aspx?FamilyID=a55b6b43-e24f-4ea3-a93e-40c0ec4f68e5&DisplayLang=en .
Troubles begin here. Visual C++ is not warned that the SDK was installed, however, SDK libraries have to be used by programs compiled by VC++. Therefore VC++ has to be informed about this change of configuration. Load Visual C++, and go to the Tools, Options, Projects and Solutions, VC++ directories, Library files and add the SDK directory, which is by default
C:\Program Files\Microsoft Platform SDK for MS Windows Server 2003 R2\Lib. This manipulation should not be required with the commercial version of VC++.
Visit the website of Cmake http://www.cmake.org , download and install the MS Windows version.
Before compiling the sources, you have to extract them from the archive, for this you have to use a tool able to handle
tar.gz files like 7zip (free software available at http://www.7-zip.org/), or Total Commander (http://www.ghisler.com).
Load Cmake from the Start menu and inform it about the directory containing Cogitant's sources in the Where is the source code field (e.g.
D:\cogitant-5.x.x). In the second field of Where to build the binaries, we'll specify either the same directory, or another directory which will contain the result of the compiling (e.g.
D:\cogitant-5.x.x\cmake). Click on Configure, and ask for the creation of files for Visual Studio 8 2005 (or Visual Studio 9 2008...). If required, modify the value of certain parameters, then click on Configure. Click then on Generate (or Ok depending on the Cmake version). Cmake deals with the creation of project files for VC++.
With the directories above-cited, Cmake has created a file
cogitant.sln in the directory
D:\cogitant-5.x.x\cmake. Run this file, which will open VC++ on this project, and start the compiling by pressing F7 (after having, if needed, chosen the compiling method Debug or Release). Beware, if you want to redistribute an application compiled with VC++, you must compile it with the Release mode because the runtime DLL of VC++ in debugging mode are not redistributable.
The Cygwin suite (http://www.cygwin.com) is a set of tools enabling to easily compile Unix-made sources. The compiler included in this suite is GNU C++ 3.4. The compiling with Cygwin is done in exactly the same way as under Unix. After starting Cygwin (
bash –login), execute the following commands:
The Mingw toolkit (http://www.mingw.org) is a MS Windows version of the GNU compiler and related tools. Unlike Cygwin which provides an emulation layer for Unix (both system calls and command line utilities), Mingw only contains the compiler and tools needed to build MS Windows programs that can use the Win32 API, but that cannot use systems call specific to Unix. The main benefit of using Mingw compared with Cygwin lies in the absence of the "heavy artillery" established by Cygwin in order to make applications believe they run under Unix: thus, any software compiled with Cygwin is dynamically linked to the
cygwin1.dll library which must be compulsorily supplied with your applications (the other constraint is that an application compiled with Cygwin must be GPL, but it is also the case of an application using Cogitant). On the contrary, Mingw produces a "pure" MS Windows executable, which does not require this dll. Nevertheless, it should be noted that the compiling of C++ source with Mingw produce an executable requiring the
libstd++.dll library (supplied with Mingw, but which must be distributed with your applications in the case of an installation on a workstation where Mingw is not installed). Cogitant can be compiled with the configure script (Unix way) or CMake (recommended).
See Configuration for generic instructions about the use of CMake with Cogitant. For Mingw, you obviously have to choose the "MinGW Makefiles" generator. Once makefiles are generated, open a command prompt window. Change the current directory to the directory where makefiles have been generated and run the Mingw make. If Mingw has been installed in
C:\mingw, Cogitant has been installed in
D:\cogitant-5.x.x and CMake-generated makefiles are in the subdirectory
D:\cogitant-5.x.x, the following commands start the compiling.
No tool is supplied with Mingw for building an application, while you need a shell application and other tools to compile Cogitant or other programs. That is why you have to install, in addition to the Mingw package, the MSys package (for minimal system). This package provides (among other things) a shell required for the execution of the
configure script, and can be downloaded from the Mingw's main website.
Once the Mingw and MSys packages are installed, open a MSys session using the Start menu, and start the compiling with
./configure –disable-shared followed by a