Déroulement d'un programme C++ et compréhension

**dfshr8** · 20/07/2015, 12h50

Bonjour,
J'ai une tone de questions puique je dois comprendre le code soure C++ d'une bibliothèque pour la modifier ultérieurement.

1) Comment suivre le déroulement d'un programme écrit en C++ ?
Du style un programme qui affiche la première ligne :par exemple le #include et affihe ce qu'il fait en retour de cette instrution.
Un programme qui suit instruction par instruction ce que fait le programme. Afin que je comprenne bie...

**ternel** · 20/07/2015, 13h12

Il s'agit surtout de comprendre comment se fait la compilation (pour les #includes et autres #ifdef), et ensuite d'utiliser un EDI correct, qui te permettra de suivre le code en cliquant sur les fonctions.

D'après ta question, je te souhaite bien du courage.
Commence par la documentation, s'il y en a.

**white_tentacle** · 20/07/2015, 14h09

Envoyé par dfshr8

Bonjour,
J'ai une tone de questions puique je dois comprendre le code soure C++ d'une bibliothèque pour la modifier ultérieurement.

1) Comment suivre le déroulement d'un programme écrit en C++ ?
Du style un programme qui affiche la première ligne :par exemple le #include et affihe ce qu'il fait en retour de cette instrution.
Un programme qui suit instruction par instruction ce que fait le programme. Afin que je comprenne bie...

Ce que tu veux, ça s’appelle un débugger

. Normalement, si tu utilises un IDE digne de ce nom, il doit y avoir une intégration.

**dfshr8** · 20/07/2015, 14h28

Envoyé par white_tentacle

Ce que tu veux, ça s’appelle un débugger

. Normalement, si tu utilises un IDE digne de ce nom, il doit y avoir une intégration.

