Utilisation de CMake avec C++ Builder

De RAD Studio
Aller à : navigation, rechercher

Prise en charge de la ligne de commande CMake

RAD Studio 10.2 Tokyo Release 3 inclut une prise en charge de la construction de projets CMake sur la ligne de commande à l'aide des compilateurs C++ de RAD Studio. Vous pouvez compiler pour Windows ou pour d'autres plates-formes que Windows. CMake prend en charge les compilateurs améliorés par Clang de RAD Studio : BCCAARM pour Android, BCCIOSARM64 pour iOS 64 bits, BCCIOSARM pour iOS 32 bits, BCC64 pour Windows 64 bits et BCC32X pour Windows 32 bits. RAD Studio 10.2 Tokyo Release 3 prend aussi en charge Ninja avec CMake. Cela permet de réaliser rapidement des compilations en parallèle.

Installation de CMake et Ninja

CMake

Téléchargez et installez CMake 3.10. Utilisez l'installateur binaire, car il peut optionnellement ajouter CMake au chemin système. Assurez-vous que vous sélectionnez cette option lors de l'installation.

Les fichiers CMake se trouvent dans C:\Program Files (x86)\Embarcadero\Studio\19.0\cmake. Toutefois, pour éviter des erreurs dans le processus de construction, vous devez déplacer un fichier manuellement. Pour cela, suivez les étapes ci-après :

  1. Localisez votre dossier d'installation CMake et le sous-dossier Modules\Platform, par exemple C:\Program Files\CMake\share\cmake-3.10\Modules\Platform
  2. Localisez le fichier Windows-Embarcadero.cmake et sauvegardez-le.
  3. Copiez Windows-Embarcadero.cmake depuis le dossier Studio\19.0\cmake et écrasez la version figurant dans le dossier CMake.

La prise en charge de CMake a été largement étendue pour les compilateurs Windows. Vous devez utiliser ce fichier pour que la construction puisse s'effectuer avec succès.

Ninja

Téléchargez et installez Ninja 1.8.2. Vous devrez l'ajouter manuellement au chemin système.

Comment utiliser CMake

CMake réalise des constructions à partir d'un fichier texte appelé CMakeLists.txt qui indique à CMake quels fichiers construire. Vous trouverez plus d'informations dans la documentation développeur (EN). Nous vous recommandons également les articles de blog de Jeff Preshing sur CMake : How to Build a CMake-based Project et Learn CMake’s Scripting Language in 15 Minutes.

Pour utiliser CMake, vous avez besoin des fichiers suivants :

  • Le source C++ que vous voulez construire : un nombre de fichiers C++ et d'en-têtes.
  • Le fichier CMakeLists.txt : Définit le nom du projet, lui indique de trouver les fichiers source et de les construire dans un exécutable, une bibliothèque, un package, etc. Voir ci-dessous pour des fichiers exemples. Des fichiers CMakeLists.txt plus avancés spécifient plusieurs projets.
  • (Facultativement) Script du batch pour lancer CMake : Utilisez le script du batch (*.bat) pour définir un certain nombre de commandes. CMake peut créer un grand nombre de fichiers, et vous pouvez utiliser le fichier batch pour créer un sous-répertoire dans lequel toutes les sorties incluant les fichiers CMake sont placées. Cet article de blog sur l'utilisation de bcc32c avec CMake contient plus de détails.
Exécutez le script du batch depuis la ligne de commande pour générer le fichier exécutable ainsi que d'autres fichiers dans le sous-dossier spécifié.

Remarque : Stockez le fichier CMakeLists.txt dans le répertoire racine de votre projet. Vous pouvez stocker les fichiers sources dans un sous-dossier.

Construction en utilisant CMake

Lancez l'invite de commande RAD Studio depuis le menu Démarrer ou en ouvrant une invite de commande et en exécutant rsvars.bat dans le dossier RAD Studio \bin.

CMake recherche un fichier CMakeLists.txt. Voir ci-dessous pour plus d'informations sur la création de l'un de ces fichiers pour un projet.

Ciblage de Windows

Pour cibler Win32 : cmake -DCMAKE_C_COMPILER=bcc32x.exe -DCMAKE_CXX_COMPILER=bcc32x.exe -G Ninja

Pour cibler Win64 : cmake -DCMAKE_C_COMPILER=bcc64.exe -DCMAKE_CXX_COMPILER=bcc64.exe -G Ninja

Ensuite, ninja

Pour invoquer Ninja en vue de construire le build actuel.

Ciblage d'iOS et Android