Je suis sous Linux, quel IDE me conseillez vous ? (j'avais pensé à Code Blocks...)

**ternel** · 20/07/2015, 14h36

C'est un bon choix.
Une autre possibilité est Eclipse pour C++ (Eclipse CDT).
En version plus léger, il y a Geany, dont j'ai entendu dire du bien.

**dfshr8** · 20/07/2015, 14h57

Ah mais j'utilise Geany, bizarrement il ne me met pas toutes les variables, me permet pas de faire des "breakpoint"... Peut être que j'ai oublié d'activer certaines choses...

**dfshr8** · 20/07/2015, 15h14

Bon j'ai tout de même un énorme problème:

Voici ce qui est indiqué pour faire fonctionner le programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Procédure suivie:
#wget https://gforge.inria.fr/frs/download.php/file/34672/SCALFMM-1.3-56.tar.gz (Télécharger les sources)
 
On obtient: SCALFMM-1.3-56.tar.gz // le décompresser
 
A l'interieur du dossier (décompréssé) créer un fichier: "Build": mkdir Buid
cmake .. (le .. fait référence aux dossier parent)
ccmake .. (pour mettre les flaggs)
make (pour rendre executable)

Du coup lors du ccmake .., j'active ou non des "Flagg": j'active DATA (pour qu'il y ait les fichiers de données).
Puis lorsque je vais dans build/release: j'ai direct mes executables! Donc je ne peux suivre le cheminement. Pour celà il faut que je retrouve le .cpp (et non l' executable).

Du coup dans mon dossier je cherche l'executable avec un find -name :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
laurent@Ellington:~/Bureau/SCALFMM-1.3-56$ find -name 'DirectComputation.cpp'
./Examples/DirectComputation.cpp

Je me place dans le dossier en question et ouvre Geany pour l' executer. Et là bahm, toutes les arborescences sont fichues... Le make (ou le cmake je ne sais pas trop s'est sans doute ocupé de mettre tout au bon ordre je ne peux me permettre de tout refaire à la main (ie) de recompiler le .cpp et copier les fichiers et dossier au bon endroit, ca me prendrait une semaine...

**dfshr8** · 20/07/2015, 15h39

apperement gdb sembe travailler diretement sur l' executable (et nonj sur le .cpp). Je ne sais pas trop la différence entre le gdb et un debugger 'un IDE...

**white_tentacle** · 20/07/2015, 15h42

Si tu peux, utilise qtcreator. Il n’est pas spécifiquement lié à qt (même si l’intégration qt y est clairement beaucoup plus aboutie que partout ailleurs), et c’est ce que j’appelle un ide digne de ce nom, qui plus est assez facile à prendre en main. Kdevelop, de mémoire, est pas mal non plus, mais ça fait bien longtemps que je n’en ai pas relancé une version.

**dfshr8** · 20/07/2015, 17h21

A première vue gdb est e qui réponds le plus à mes besoins:
- un outil simple facilement/rapidement pris en main
- qui permet de suivre le contenue des variables/
- mettre des arrêts
- fontionne directement sur l' executable (contrairement à tous les autres qui nécessitent de passer par le source .cpp)

**dragonjoker59** · 20/07/2015, 17h51

GDB est le debugger.
Des IDE tels que Code::Blocks (que j'affectionne) ou Eclipse CDT s'appuient dessus pour permettre à l'utilisateur de debugger "plus facilement".
Avec CMake (puisque c'est ce qui est utilisé) tu peux spécifier le type de "générateur" utilisé, ave l'option ligne de commande appropriée.
Par exemple cmake -G "CodeBlocks - Unix Makefiles" . va générer un projet Code::Blocks basé sur des Makefiles.
Rien qu'avec ça tu devrais pouvoir debugger tranquillement ton programme.

**dfshr8** · 21/07/2015, 14h19

Envoyé par dragonjoker59

GDB est le debugger.
Des IDE tels que Code::Blocks (que j'affectionne) ou Eclipse CDT s'appuient dessus pour permettre à l'utilisateur de debugger "plus facilement".
Avec CMake (puisque c'est ce qui est utilisé) tu peux spécifier le type de "générateur" utilisé, ave l'option ligne de commande appropriée.
Par exemple cmake -G "CodeBlocks - Unix Makefiles" . va générer un projet Code::Blocks basé sur des Makefiles.
Rien qu'avec ça tu devrais pouvoir debugger tranquillement ton programme.

Merci je comprends mieux (d'ailleurs j'avais repéré que cmake était compatible avec CodeBlocks: http://www.cmake.org/Wiki/CMake_Gene...ic_Information). Par contre je dois vous avouer qu' étant mauvais en informatique je n'y comprend rien...

1) Qu'est ce que le CMAKe ? (j'ai imprimé le cours C++ de developpez.net pour me documenter un peu.
Je trouve ça étrange: je télécharge un dossier comprenant les routines qui m'interessent (comme DirectComputation.cpp). Puis je m'aperçoit que c'est un foutoir pas possible: quand je veux faire la commande g++ -o DuirectComputation DirectComputation.cpp ben la hierrarchie/l'arborescence n'est pas respecté. Le compilateur ne troiuve pas les autres fichiers utiles (les headers .h, les autres fichiers auxiliaires .cpp qui sont en dehors du main...). Poiurtant dans le dossier d'origine tous ces fichiers sont bien présents. Alors pourquoi ne pas distribuer le dossier correctement hiérarchiser?? Pourquoi passer par un Cmake et un make? A priori si je compile mon .main et que tous les fichiers sont correctements disposés le compilateur fait tous tous seul....

2) Comment concrètement ouvrir mon fichier avec Codeblocks ? Ou est ce que je tape: cmake -G "CodeBlocks - Unix Makefiles ? Est ce que qqun peut m' expliquer où je tape cette commande? Dans un terminal? Dans quel dossier? En partant du principe que je ne connais rien à l' info : ça fait 3 semaines que j'apprends le c++ et que ma connaissance de Linux s'est forgée en 3 heure...

**ternel** · 21/07/2015, 14h34

pour la question 1, il y a trois programmes dans la boucle:

le compilateur lui-même (a priori, gcc), qui compilera chaque fichier.
make, qui pilote le compilateur, pour lui dire quand compile ou non tel ou tel fichier. Ceci, afin de ne pas recompiler du code qui n'a pas changé.
cmake, qui crée le fichier de pilotage utilisé par make: le makefile.

make est apparu pour accélérer et simplifier la compilation. Les options de compilations sont renseignées par lui, plutot que par toi.
Pour cela, il suffit d'écrire un fichier spécial nommé normalement makefile, dans lequel on écrit les commandes à exécuter.

cmake fut créé plus tard pour simplifier l'utilisation de make.
En effet, dès que le projet est assez gros, le makefile devient difficile à écrire, à controler, et donc à maitriser.
L'intérêt initial de cmake était de créer ce makefile à partir de quelques questions et des informations qu'il peut trouver dans l'ordinateur (chemin des bibliothèques, des dossiers standard, nature et version de l'OS, par exemple).

Puis CMake a évolué pour pouvoir s'utiliser avec d'autres version de make, et même d'autres programmes (comme scons).
En l'occurence, tu dois le régler pour générer un makefile au format attendu par code::blocks.

Pour la question 2)
je ne sais plus, ca fait longtemps que je n'ai pas utilisé cmake

**prgasp77** · 21/07/2015, 14h41

Envoyé par dfshr8

2) Comment concrètement ouvrir mon fichier avec Codeblocks ? Ou est ce que je tape: cmake -G "CodeBlocks - Unix Makefiles ? Est ce que qqun peut m' expliquer où je tape cette commande? Dans un terminal? Dans quel dossier? En partant du principe que je ne connais rien à l' info.

Depuis un terminal, tu tapes la commande cmake /path/to/CMakeLists.txt -G "CodeBlocks - Unix Makefiles" ; sera alors généré un projet Code::Blocks dans le dossier courant. Ouvrir le fichier généré avec C::B te présentera un projet, il te sera possible de modifier les sources, compiler, tester et déboguer le programme.

**dfshr8** · 21/07/2015, 14h50

Bon là aussi pour comprendre le fonctionnement du programme (en attendant vos copnseil pour faire fonctionner sous CodeBlocks et utiliser le debugger, Il est probable que nos messages se croisent le temps d'écrire ce message...):

Voici le programme en question:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
// ===================================================================================
// ===================================================================================
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Berenger Bramas, Matthias Messner
// olivier.coulaud@inria.fr, berenger.bramas@inria.fr
// This software is a computer program whose purpose is to compute the FMM.
//
// This software is governed by the CeCILL-C and LGPL licenses and
// abiding by the rules of distribution of free software.  
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public and CeCILL-C Licenses for more details.
// "http://www.cecill.info". 
// "http://www.gnu.org/licenses".
// ===================================================================================
 
#include <iostream>
#include <iomanip>
 
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
 
#include  "ScalFmmConfig.h"
#include "Utils/FTic.hpp"
#include "Utils/FParameters.hpp"
 
#include "Files/FFmaGenericLoader.hpp"
#include "Kernels/P2P/FP2P.hpp"
#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
 
#include "Utils/FParameterNames.hpp"
//
/// \file  DirectComputation.cpp
//!
//! \brief DirectComputation: Driver to compute direct interaction between N particles for 1/r kernel.
//!
//! DirectComputation: Driver to compute direct interaction between N particles for 1/r kernel.
//! the particles are read from file given by -fin argument and potential, forces are stored in FMA format.
//!  <b> General arguments:</b>
//!     \param   -help (-h)      to see the parameters available in this driver
//!     \param   -fin name:  file name  to convert (with extension .fma (ascii) or bfma (binary).
//!                             Only our FMA (.bma, .bfma) is allowed "
//!     \param    -fout filenameOUT   output file  with extension (default output.bfma)
//!      \param   -verbose : print index x y z Q V fx fy fz
//!
 
// Simply create particles and try the kernels
int main(int argc, char ** argv){
    FHelpDescribeAndExit(argc, argv,
                         ">> This executable has to be used to compute  interaction either for periodic or non periodic system.\n"
                         ">> Example -fin filenameIN.{fma or bfma)     -fout filenameOUT{fma or bfma) \n"
                         ">> Default input file : Data/unitCubeXYZQ20k.fma\n"
                         ">> Only our FMA (.bma, .bfma) is allowed as input.\n"
                         ">> Output file  with extension (default output.bfma).",
                         FParameterDefinitions::InputFile, FParameterDefinitions::OutputFile,
                         FParameterDefinitions::EnabledVerbose);
 
    //////////////////////////////////////////////////////////////
    typedef double FReal;
    const std::string defaultFile(/*SCALFMMDataPath+*/"../Data/unitCubeXYZQ20k.fma");
    const std::string filenameIn(FParameters::getStr(argc,argv,FParameterDefinitions::InputFile.options,  defaultFile.c_str()));
    const std::string filenameOut(FParameters::getStr(argc,argv,FParameterDefinitions::OutputFile.options, "output.bfma"));
    //
    FTic counter;
 
    // -----------------------------------------------------
    //  LOADER
    //  -----------------------------------------------------
    // ---------------------------------------------------------------------------------
    // Read  particles in the Octree
    // ---------------------------------------------------------------------------------
    std::cout << "Opening : " << filenameIn << "\n";
    //
    FFmaGenericLoader<FReal> loader(filenameIn);
    //
    FSize nbParticles = static_cast<int>(loader.getNumberOfParticles());
    std::cout << "Read " << nbParticles << " particles ..." << std::endl;
    double BoxWith=loader.getBoxWidth();
    FPoint<FReal> Centre(loader.getCenterOfBox().getX(), loader.getCenterOfBox().getY() , loader.getCenterOfBox().getZ());
    std::cout << "\tWidth : " <<BoxWith << " \t center x : " << loader.getCenterOfBox().getX()
              << " y : " << loader.getCenterOfBox().getY() << " z : " << loader.getCenterOfBox().getZ() << std::endl;
 
    counter.tic();
    //
    FmaRWParticle<FReal, 4,8> *  particles = new FmaRWParticle<FReal, 4,8>[nbParticles];
    memset(particles, 0, sizeof(FmaRWParticle<FReal, 4,8>) * nbParticles) ;
    //
    double totalCharge = 0.0;
    //
    //	int nbDataToRead = particles[0].getReadDataNumber();
    for(int idx = 0 ; idx<nbParticles ; ++idx){
        //
        loader.fillParticle(particles[idx].getPtrFirstData(), particles[idx].getReadDataNumber());
        //	loader.fillParticle(particles[idx].getPtrFirstData(), nbDataToRead);    // OK
        //  loader.fillParticle(particles[idx]); // OK
        //    std::cout << idx <<"  "<<  particles[idx].getPosition() << " "<<particles[idx].getPhysicalValue() << " "<<particles[idx].getPotential()
        //			<<"  " << particles[idx].getForces()[0]<<"  " <<particles[idx].getForces()[1]<<"  " <<particles[idx].getForces()[2]<<"  " <<std::endl;
        //
        totalCharge += particles[idx].getPhysicalValue() ;
    }
 
    counter.tac();
 
    std::cout << std::endl;
    std::cout << "Total Charge         = "<< totalCharge <<std::endl;
    std::cout << std::endl;
 
    std::cout << "Done  " << "(@ reading Particles  " << counter.elapsed() << " s)." << std::endl;
    //
    // ----------------------------------------------------------------------------------------------------------
    //                                   COMPUTATION
    // ----------------------------------------------------------------------------------------------------------
    // interaction kernel evaluator
    typedef FInterpMatrixKernelR<FReal> MatrixKernelClass;
    const MatrixKernelClass MatrixKernel;
    FReal denergy = 0.0;
    //
    //  computation
    //
    {
        printf("Compute :\n");
        counter.tic();
#pragma omp parallel shared(nbParticles, particles,denergy)
        {
#pragma omp for
            for(int idxTarget = 0 ; idxTarget < nbParticles ; ++idxTarget){
                //
                // compute with all other except itself
                //
                // Compute force and potential between  particles[idxTarget] and particles inside the box
                //
                for(int idxOther = 0; idxOther < nbParticles ; ++idxOther){
                    if( idxOther != idxTarget ){
                        FP2P::NonMutualParticles(
                                    particles[idxOther].getPosition().getX(), particles[idxOther].getPosition().getY(),
                                    particles[idxOther].getPosition().getZ(),particles[idxOther].getPhysicalValue(),
                                    particles[idxTarget].getPosition().getX(), particles[idxTarget].getPosition().getY(),
                                    particles[idxTarget].getPosition().getZ(),particles[idxTarget].getPhysicalValue(),
                                    &particles[idxTarget].setForces()[0],&particles[idxTarget].setForces()[1],
                                &particles[idxTarget].setForces()[2],particles[idxTarget].setPotential(),&MatrixKernel);
                    }
                }
            } // end for
            // Compute the energy
#pragma omp  for reduction(+:denergy)
            for(int idx = 0 ; idx < nbParticles ; ++idx){
                denergy +=  particles[idx].getPotential()*(particles[idx].getPhysicalValue()) ;
            }
        } // end pragma parallel
        //
        denergy *= 0.5 ;
        counter.tac();
        //
        printf("Energy =   %.14e\n",denergy);
        //
        std::cout << "Done  " << "(@ Direct computation done = " << counter.elapsed() << " s)." << std::endl;
        std::cout << "\n"<< "END  "
                  << "-------------------------------------------------------------------------"
                  << std::endl << std::endl ;
    } // END
 
    //
    // ----------------------------------------------------------------
    //  Save  computation in binary format
    //
    //
 
    std::cout << "Generate " << filenameOut <<"  for output file" << std::endl;
    //
    std::cout << " nbParticles: " << nbParticles <<"  " << sizeof(nbParticles) <<std::endl;
    std::cout << " denergy: " << denergy <<"  " << sizeof(denergy) <<std::endl;
    std::cout << " Box size: " << loader.getBoxWidth() << "  " << sizeof(loader.getBoxWidth())<<std::endl;
    //
    FFmaGenericWriter<FReal> writer(filenameOut) ;
    writer.writeHeader(Centre,BoxWith, nbParticles,*particles) ;
    writer.writeArrayOfParticles(particles, nbParticles);
    //
    // end generate
    // -----------------------------------------------------
    //
    if(FParameters::existParameter(argc, argv, FParameterDefinitions::EnabledVerbose.options)){
        denergy = 0 ;
        for(int idx = 0 ; idx < nbParticles ; ++idx){
            std::cout << ">> index " << idx << std::endl;
            std::cout << " x   " << particles[idx].getPosition().getX() << " y  " << particles[idx].getPosition().getY() << " z  " << particles[idx].getPosition().getZ() << std::endl;
            std::cout << " Q   " << particles[idx].getPhysicalValue()   << " V  " << particles[idx].getPotential() << std::endl;
            std::cout << " fx  " << particles[idx].getForces()[0]       << " fy " << particles[idx].getForces()[1]       << " fz " << particles[idx].getForces()[2] << std::endl;
            std::cout << "\n";
            denergy +=  particles[idx].getPotential()*particles[idx].getPhysicalValue() ;
        }
    }
    std::cout << " ENERGY " << denergy << std::endl;
    //
    delete[] particles;
    return 0;
}

Alors voici ce que je pige (ainsi que ce que je ne comprends pas..): je vais essayer de comprendre le code linéairement (je fais comme le compilateur instruction par instruction), en essayant de comprendre ce que font chaque variables et fonctions (j'imagine que c'est la seule manière de procéder).

3)Ligne 50 à 61 définition du main:

a) Prototype du main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
// Simply create particles and try the kernels
int main(int argc, char ** argv){

il y a des arguments ce que je n'avais jamais vu: "int argc, char ** argv". J'ai cru comprendre que ce sont des arguments que l'on passe au compilateur/ ou à "l'executeur". Lorsque je fait mon ./ ; j'imagine qu'on passe les paramètres comme suit: ./DirectComputation -3 -**char (je met n'importe quoi car il demande : un entier, j'ai mis 3, et un pointeur sur un pointeur de char (ça je ne conprends pas).

b) Paramètres du compilateur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
   FHelpDescribeAndExit(argc, argv,
                         ">> This executable has to be used to compute  interaction either for periodic or non periodic system.\n"
                         ">> Example -fin filenameIN.{fma or bfma)     -fout filenameOUT{fma or bfma) \n"
                         ">> Default input file : Data/unitCubeXYZQ20k.fma\n"
                         ">> Only our FMA (.bma, .bfma) is allowed as input.\n"
                         ">> Output file  with extension (default output.bfma).",
                         FParameterDefinitions::InputFile, FParameterDefinitions::OutputFile,
                         FParameterDefinitions::EnabledVerbose);
 
    //////////////////////////////////////////////////////////////