iOS et Android sont gérés par l'intermédiaire des fichiers toolchain qui sont utilisés pour la compilation croisée. Assurez-vous que vous pouvez construire et déployer depuis l'EDI (y compris la configuration du SDK) avant de lancer un build par la ligne de commande.

Pour cibler iOS32 : cmake -DCMAKE_TOOLCHAIN_FILE=bccios32.cmake -G Ninja

Pour cibler iOS64 : cmake -DCMAKE_TOOLCHAIN_FILE=bccios64.cmake -G Ninja

Pour cibler Android : cmake -DCMAKE_TOOLCHAIN_FILE=bccaarm.cmake -G Ninja

Ensuite, ninja

Pour invoquer Ninja en vue de construire le build actuel.

Autres indicateurs de la ligne de commande

  • -G”Borland Makefiles” pour utiliser la méthode de construction traditionnelle.
  • -DCMAKE_BUILD_TYPE_INIT=Release de débogage ou construction de distribution (release build).
  • -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON pour faciliter la sortie du débogage.
  • --debug-output pour placer CMake en mode débogage.

Par exemple : 

cmake -DCMAKE_C_COMPILER=bcc32x.exe -DCMAKE_CXX_COMPILER=bcc32x.exe -DCMAKE_BUILD_TYPE_INIT=Release -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -G "Borland Makefiles" --debug-output -v ..

Permet d'utiliser le compilateur Win32, les builds de distribution, les indicateurs de débogage ou du mode commentaire, et aussi de construire avec make en utilisant le fichier CMakeLists.txt situé dans le dossier parent.

Prise en charge spécifique de C++ Builder dans un fichier CMakeLists.txt

Cibles

En utilisant CMake, vous pouvez créer des exécutables, des DLL, des bibliothèques statiques et des packages. 

set_embt_target(FMX)
set_embt_target(VCL)
set_embt_target(Package)
set_embt_target(DynamicRuntime)

Ou des combinaisons : 

set_embt_target(VCL DynamicRuntime)

Macros et variables

Un certain nombre de macros et variables existent pour iOS et Android. Ce fichier CMakeLists.txt exemple en affiche certaines : 