Il y a je crois:
* FHelpDescribeAndExit : une fonction qui prend en argument:
- un entier: argc
- un pointeur sur un pointeur de char: **char
une chaine de caractère explicite (ce qui est entre les "")
- une variable InputFile: de type FParameterDefinitions (je n'ai aucune idée de ce que représente ce type, j'imagine que je le retrouverai dans les autres entêtes)
où retrouver ou est définis ce type je n'en ai aucune idée??? J'imagine qu'il va falloir que je me serve de la commande "grep"
- une variable: outputFile, de type FParameterDefinitions
- une variable : EnabledVerbose de type FParameterDefinitions

**dfshr8** · 21/07/2015, 14h56

Envoyé par prgasp77

Depuis un terminal, tu tapes la commande cmake /path/to/CMakeLists.txt -G "CodeBlocks - Unix Makefiles" ; sera alors généré un projet Code::Blocks dans le dossier courant. Ouvrir le fichier généré avec C::B te présentera un projet, il te sera possible de modifier les sources, compiler, tester et déboguer le programme.

Je fait la commande depuis mon hoùme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
e@sky:~$ cmake Desktop/SCALFMM-1.3-56/CMakeLists.txt -G "CodeBlocks - Unix Makefiles> 
>

Et comme on peut le voir ça m'affiche un prompte:
du coup je sors avec Ctrl+C:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
> 
> ^C
dfshr8@sky:~$ ls
Desktop    Downloads  Library  Movies  Musique	 Public  Téléchargements
Documents  Images     Modèles  Music   Pictures  Sites	 Vidéos
dfshr8@sky:~$

et je constate que ça ne me crée aucun makefile.

**ternel** · 21/07/2015, 15h08

Le prompt que tu as vu n'est pas dû à CMake, mais au shell lui-même, qui attendait la fin d'une chaine de caractère.
C'est parce que le dernier caractère n'est pas > mais "

Par ailleurs, Ctrl+C interrompt l'action en cours, ici, la saisie d'une commande. C'est donc normal de ne pas avoir de makefile, vu que cmake n'a même pas tourné.

Une commande dans le terminal, c'est toujours: un nom de programme, et ses arguments et options.
Dans ton cas, le programme c'est "cmake", le premier argument est le chemin vers le fichier de paramétrage de cmake, et tu rajoute un option, -G, avec sa valeur, la chaine "CodeBlocks - Unix Makefiles".
cmake comprenant -G comme étant une option attendant une valeur (de type texte), qui désignera le format de sortie.

Pour le code, il faudrait le lire plus avant.
les arguments de main sont deux variables (un nombre d'arguments, et les valeurs des dits arguments), qui permettent justement de lire les options.
vu son nom, FHelpDescribeAndExit est une fonction qui affiche l'aide et quitte l'application si les options ne sont pas valide.
C'est du code, donc certainement pas les parametres du compilateurs.

Je pense qu'il faut que tu t'entraines un peu plus avant de te lancer dans ce code.
Essaie d'écrire un programme jouet, tel qu'un jeu de "plus ou moins".

**dfshr8** · 21/07/2015, 15h30

Envoyé par leternel

Le prompt que tu as vu n'est pas dû à CMake, mais au shell lui-même, qui attendait la fin d'une chaine de caractère.
C'est parce que le dernier caractère n'est pas > mais "

Par ailleurs, Ctrl+C interrompt l'action en cours, ici, la saisie d'une commande. C'est donc normal de ne pas avoir de makefile, vu que cmake n'a même pas tourné.

Une commande dans le terminal, c'est toujours: un nom de programme, et ses arguments et options.
Dans ton cas, le programme c'est "cmake", le premier argument est le chemin vers le fichier de paramétrage de cmake, et tu rajoute un option, -G, avec sa valeur, la chaine "CodeBlocks - Unix Makefiles".
cmake comprenant -G comme étant une option attendant une valeur (de type texte), qui désignera le format de sortie.
.

Merci, maintenant l' erreur vient d'utre chose:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 ls
OutilsCpp  SCALFMM-1.3-56  TestCB
dfshr8@sky:~/Desktop$ cmake SCALFMM-1.3-56/CMakeLists.txt -G "CodeBlocks - Unix Makefiles"
-- The C compiler identification is GNU 4.8.4
-- The CXX compiler identification is GNU 4.8.4
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
CMake Error at CMakeLists.txt:19 (message):
  SCALFMM requires an out of source build.  Goto ./Build and tapes cmake ../
 
 
-- Configuring incomplete, errors occurred!
See also "/Network/Servers/ldap.ann.jussieu.fr/Volumes/DATA/users/thesards/dfshr8/Desktop/SCALFMM-1.3-56/CMakeFiles/CMakeOutput.log".
dfshr8@sky:~/Desktop$ ls
OutilsCpp  SCALFMM-1.3-56  TestCB

Peut être que je dois me mettre dans le Build obligatoirement? Mais en le faisant ça ne fonctionne pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
cmake_minimum_required (VERSION 2.8.3 FATAL_ERROR)
 
if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 7 AND CMAKE_PATCH_VERSION GREATER 11)
  cmake_policy(SET CMP0022 OLD)
endif()
 
cmake_policy(SET CMP0004 OLD)
 
set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
 
#===========================================================================
# Project Declaration
#===========================================================================
project(SCALFMM C CXX)
 
# check if compiling into source directories
string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" insource)
if(insource)
  message(FATAL_ERROR "${PROJECT_NAME} requires an out of source build. Goto ./Build and tapes cmake ../")
endif(insource)
 
set(SCALFMM_CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules)
 
 
#===========================================================================
# Version Number
#===========================================================================
 
# SCALFMM version number.  An even minor number corresponds to releases.
set(SCALFMM_MAJOR_VERSION 1)
set(SCALFMM_MINOR_VERSION 3)
set(SCALFMM_PATCH_VERSION 0)
set(SCALFMM_VERSION  "${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}.${SCALFMM_PATCH_VERSION}" )
 
set( MORSE_DISTRIB_DIR "" CACHE PATH "Directory of MORSE distribution")
 
if (MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_SOURCE_DIR}/CMakeModules/morse/")
 
  # Add extra cmake module path and initialize morse cmake modules
  # --------------------------------------------------------------
  if(MORSE_DISTRIB_DIR)
      list(APPEND CMAKE_MODULE_PATH ${MORSE_DISTRIB_DIR}/cmake_modules)
      list(APPEND CMAKE_MODULE_PATH "${MORSE_DISTRIB_DIR}/cmake_modules/morse")
      set(MORSE_CMAKE_MODULE_PATH ${MORSE_DISTRIB_DIR}/cmake_modules/morse )
  elseif(EXISTS "${CMAKE_SOURCE_DIR}/CMakeModules/morse/")
      list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules/morse/)
      set(MORSE_CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules/morse )
  endif()
  include(MorseInit)
 
  #
  # Options
  option( SCALFMM_USE_MPI              "Set to ON to build ScaFMM with MPI"          OFF )
  option( SCALFMM_USE_BLAS             "Set to ON to build ScaFMM with BLAS"         ON )
  option( SCALFMM_USE_FFT              "Set to ON to build ScaFMM with FFTW"         ON )
  option( SCALFMM_BUILD_EXAMPLES       "Set to ON to compile examples "              ON  )
  option( SCALFMM_BUILD_TESTS          "Set to ON to build functionalities Tests"    OFF )
  option( SCALFMM_BUILD_UTESTS         "Set to ON to build UTests"                   OFF )
  option( SCALFMM_INSTALL_DATA         "Set to ON to include the data when proceeding to the installtion " OFF )
  option( SCALFMM_BUILD_DOC            "Set to ON to build the Doxygen documentation " OFF )
  option( SCALFMM_BUILD_DEBUG          "Set to ON to build in Debug"                 OFF )
  option( SCALFMM_USE_LOG              "Set to ON to print output debug information" OFF )
  option( SCALFMM_USE_MEM_STATS        "Set to ON to profile memory"                 OFF )
  option( SCALFMM_ATTACHE_SOURCE       "Set to ON to compile with -g"                OFF )
  option( SCALFMM_USE_ADDONS           "Set to ON to compile add ons"                OFF )
  option( SCALFMM_USE_SSE              "Set to ON to compile with SSE support (and use intrinsec SSE P2P)"  ON  )
  option( SCALFMM_USE_AVX              "Set to ON to compile with AVX support (and use intrinsec AVX P2P)" OFF  )
  option( SCALFMM_USE_AVX2             "Set to ON to compile with AVX support (and use intrinsec AVXZ P2P)" OFF )
  option( SCALFMM_USE_ASSERT           "Set to ON to enable safe tests during execution" ON  )
  option( SCALFMM_USE_MIC_NATIVE       "Set to ON to compile in native mode for MIC" OFF  )
  option( SCALFMM_ONLY_DEVEL           "Set to ON to compile Development tools (only scalfmm team)" OFF )
  if( SCALFMM_ONLY_DEVEL )
    option( SCALFMM_USE_STARPU "Set to ON to build SCALFMM with StarPU" OFF )
  endif()
  if( SCALFMM_USE_MPI )
    try_compile(COMPILE_INTEL ${CMAKE_CURRENT_BINARY_DIR}
                ${SCALFMM_CMAKE_MODULE_PATH}/compileTestIntel.cpp
                COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS}")
    if (COMPILE_INTEL)
      set(CMAKE_CXX_COMPILER_ID  "Intel")
    endif()
  endif()
  message(STATUS "CXX  ${CMAKE_CXX_COMPILER_ID}" )
  # Set scalfmm to default libraries
  set(SCALFMM_LIBRARIES "")
  set(SCALFMM_CXX_FLAGS "-std=c++11 -fpic -Wall")
  #
  #
  # Test if openmp is here
  #
  find_package (OpenMP)
  if(OPENMP_FOUND)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
  else(OPENMP_FOUND)
    message(WARNING "OPENMP NOT FOUND")
  endif(OPENMP_FOUND)
  message(STATUS "SCALFMM_BUILD_DEBUG = ${SCALFMM_BUILD_DEBUG}" )
  #
  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
    set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -m64")
  endif()
  ##############################################################################
  #                           Compile options                                  #
  ##############################################################################
  #  -xHost -mfpmath=sse
  # -Wall Wnosign-conversion
  #
  if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
    # INTEL
    IF (APPLE)
      set(SSE_FLAGS  "-msse4  -mfpmath=sse")   # -mtune=native -march=native
    else(APPLE)
      set(AVX_FLAGS  "-mavx")
      set(AVX2_FLAGS  "-mavx2")
      set(SSE_FLAGS  "-axSSE4.2")
    endif(APPLE)
    #-Wshadow -Wpointer-arith -Wcast-qual -Wconversion  -Wall -Wnosign-conversion ")
  else()
    # NOT      INTEL
    if(NOT SCALFMM_USE_MPI)
      include(CheckCCompilerFlag)
      check_c_compiler_flag(-Wzero-as-null-pointer-constant HAS_WZERO_NULL_PTR_FLAG)
      if(HAS_WZERO_NULL_PTR_FLAG)
        set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -Wzero-as-null-pointer-constant")
      endif()
    else()
      include(CheckCCompilerFlag)
      check_c_compiler_flag(-Wno-literal-suffix HAS_NO_LITERAL_SUFFIX_FLAG)
      if(HAS_NO_LITERAL_SUFFIX_FLAG)
        set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -Wno-literal-suffix")
      endif()
    endif()
    set(AVX_FLAGS "-mtune=native -march=native")
    set(AVX2_FLAGS "-mtune=native -march=native -mmic")
    IF (APPLE)
      set(SSE_FLAGS  "-msse3  -mfpmath=sse")   # -mtune=native -march=native
    else(APPLE)
      set(SSE_FLAGS  "-mtune=native -march=native")   # -mtune=native -march=native
    endif(APPLE)
  endif()
 
  ##############################################################################
  #                           FUSE list                                        #
  ##############################################################################
  set(FUSE_LIST "")
  # then do list(APPEND FUSE_LIST "BLAS") to protect from FUSE_BLAS
  list(APPEND FUSE_LIST "MPI")
 
  ##############################################################################
  #                        Debug      flags                                    #
  ##############################################################################
  #
  if( SCALFMM_BUILD_DEBUG )
    #
    # Compile Debug flags
    #
    set(CMAKE_BUILD_TYPE Debug)
    ADD_DEFINITIONS(-O0)
    if( APPLE )
      set(SCALFMM_FLAGS_OPTI_DEBUG "-funroll-loops" CACHE STRING
        "Set your optimization flags for debug mode.")
    else(APPLE)
      if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        set(SCALFMM_FLAGS_OPTI_DEBUG "-fp-model strict  -funroll-loops" CACHE STRING
          "Set your optimization flags for debug mode.")
      else()
        set(SCALFMM_FLAGS_OPTI_DEBUG "-funroll-loops" CACHE STRING
          "Set your optimization flags for debug mode.")
      endif()
    endif(APPLE)
    #  ADD_DEFINITIONS(${SCALFMM_FLAGS_OPTI_DEBUG})
    set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${SCALFMM_FLAGS_OPTI_DEBUG}")
    set(CMAKE_CXX_FLAGS_TYPE "${CMAKE_CXX_FLAGS_DEBUG}")
 
  else()
    ##############################################################################
    #                          Release flags                                     #
    ##############################################################################
    set(CMAKE_BUILD_TYPE Release)
    # force -O3 in release
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
    string(REPLACE "-O2" "-O3" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE} )
    set(CMAKE_CXX_FLAGS_TYPE  "${CMAKE_CXX_FLAGS_RELEASE}")
    # if compiler is intel add -ip
    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
      set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -ip")
      # set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -ip -no-prec-div -no-prec-sqrt")
    endif()
    # Compile optimization
    if(APPLE)
      set(SCALFMM_FLAGS_OPTI_RELEASE "-funroll-loops" CACHE STRING
        "Set your optimization flags for release mode.")
    else(APPLE)
      # Not apple system - Check the compiler flags
      if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        # set(SCALFMM_FLAGS_OPTI_RELEASE "-fp-model precise -fp-model source -fimf-precision=low  -funroll-loops -ftree-vectorize"
        #   CACHE STRING "Set your optimization flags for release mode.")
        set(SCALFMM_FLAGS_OPTI_RELEASE " " CACHE STRING
          "Set your optimization flags for release mode.")
      else()
        set(SCALFMM_FLAGS_OPTI_RELEASE "-ffast-math -funroll-loops -ftree-vectorize" CACHE STRING
          "Set your optimization flags for release mode.")
      endif()
    endif(APPLE)
    #
    set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} ${SCALFMM_FLAGS_OPTI_RELEASE}")
  endif()
  #
  ##############################################################################
  #                Attach source code to exec                                  #
  ##############################################################################
  message(STATUS "SCALFMM_ATTACHE_SOURCE       = ${SCALFMM_ATTACHE_SOURCE}" )
  if( SCALFMM_ATTACHE_SOURCE )
    message(STATUS "Option -g is used, the code is attached to the binary." )
    set(SCALFMM_CXX_FLAGS  "${SCALFMM_CXX_FLAGS} -g")
  endif(SCALFMM_ATTACHE_SOURCE)
  #
  ##############################################################################
  #                                 find MPI                                   #
  ##############################################################################
  #
  if( SCALFMM_USE_MPI )
 
    # allows to use an external mpi compilation by setting compilers with
    # -DMPI_C_COMPILER=path/to/mpicc -DMPI_CXX_COMPILER=path/to/mpicxx
    # at cmake configure
    if(NOT MPI_C_COMPILER)
        set(MPI_C_COMPILER mpicc)
    endif()
    if(NOT MPI_CXX_COMPILER)
        set(MPI_CXX_COMPILER mpicxx)
    endif()
 
    find_package(MPI REQUIRED)
 
    if (MPI_CXX_INCLUDE_PATH)
        include_directories( ${MPI_CXX_INCLUDE_PATH} )
    endif()
    if (MPI_CXX_COMPILE_FLAGS)
        set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${MPI_CXX_COMPILE_FLAGS}")
    endif()
    if (MPI_CXX_INCLUDE_PATH)
        set(SCALFMM_INCLUDES  "${SCALFMM_INCLUDES}; ${MPI_CXX_INCLUDE_PATH}")
    endif()
    if (MPI_CXX_LINK_FLAGS)
        set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${MPI_CXX_LINK_FLAGS}")
    endif()
    if (MPI_CXX_LIBRARIES)
        set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${MPI_CXX_LIBRARIES}")
    endif()
 
  endif()
  #
  ##############################################################################
  #                             Blas option                                    #
  ##############################################################################
  #
  if( SCALFMM_USE_BLAS )
    message(STATUS "CMAKE_CXX_COMPILER_ID STREQUAL  ${CMAKE_CXX_COMPILER_ID}")
 
    option( SCALFMM_USE_MKL_AS_BLAS "Set to ON to use MKL CBLAS" OFF )
 
    if( SCALFMM_USE_MKL_AS_BLAS )
      set(BLA_VENDOR "Intel10_64lp_seq")
      find_package(BLASEXT) # not REQUIRED
 
      if(BLAS_LIBRARY_DIRS)
        # the RPATH to be used when installing
        list(APPEND CMAKE_INSTALL_RPATH "${BLAS_LIBRARY_DIRS}")
      endif()
      unset(LAPACK_LIBRARIES)
      if (BLAS_LIBRARIES)
        set(BLASLAPACK_LIBRARIES ${BLAS_LIBRARIES})
      endif()
    elseif(SCALFMM_USE_EXTERNAL_BLAS)
      message(STATUS "BLAS SET BY EXTERNAL PROGRAM = ${BLAS_LIBRARIES}")
    else()
      find_package(BLASEXT)  # not REQUIRED
      find_package(LAPACKEXT)  # not REQUIRED
      set(BLASLAPACK_LIBRARIES)
      if (LAPACK_LIBRARIES)
        set(BLASLAPACK_LIBRARIES "${LAPACK_LIBRARIES}")
      endif()
      if (BLAS_LIBRARIES)
        list(APPEND BLASLAPACK_LIBRARIES "${BLAS_LIBRARIES}")
      endif()
    endif()
 
    if(BLAS_FOUND)
        set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${BLASLAPACK_LIBRARIES}")
        #message(STATUS "SCALFMM_LIBRARIES          = ${SCALFMM_LIBRARIES}")
    else()
        message(WARNING "BLAS has not been found, SCALFMM will continue to compile but some applications will be disabled.")
        message(WARNING "If you have BLAS set BLAS_LIBDIR, BLAS_INCDIR or BLAS_DIR (CMake variables using -D or environment variables).")        
        set(SCALFMM_USE_FFT OFF)
    endif()
 
  endif(SCALFMM_USE_BLAS)
  list(APPEND FUSE_LIST "BLAS")
  #
  # FFT option
  #
  if( SCALFMM_USE_FFT )
 
    option( SCALFMM_USE_MKL_AS_FFTW "Set to ON to use MKL FFTW" OFF )
 
    message(STATUS "SCALFMM USE FFT Configure:")
 
    if( SCALFMM_USE_MKL_AS_FFTW )
 
      message(STATUS "         SCALFMM USE MKL ")
 
      if( SCALFMM_USE_MKL_AS_BLAS )
 
        unset(FFT_LIBRARIES CACHE)
        message(STATUS "         SCALFMM USE MKL already defined")
        set(FFT_INCLUDES "$ENV{MKLROOT}/include/fftw" CACHE STRING "Set your MKL flags")
        if (BLAS_FOUND)
            set(FFTW_FOUND ON)
        endif()
 
      else(SCALFMM_USE_MKL_AS_BLAS)
 
        # The package can be used with the following COMPONENTS:
        # MKL, THREADS|OMP and/or SIMPLE|DOUBLE|LONG|QUAD
        # Default is DOUBLE and without THREADS|OMP
        find_package(FFTW  COMPONENTS MKL) # not REQUIRED
        if (FFTW_LIBRARY_DIRS_DEP)
            set(FFT_LIBRARIES "-L${FFTW_LIBRARY_DIRS_DEP};" CACHE STRING "Set your MKL flags")
        endif()
        if (FFTW_LIBRARIES_DEP)
            foreach (fft_lib ${FFTW_LIBRARIES_DEP})
              set(FFT_LIBRARIES "${FFT_LIBRARIES} ${fft_lib};")
            endforeach()
        endif()
        set(FFT_INCLUDES "${FFTW_INCLUDE_DIRS_DEP}" )
        if (FFT_LIBRARIES)
            set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${FFT_LIBRARIES}")
        endif()
 
      endif(SCALFMM_USE_MKL_AS_BLAS)
 
    else(SCALFMM_USE_MKL_AS_FFTW)
 
      message(STATUS "         SCALFMM USE FFTW ")
      # The package can be used with the following COMPONENTS:
      # MKL, THREADS|OMP and/or SIMPLE|DOUBLE|LONG|QUAD
      # Default is DOUBLE and without THREADS|OMP
      find_package(FFTW) # not REQUIRED
      if (FFTW_LIBRARY_DIRS_DEP)
        set(FFT_LIBRARIES "-L${FFTW_LIBRARY_DIRS_DEP};" CACHE STRING "Set your MKL flags")
      endif()
      if (FFTW_LIBRARIES_DEP)
        foreach (fft_lib ${FFTW_LIBRARIES_DEP})
          set(FFT_LIBRARIES "${FFT_LIBRARIES} ${fft_lib};")
        endforeach()
      endif()
      set(FFT_INCLUDES "${FFTW_INCLUDE_DIRS_DEP}" )
      if (FFT_LIBRARIES)
        set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${FFT_LIBRARIES}")
      endif()
 
    endif(SCALFMM_USE_MKL_AS_FFTW)
 
    if (FFT_INCLUDES)
        set(SCALFMM_INCLUDES "${SCALFMM_INCLUDES}; ${FFT_INCLUDES}")
    endif()
 
    if(FFTW_FOUND)
        message(STATUS "         SCALFMM_LIBRARIES          = ${SCALFMM_LIBRARIES}")
        message(STATUS "         SCALFMM_INCLUDES          = ${SCALFMM_INCLUDES}")
    else()
        message(WARNING "FFTW has not been found, SCALFMM will continue to compile but some applications will be disabled.")
        message(WARNING "If you have FFTW set FFTW_LIBDIR, FFTW_INCDIR or FFTW_DIR (CMake variables using -D or environment variables).")        
        set(SCALFMM_USE_FFT OFF)
    endif()
  endif(SCALFMM_USE_FFT)
  list(APPEND FUSE_LIST "FFT")
         message(STATUS "         SCALFMM_LIBRARIES          = ${SCALFMM_LIBRARIES}")
        message(STATUS "         SCALFMM_INCLUDES          = ${SCALFMM_INCLUDES}")
 
  message(STATUS "SCALFMM_USE_FFT       =  ${SCALFMM_USE_FFT}")
 
  #
  # C++ 2011
  message( STATUS "CMAKE_SYSTEM:   ${CMAKE_SYSTEM}  CMAKE_CXX_COMPILER_ID ${CMAKE_CXX_COMPILER_ID}  CMAKE_CXX_COMPILER ${NAME}")
  if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE INTEL_VERSION)
    message( STATUS "Intel:   ${INTEL_VERSION}")
    set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -Wall")
  else()
    # Compile option valid on GCC/G++
    set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} -Wall -Wshadow -Wpointer-arith -Wcast-qual -Wconversion -Wcast-qual -Wcast-align -Woverloaded-virtual")
  endif()
  #
  ##################################################################
  #              STARPU Section
  ##################################################################
  #
  message( STATUS "SCALFMM_USE_STARPU             = ${SCALFMM_USE_STARPU}" )
  if( SCALFMM_USE_STARPU )
    # No fast math with starpu
    if(SCALFMM_CXX_FLAGS)
        string(REPLACE "-ffast-math" " " SCALFMM_CXX_FLAGS ${SCALFMM_CXX_FLAGS})
    endif()
    if(SCALFMM_FLAGS_OPTI_RELEASE)
        string(REPLACE "-ffast-math" " " SCALFMM_FLAGS_OPTI_RELEASE ${SCALFMM_FLAGS_OPTI_RELEASE})     
    endif()
 
    # CUDA could be used with StarPU enabled
    option( SCALFMM_USE_CUDA "Set to ON to use CUDA with StarPU" OFF )
    message( STATUS "SCALFMM_USE_CUDA             = ${SCALFMM_USE_CUDA}" )
    if(SCALFMM_USE_CUDA)
        execute_process(COMMAND nvcc --version ERROR_VARIABLE cuda_error_output OUTPUT_QUIET)
        if(cuda_error_output)
            message( FATAL_ERROR "nvcc is needed with CUDA." )
        endif()
        if(NOT DEFINED CUSTOM_CUDA_FLAGS)
            set( CUSTOM_CUDA_FLAGS "-std=c++11;-arch=sm_20" CACHE
            STRING "Set your CUDA flags, for example : -arch=sm_20;-ptxas-options=-v;-use_fast_math")
        endif()
        # This is needed to remove backslash after space in ADD_CUSTOM_COMMAND
        separate_arguments(CUSTOM_CUDA_FLAGS)
        message( STATUS "CUSTOM_CUDA_FLAGS             = ${CUSTOM_CUDA_FLAGS}" )
 
        find_package(CUDA REQUIRED)
 
        if (CUDA_INCLUDE_DIRS)
            include_directories(${CUDA_INCLUDE_DIRS})
        endif()
        if (CUDA_LIBRARIES)
            set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${CUDA_LIBRARIES}")
        endif()
 
        set(CUDA_NEEDED_INCLUDE_DIRS ${CMAKE_BINARY_DIR}/Src)
    endif()
 
    # Find StarPU with a list of optional components
    set(SCALFMM_STARPU_VERSION "1.1" CACHE STRING "oldest STARPU version desired")
    # create list of components in order to make a single call to find_package(starpu...)
    set(STARPU_COMPONENT_LIST "HWLOC")
    if(SCALFMM_USE_MPI)
        list(APPEND STARPU_COMPONENT_LIST "MPI")
    endif()
    if(SCALFMM_USE_CUDA)
        list(APPEND STARPU_COMPONENT_LIST "CUDA")
    endif()
 
    find_package(STARPU ${SCALFMM_STARPU_VERSION} REQUIRED
                 COMPONENTS ${STARPU_COMPONENT_LIST})
 
    # Append list of libraries and include dirs
    include_directories(${STARPU_INCLUDE_DIRS_DEP})
    foreach (starpu_libdir ${STARPU_LIBRARY_DIRS_DEP})
      if (${starpu_libdir} MATCHES "^ *-L")
          set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${starpu_libdir}")
      else()
          set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; -L${starpu_libdir}")
      endif()
    endforeach()
    foreach (starpu_lib ${STARPU_LIBRARIES_DEP})
      if (EXISTS ${starpu_lib} OR ${starpu_lib} MATCHES "^ *-")
          set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${starpu_lib}")
      else()
          set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; -l${starpu_lib}")
      endif()
    endforeach()
 
    # TODO: is this very useful? CUDA is already a component of find starpu
    if (CUDA_LIBRARIES)
        set(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; ${CUDA_LIBRARIES}")
    endif()
 
    # Message
    message(STATUS "         STARPU_LIBRARIES          = ${STARPU_LIBRARIES}")
    if (STARPU_INCLUDE_DIRS)
        message(STATUS "         STARPU_INCLUDES           = ${STARPU_INCLUDE_DIRS}")
    endif()
 
    # TODO: replace this by a component of find starpu
    OPTION( SCALFMM_USE_OPENCL      "Set to ON to use OPENCL with StarPU" OFF )
    MESSAGE( STATUS "SCALFMM_USE_OPENCL             = ${SCALFMM_USE_OPENCL}" )
    if(SCALFMM_USE_OPENCL)
        include_directories($ENV{OPENCL_INC})
        SET(SCALFMM_LIBRARIES "${SCALFMM_LIBRARIES}; -L$ENV{OPENCL_LIB}; -lOpenCL")
    endif()
  endif(SCALFMM_USE_STARPU)
  list(APPEND FUSE_LIST "STARPU")
  list(APPEND FUSE_LIST "CUDA")
  list(APPEND FUSE_LIST "OPENCL")
 
  ##################################################################
  #                         Use SSE                                #
  ##################################################################
 
  message( STATUS "SCALFMM_USE_SSE              = ${SCALFMM_USE_SSE}" )
  if( SCALFMM_USE_SSE )
    if(NOT EXISTS ${SCALFMM_CMAKE_MODULE_PATH}/compileTestSse.cpp)
      message(FATAL_ERROR "The CompileTestSseFile does not exist (${SCALFMM_CMAKE_MODULE_PATH}/compileTestSse.cpp)" )
    endif()
    message( STATUS "SSE_FLAGS ${SSE_FLAGS}  -- ${CMAKE_CXX_FLAGS}  ")
    try_compile(COMPILE_SSE  ${CMAKE_CURRENT_BINARY_DIR}
                ${SCALFMM_CMAKE_MODULE_PATH}/compileTestSse.cpp
                COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${SSE_FLAGS}"
                OUTPUT_VARIABLE COMPILE_SSE_OUTPUT)
 
    if(${COMPILE_SSE})
      set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${SSE_FLAGS}")
 
      try_compile(COMPILE_RESULT_VAR ${CMAKE_CURRENT_BINARY_DIR}
                  ${SCALFMM_CMAKE_MODULE_PATH}/checkSSEpe.cpp
                  COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${SSE_FLAGS}")
      if( NOT ${COMPILE_RESULT_VAR})
        set(__SSEPE_INTEL_COMPILER ON)
      endif()
      #set(SCALFMM_USE_AVX OFF)
    else(${COMPILE_SSE})
      message(FATAL_ERROR "SSE NOT SUPPORTED ; Set SCALFMM_USE_SSE  to OFF \n Output from test is : ${COMPILE_SSE_OUTPUT}")
    endif(${COMPILE_SSE})
  endif()
  list(APPEND FUSE_LIST "SSE")
 
  ##################################################################
  #                           Use AVX                              #
  ##################################################################
 
  message(STATUS "SCALFMM_USE_AVX               = ${SCALFMM_USE_AVX}")
  if(SCALFMM_USE_AVX)
    if(NOT EXISTS ${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx.cpp)
      message(FATAL_ERROR "The CompileTestSseFile does not exist (${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx.cpp)" )
    endif()
 
    try_compile(COMPILE_AVX ${CMAKE_CURRENT_BINARY_DIR}
                ${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx.cpp
                COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${AVX_FLAGS}"
                OUTPUT_VARIABLE COMPILE_AVX_OUTPUT)
    if(${COMPILE_AVX})
      set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS}   ${AVX_FLAGS}")
      #set( SCALFMM_USE_SSE   OFF   FORCE) # ne marche pas
      try_compile(COMPILE_RESULT_AVSPE ${CMAKE_CURRENT_BINARY_DIR}
                  ${SCALFMM_CMAKE_MODULE_PATH}/checkAVXpe.cpp
                  COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${AVX_FLAGS}")
      if( NOT ${COMPILE_RESULT_AVSPE})
        set(__AVXPE_INTEL_COMPILER ON)
      endif()
 
      message(STATUS ${CMAKE_CXX_FLAGS} )
    else(${COMPILE_AVX})
      message(FATAL_ERROR "AVX NOT SUPPORTED ; Set SCALFMM_USE_AVX  to OFF \n Output from test is : ${COMPILE_AVX_OUTPUT} ")
    endif(${COMPILE_AVX})
  endif(SCALFMM_USE_AVX)
  list(APPEND FUSE_LIST "AVX")
  #
  # Error if both SCALFMM_USE_AVX AND SCALFMM_USE_SSE are set
  #
  if( SCALFMM_USE_AVX AND SCALFMM_USE_SSE)
    message(FATAL_ERROR "Check SCALFMM_USE_SSE or SCALFMM_USE_AVX BUT NOT BOTH. ")
  endif(SCALFMM_USE_AVX AND SCALFMM_USE_SSE)
  ##################################################################
  #                           Use AVX2                             #
  ##################################################################
 
  message(STATUS "SCALFMM_USE_AVX2               = ${SCALFMM_USE_AVX2}")
  if(SCALFMM_USE_AVX2)
    if(NOT EXISTS ${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx2.cpp)
      message(FATAL_ERROR "The CompileTestSseFile does not exist (${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx.cpp)" )
    endif()
 
    try_compile(COMPILE_AVX2 ${CMAKE_CURRENT_BINARY_DIR}
                ${SCALFMM_CMAKE_MODULE_PATH}/compileTestAvx2.cpp
                COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${AVX2_FLAGS}"
                OUTPUT_VARIABLE COMPILE_AVX2_OUTPUT)
    if(${COMPILE_AVX2})
      set(SCALFMM_CXX_FLAGS "${SCALFMM_CXX_FLAGS}   ${AVX2_FLAGS}")
      #set( SCALFMM_USE_SSE   OFF   FORCE) # ne marche pas
      try_compile(COMPILE_RESULT_AVSPE ${CMAKE_CURRENT_BINARY_DIR}
                  ${SCALFMM_CMAKE_MODULE_PATH}/checkAVX2pe.cpp
                  COMPILE_DEFINITIONS "${CMAKE_CXX_FLAGS} ${AVX2_FLAGS}")
      if( NOT ${COMPILE_RESULT_AVSPE})
        set(__AVX2PE_INTEL_COMPILER ON)
      endif()
 
      message(STATUS ${CMAKE_CXX_FLAGS} )
    else(${COMPILE_AVX2})
      message(FATAL_ERROR "AVX2 NOT SUPPORTED ; Set SCALFMM_USE_AVX2  to OFF \n Output from test is : ${COMPILE_AVX_OUTPUT} ")
    endif(${COMPILE_AVX2})
  endif(SCALFMM_USE_AVX2)
  list(APPEND FUSE_LIST "AVX2")
  #
  # Error if both SCALFMM_USE_AVX2 AND SCALFMM_USE_SSE are set
  #
  if( SCALFMM_USE_AVX2 AND SCALFMM_USE_SSE)
    message(FATAL_ERROR "Check SCALFMM_USE_SSE or SCALFMM_USE_AVX2 BUT NOT BOTH. ")
  endif(SCALFMM_USE_AVX2 AND SCALFMM_USE_SSE)
  ##################################################################
  #                     Use  native MIC compilation                #
  ##################################################################
  if( SCALFMM_USE_MIC_NATIVE )
    include(CheckCCompilerFlag)
    check_c_compiler_flag(-mmic HAS_MMIC_FLAG)
    if(NOT HAS_MMIC_FLAG)
      message(FATAL_ERROR "MIC NOT SUPPORTED ; Set SCALFMM_USE_MIC_NATIVE to OFF")
    endif()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmic")
  else()
    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -xhost")
  endif()
  list(APPEND FUSE_LIST "MIC")
  ##################################################################
  #
  ##################################################################
 
 
  ##################################################################
  #                                                                #
  #                     END SETTING VARIABLES                      #
  #                                                                #
  ##################################################################
  #
  # Generate  ScalFmmConfig.h
  #
  set(SCALFMM_COMPILE_FLAGS "${SCALFMM_CXX_FLAGS} ${CMAKE_CXX_FLAGS_TYPE} ${CMAKE_CXX_FLAGS}")
  set(CMAKE_CXX_FLAGS "${SCALFMM_COMPILE_FLAGS}")
#  set(CMAKE_CXX_FLAGS "${SCALFMM_COMPILE_FLAGS} ${CMAKE_CXX_FLAGS_TYPE} ${CMAKE_CXX_FLAGS}")
  set(SCALFMM_COMPILE_LIBS   "${SCALFMM_LIBRARIES}")
  configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/Src/ScalFmmConfig.h.cmake
                  ${CMAKE_BINARY_DIR}/Src/ScalFmmConfig.h  )
  #
  ##################################################################
  #                      Build - lib                               #
  ##################################################################
  #
  add_subdirectory(Src)
  # Link with scalfmm lib
  set(scalfmm_lib scalfmm)
  #
  ##################################################################
  #            Remove compilation  of the drivers                  #
  ##################################################################
  if( SCALFMM_BUILD_EXAMPLES )
    # Build - Examples and drivers
    add_subdirectory(Examples)
  endif()
  ##################################################################
  #           Build tools (Internal use)                           #
  ##################################################################
  # Build - UTILs
  if( SCALFMM_ONLY_DEVEL )
    add_subdirectory(Utils)
  endif()
 
  ##################################################################
  #                Build -Tests to see examples                    #
  ##################################################################
  # Build - Tests
  message( STATUS "SCALFMM_BUILD_TESTS          = ${SCALFMM_BUILD_TESTS}" )
  if( SCALFMM_BUILD_TESTS )
    add_subdirectory(Tests)
  endif()
 
  ##################################################################
  #              Build - Unitary and numerical Tests               #
  ##################################################################
  #
  message( STATUS "SCALFMM_BUILD_UTESTS         = ${SCALFMM_BUILD_UTESTS}" )
  if( SCALFMM_BUILD_UTESTS )
    include(CTest)
    enable_testing()
    add_subdirectory(UTests)
  endif()
 
  ##################################################################
  #                           Add - doc                            #
  ##################################################################
  if(SCALFMM_BUILD_DOC)
    add_subdirectory(Doc)
  endif()
  ##################################################################
  #                       Build - Addons                           #
  ##################################################################
  #
  if( SCALFMM_USE_ADDONS )
    file(GLOB all_addons ./Addons/*)
    # Options
    option( SCALFMM_ADDON_CKERNELAPI "Set to ON to build ScaFMM FMM API interface" OFF )
 
    foreach(addon_name ${all_addons})
      message(STATUS "Addons += ${addon_name}" )
      add_subdirectory(${addon_name})
    endforeach()
  endif()
 
  # Add custom clean command
  if("${CMAKE_GENERATOR}" MATCHES "Make")
    add_custom_target(reset
      COMMAND ${CMAKE_MAKE_PROGRAM} clean && rm -r ./CMake* && cmake ..
      WORKING_DIRECTORY ${CMAKE_CURRENT_DIR}
      COMMENT "Cleaning Build dir and CMake cache, then do cmake.."
      )
  endif()
  #
  ##################################################################
  #                                                                #
  #                  Build and export cmake files                  #
  #                                                                #
  ##################################################################
  #
  message(STATUS "SCALFMM_BINARY_DIR:          " ${SCALFMM_BINARY_DIR})
  configure_file(${SCALFMM_SOURCE_DIR}/ScalFMMConfig.cmake.in
    ${SCALFMM_BINARY_DIR}/ScalFMMConfig.cmake
    @ONLY IMMEDIATE
    )
  #
  install(FILES  ${SCALFMM_BINARY_DIR}/ScalFMMConfig.cmake  DESTINATION lib/  )
  if( SCALFMM_INSTALL_DATA )
    install(FILES  ${SCALFMM_SOURCE_DIR}/Data/test20k.fma  DESTINATION Data/   )
  endif()
 
  ##################################################################
  #                                                                #
  #              build a CPack driven installer package            #
  #                                                                #
  ##################################################################
  #
  # Use git commit number as CPACK_PACKAGE_VERSION_PATCH
  set(CPACK_PACKAGE_VERSION_PATCH 0)
  execute_process(
    COMMAND git rev-list HEAD --count
    OUTPUT_VARIABLE CPACK_PACKAGE_VERSION_PATCH
    RESULT_VARIABLE RET
    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
    )
  #string_TRIM(PATCH1 PATCH)
  set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY "ON")
  #
  set (CPACK_RESOURCE_FILE_LICENSE  "${CMAKE_CURRENT_SOURCE_DIR}/Licence.txt")
  set(CPACK_PACKAGE_VERSION_MAJOR "${SCALFMM_MAJOR_VERSION}")
  set(CPACK_PACKAGE_VERSION_MINOR "${SCALFMM_MINOR_VERSION}")
  #
  set(PACK_PACKAGE_VERSION "${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}-${CPACK_PACKAGE_VERSION_PATCH}")
  set(CPACK_SOURCE_GENERATOR "TGZ")
  set(CPACK_SOURCE_PACKAGE_FILE_NAME  "SCALFMM-${SCALFMM_MAJOR_VERSION}.${SCALFMM_MINOR_VERSION}-${CPACK_PACKAGE_VERSION_PATCH}")
  set(CPACK_SOURCE_IGNORE_FILES "\\\\.git;.DS_Store;.*~;/*.aux;/*.idx;/*.log;/*.out;/*.toc;/*.ilg;scalfmm.pro*;org.eclipse.core.resources.prefs;.cproject;.project")
  list(APPEND CPACK_SOURCE_IGNORE_FILES  "${CMAKE_BINARY_DIR};${CMAKE_SOURCE_DIR}/Utils/;Notes;Deprecated;/Build*;/noDist/;/Bench;ToRemove;Olivier")
  # Uniform;GroupTree;Adaptive;testUnif*;/*Lagrange*")
  #list(APPEND CPACK_SOURCE_IGNORE_FILES  "Stages;Uniform;Adaptive;testUnif*;*Lagrange*" )
  #
  include(CPack)
  #
  #
  ##################################################################
  #                                                                #
  #                      PRINT messages                            #
  #                                                                #
  ##################################################################
  message(STATUS "CPACK_SOURCE_IGNORE_FILES = ${CPACK_SOURCE_IGNORE_FILES}")
  message(STATUS "CPACK_SOURCE_PACKAGE_FILE_NAME = ${CPACK_SOURCE_PACKAGE_FILE_NAME}")
  #
  #                    Use Mem stats
  message(STATUS "SCALFMM_USE_MEM_STATS        = ${SCALFMM_USE_MEM_STATS}" )
  #                    Use Log
  message(STATUS "SCALFMM_USE_LOG              = ${SCALFMM_USE_LOG}" )
  #                    Use Assert
  message(STATUS "SCALFMM_USE_ASSERT           = ${SCALFMM_USE_ASSERT}" )
  #
  #message(STATUS "CMAKE_CXX_FLAGS   =  ${CMAKE_CXX_FLAGS}")
  #set(CMAKE_CXX_FLAGS "${SCALFMM_CXX_FLAGS} ${CMAKE_CXX_FLAGS}")
  message(STATUS "SCALFMM_USE_BLAS     =  ${SCALFMM_USE_BLAS}")
  message(STATUS "SCALFMM_USE_FFT       =  ${SCALFMM_USE_FFT}")
  message(STATUS "SCALFMM_USE_MKL      =  TODO")
# 
  message(STATUS "CMAKE_CXX_FLAGS     =  ${CMAKE_CXX_FLAGS}")
  message(STATUS "SCALFMM_CXX_FLAGS   =  ${SCALFMM_CXX_FLAGS}")
  message(STATUS "SCALFMM_LIBRARIES   =  ${SCALFMM_LIBRARIES}")
  message(STATUS "SCALFMM_INCLUDES    =  ${SCALFMM_INCLUDES}")
  ##################################################################
  #                               END                              #
  ##################################################################
 
else(MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_SOURCE_DIR}/CMakeModules/morse/")
 
  message(STATUS "MORSE_DISTRIB_DIR is not set")
  message(STATUS "Please indicate where is located your MORSE distribution directory."
    " This is necessary to find cmake_modules.")
  message(STATUS "If you are a MORSE developer, you normally have access to the svn repository of the MORSE_DISTRIB_DIR: "
    "svn checkout svn+ssh://yourlogin@scm.gforge.inria.fr/svnroot/morse/trunk/morse_distrib")
 
endif(MORSE_DISTRIB_DIR OR EXISTS "${CMAKE_SOURCE_DIR}/CMakeModules/morse/")

**ternel** · 21/07/2015, 15h38

il te dit "Goto ./Build and tapes cmake ../"
donc tu vas dans Build, et tu tapes cmake ../ -G "CodeBlocks - Unix Makefiles".

**dfshr8** · 21/07/2015, 18h47

C'est ce que j'ai fait mais comme déjà dit il y a une erreur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
@sky:~/Desktop/SCALFMM-1.3-56/Build$ cmake ../ -G "CodeBlocks - Unix Makefiles"
CMake Error at CMakeLists.txt:19 (message):
  SCALFMM requires an out of source build.  Goto ./Build and tapes cmake ../
 
 
-- Configuring incomplete, errors occurred!
See also "/Network/Servers/ldap.ann.jussieu.fr/Volumes/DATA/users/thesards/dfshr8/Desktop/SCALFMM-1.3-56/CMakeFiles/CMakeOutput.log".

Déroulement d'un programme C++ et compréhension

C++

Discussions similaires

Partager

Partager