cmake_minimum_required(VERSION 3.9)
set(APP "FMXApp")
set(CMAKE_BUILD_TYPE "DEBUG")
set(EMBT_PROJECT_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/Project_${APP}")
project (${APP})

if(EMBT_TARGET STREQUAL iOS64)
    set(EMBT_IOS_BUNDLE_IDENTIFIER "com.company.adhoc")
    set(EMBT_IOS_BUNDLE_EXECUTABLE ${APP})
    set(EMBT_IOS_BUNDLE_NAME ${APP})
    set(EMBT_IOS_BUNDLE_VERSION "1.0")
    set(EMBT_IOS_BUILD_TYPE "Ad-hoc")
    add_embt_background_modes(audio)
    add_embt_background_modes(voip)
    add_embt_additional_files("${CMAKE_CURRENT_SOURCE_DIR}/cmakelists.txt")
    add_embt_additional_files("${CMAKE_CURRENT_SOURCE_DIR}/cmakelists.txt" "${EMBT_PROJECT_LOCATION}" "new.txt")
    set(EMBT_IOS_CAMERA_USAGE_DESCRIPTION "This app needs access to your camera")
    set_embt_device_family(iphone)
    set(EMBT_IOS_MINIMUM_OS_VERSION 8.0)
    set(EMBT_IOS_BUNDLE_ALLOW_MIXED_LOCALIZATIONS YES)
    set(REMOTE_PROFILE "_mac")
    set(PROVISIONING_PROFILE "provision.mobileprovision")  
    set(CERTIFICATE "iPhone Distribution:")
elseif(EMBT_TARGET STREQUAL iOS32)
    set(EMBT_IOS_BUNDLE_EXECUTABLE ${APP})
    set(EMBT_IOS_BUNDLE_NAME ${APP})
    set(EMBT_IOS_BUNDLE_IDENTIFIER "com.company.id")
    set(EMBT_IOS_BUNDLE_VERSION "1.0")
    set(EMBT_IOS_MINIMUM_OS_VERSION 8.0)
    add_embt_background_modes(audio)
elseif(EMBT_TARGET STREQUAL Android)
    set(EMBT_ANDROID_BUILD_TYPE "Development")
    add_embt_additional_files("${CMAKE_CURRENT_SOURCE_DIR}/cmakelists.txt")
    add_embt_additional_files("${CMAKE_CURRENT_SOURCE_DIR}/cmakelists.txt" "${EMBT_PROJECT_LOCATION}" "new.txt")
    #set(EMBT_ANDROID_SPLASH_IMAGE_LARGE "c:/myArtwork/Android/FM_SplashImage_640x480.png")
    set(EMBT_ANDROID_INCLUDE_SPLASH_IMAGE True)
    set(EMBT_ANDROID_ALIAS "release-keystore")
    set(EMBT_ANDROID_KEYSTORE "release.jks")
    set(EMBT_ANDROID_STOREPASS "cmakeandroid")
    set(EMBT_ANDROID_KEYPASS "cmakeandroid")
endif()

# Create a sources variable with a link to all cpp files to compile
file(GLOB SOURCES
    "src/*.h"
    "src/*.cpp"
)
set_embt_target("FMX")
if(EMBT_TARGET STREQUAL Windows)
    add_executable (${APP} WIN32 ${SOURCES})
    install(TARGETS ${APP} RUNTIME DESTINATION bin)
else()
    add_fmx_app("${SOURCES}")
endif()

Fichier CMakeLists.txt exemple

Pour un projet nommé Example, contenant des fichiers source dans le même dossier, voici une présentation minimale du fichier CMakeLists.txt : 

cmake_minimum_required (VERSION 3.10)
project (Example)

file(GLOB Example_SRC
   "*.h"
   "*.cpp"
)

add_executable(Example ${Example_SRC})

Ces commandes spécifient la version minimale (3.10), le nom du projet, l'utilisation de tous les fichiers .cpp et .h disponibles, et la compilation du tout en un fichier Example.exe.

Rassembler tous les fichiers avec la commande “Glob” est rapide et simple, mais ce n'est pas une pratique recommandée, il est préférable de spécifier les fichiers à utiliser. Vous pouvez spécifier les fichiers .cpp et les en-têtes. Pour spécifier des fichiers .cpp, voici un exemple minimal : 

cmake_minimum_required (VERSION 3.10)
project (Example)

add_executable(Example main.cpp foo.cpp bar.cpp)

Fichier CMakeLists.txt exemple : Application VCL

cmake_minimum_required(VERSION 3.9)
project (VCLApp)
set_embt_target(VCL DynamicRuntime)
add_executable (VCLApp WIN32 src/VCLApplication.cpp src/Project1.cpp)
install(TARGETS VCLApp
            RUNTIME DESTINATION bin
            LIBRARY DESTINATION lib
            ARCHIVE DESTINATION lib/static
)

Fichier CMakeLists.txt exemple : Appplication FMX

cmake_minimum_required(VERSION 3.9)
project (FMXApp)
set_embt_target(FMX)
add_executable (FMXApp WIN32 src/FMXSample.cpp src/FMXProj.cpp)
install(TARGETS FMXApp RUNTIME DESTINATION bin)

Fichier CMakeLists.txt exemple : Bibliothèque partagée

project(SharedLibrary)

set(SharedLibrary_headers SharedLibrary.h)
set(SharedLibrary_sources SharedLibrary.cpp)

add_library(SharedLibrary SHARED SharedLibrary.h SharedLibrary.cpp)

install(TARGETS     SharedLibrary 
                    RUNTIME DESTINATION bin
                    LIBRARY DESTINATION lib
                    ARCHIVE DESTINATION lib/static
       )

Fichier CMakeLists.txt exemple : Bibliothèque statique

project(StaticLibrary)

set(StaticLibrary_headers StaticLibrary.h)
set(StaticLibrary_sources StaticLibrary.cpp)

add_library(StaticLibrary STATIC StaticLibrary.h StaticLibrary.cpp)
install(TARGETS     StaticLibrary
                    RUNTIME DESTINATION bin
                    LIBRARY DESTINATION lib
                    ARCHIVE DESTINATION lib/static
       )

Fichier CMakeLists.txt exemple : Package

cmake_minimum_required(VERSION 3.9)

project (PackageExample)
set_embt_target(Package)
add_library(PackageExample SHARED PackageExample.cpp)

install(TARGETS     PackageExample
                    RUNTIME DESTINATION bin
                    LIBRARY DESTINATION lib
                    ARCHIVE DESTINATION lib/static
       )

Fichier CMakeLists.txt exemple : Ressources

cmake_minimum_required(VERSION 3.9)

project (myapp)
set(SYSTEM_SOURCES ${SYSTEM_SOURCES} myapp.rc ) 
set(StrTableRes_SRCS resource.h myapp.cpp)
ADD_EXECUTABLE(myapp WIN32 ${SYSTEM_SOURCES} ${StrTableRes_SRCS} )

Voir aussi

Récupérée de « http://docwiki.embarcadero.com/RADStudio/Rio/f/index.php?title=Utilisation_de_CMake_avec_C%2B%2B_Builder&oldid=212910 »