CMake
többplatformos, fordítófüggetlen build rendszer generátor From Wikipedia, the free encyclopedia
Remove ads
A CMake egy ingyenes, platform-független szoftverfejlesztő eszköz, amellyel a fordítótól független utasítások segítségével készíthetünk alkalmazásokat. Automatizálni tudja a tesztelést, a csomagolást és a telepítést is. Számos platformon fut, és számos programozási nyelvet támogat.[3]
Meta-építő eszközként a CMake konfigurálja a natív[4] build-eszközöket,[5] amelyek viszont a kódbázist építik.[6] A CMake a CMake-specifikus konfigurációs fájlok alapján konfigurációs fájlokat generál más építőeszközök[5] számára.[7] A többi eszköz a közvetlenebb építésért[5] felelős; a generált fájlok felhasználásával. A CMake-specifikus konfigurációs fájlok egyetlen készletével egy kódbázis több platform natív építőeszközeivel is építhető.[8]
A CMake által támogatott fontosabb natív építőeszközök[5] a következők: Make, Qt Creator, Ninja, Android Studio, Xcode és Visual Studio.[8]
A CMake szabad és nyílt forráskódú szoftver, amely a BSD-3 klauzula licenc alatt áll.[9]
Remove ads
Története
A kezdeti fejlesztés 1999-ben kezdődött a Kitware-nél a United States National Library of Medicine finanszírozásával a Visible Human Project[10] részeként.[8] A CMake 2000-ben jelent meg először.
A CMake-et az Insight Segmentation and Registration Toolkit (ITK[11]) több platformra történő építésének[5] támogatására fejlesztették ki. A kitűzött célok között szerepelt a korabeli eszközök, például az autoconf és a libtool gyengeségeinek kezelése az erősségek megtartása mellett, valamint az akkori legmodernebb építési technológiához való igazodás: konfigurációs szkriptek és Make fájlok Unix platformokon, valamint Visual Studio projektfájlok Windowson.[8][12]
A CMake-et több kortárs eszköz is inspirálta. A pcmaker – amelyet Ken Martin és mások fejlesztettek ki a Visualization Toolkit (VTK) építésének támogatására – a Unix Make fájlokat NMake fájlokká alakította a Windowson történő építéshez.[8] A gmake támogatta a Unix és Windows fordítókat, de a tervezése olyan problémákhoz vezetett, amelyeket nehéz volt megoldani. Mindkét eszköz működő példája volt a Unixot és a Windowst egyaránt támogató build eszköznek, de egy komoly hiba jellemezte őket: a Windows-fejlesztők számára a parancssor használatát követelték meg, annak ellenére, hogy sokan inkább integrált fejlesztőkörnyezetet (IDE), például a Visual Studiót használják.
A CMake célja az volt, hogy hasonló keresztplatformos támogatást nyújtson, de jobban kielégítse az egyes platformok fejlesztőinek preferenciáit.
Az első verzió tervezési céljai közé tartoztak:[8]
- Csak a gazdagép C++ fordítójától függ; nincs szükség más harmadik féltől származó eszközökre vagy könyvtárakra
- Visual Studio projektfájlok (valamint Unix-fájlok) generálása
- Támogassa az építési[5] célokat: program, statikus könyvtár, megosztott könyvtár
- Futtasson build-idejű kódgenerátorokat
- Támogassa a külön könyvtárfákat a forrás- és a build-fájlokhoz
- Támogassa a gazdaszámítógép képességeinek önvizsgálatát
- A C/C++ fejlécfájlok automatikus függőségi vizsgálatának támogatása
- Minden funkciónak következetesen és egyformán jól kell működnie minden támogatott platformon
Különböző okokból a CMake fejlesztői úgy döntöttek, hogy a Tcl – az akkoriban népszerű építési nyelv – helyett egy szkriptnyelv kifejlesztését választják a CMake számára. A Tcl használata egy olyan függőséget jelentett volna a gépen, amely ellentétes a céllal, hogy a fordítóprogramon kívül ne legyenek függőségek. Továbbá a Tcl a kezdeti fejlesztés idején nem volt jól támogatott a Windows és néhány Unix rendszeren.[8]
A későbbi fejlesztéseket és javításokat a CMake beépítése a fejlesztők saját rendszereibe, beleértve a VXL projektet,[13] a Brad King által hozzáadott CABLE[14] funkciókat, és a GE Corporate R&D-t a DART támogatására.[15] További funkciókat hoztak létre, amikor a VTK áttért a CMake-re a build környezet és a ParaView támogatásához.
A 3.0-ás verzió 2014 júniusában jelent meg.[16] A „Modern CMake” kezdetének nevezték.[17] A szakértők most azt tanácsolják, hogy kerüljük a változókat a célok és a tulajdonságok javára.[18] A CMake 2 alapját képező add_compile_options, include_directories, link_directories, link_libraries parancsokat mostantól célspecifikus parancsokkal kell helyettesíteni.
Remove ads
Név
Brad King, a CMake fejlesztője azt nyilatkozta, hogy „a 'C' a CMake-ben a »cross-platform«-ot jelenti”.[19]
Jellemzők
Generátorok
Minden egyes natív építőeszköz[5] támogatása külön generatorként van megadva. A CMake alapértelmezés szerint egy adott generátort használ a gazdakörnyezethez. Alternatívaként a generátor kiválasztható a parancssori -G opcióval. Például a Unix Makefiles generátor fájlokat hoz létre a make számára.[8]
A CMake nem támogatja az egyéni generátorokat a CMake implementáció módosítása nélkül. Ennek ellenére a CMake forráskódja módosítható, hogy tartalmazzon egy egyéni generátort.
Build targets
A CMake támogatja a futtatható fájlok, könyvtárak (pl. libxyz, xyz.dll stb.), objektumfájl könyvtárak és álcélok (pseudo-targets, beleértve az aliasokat is) építését. A CMake képes olyan objektumfájlokat előállítani, amelyeket a végrehajtható binárisok/könyvtárak linkelhetnek, elkerülve a dinamikus (futásidejű) linkelést, és helyette statikus (fordításidejű) linkelést használva. Ez lehetővé teszi a különböző optimalizációk rugalmas konfigurálását.[20]
A cél (target) generálása a cél tulajdonságain keresztül konfigurálható. A régebbi verziókban ez a CMAKE_-prefixált globális változókon keresztül történt, de ez a megközelítés elavult.[18][21]
Hierarchikus konfiguráció
A CMake konfigurációs fájlokat a forráskód hierarchikus felépítése szerint lehet strukturálni; ez a forrásfa. A gyökér (root) forráskönyvtárban található CMakeLists.txt a konfiguráció gyökereként szolgál. Ez tartalmazhat alkönyvtárakat, amelyek mindegyike tartalmaz egy CMakeLists.txt-t. Ennek megismétlése a konfiguráció hierarchikus szerkezetét eredményezi, amely követi a forráskód szerkezetét.[18][21]
Különálló építési fa
A CMake képes a generált fájlokat (mind a CMake, mind a natív építőeszközök által) a forrásfától elkülönített könyvtárfában elhelyezni.[8]
Ez lehetővé teszi a többszörös építést[5] ugyanabból a forrásfából, mivel mindegyiknek különálló, nem átfedő fájlrendszeri helye van. Ez kihasználható különböző vagy akár inkompatibilis konfigurációk, például különböző platformok számára történő létrehozására.
Ez egyszerűsíti a fájlkezelést is, mivel lehetővé teszi a generált fájlok eltávolítását egyetlen könyvtárfa törlésével, ahelyett, hogy a forrásfában több fájlt és könyvtárat távolítana el. Ez általában megakadályozza a forrásfájlok véletlen törlését vagy a generált fájlok véletlen hozzáadását a verziókezelés során.
Függőségkezelés
A CMake biztosítja, hogy a downstream komponensek újraépüljenek,[22] amikor a forrásai megváltoznak vagy épülnek.[8]
Flexibilis projektstruktúra
A CMake képes rendszerszintű és felhasználó által meghatározott futtatható állományok, fájlok és könyvtárak keresésére. Ezeket a helyeket egy gyorsítótárban tárolja, amelyek aztán testreszabhatók a cél build fájlok generálása előtt. A cache szerkeszthető egy grafikus szerkesztővel, amely a CMake-kel együtt kerül szállításra.
A bonyolult könyvtárhierarchiákat és a több könyvtárra támaszkodó alkalmazásokat a CMake jól támogatja. Például képes befogadni egy olyan projektet, amely több eszközkészletet (toolkit) vagy könyvtárat tartalmaz, amelyek mindegyike több könyvtárral rendelkezik. Ezen kívül a CMake képes olyan projektekkel is dolgozni, amelyeknél a végrehajtható fájlok létrehozása szükséges a végső alkalmazáshoz lefordítandó kód generálása előtt. Nyílt forráskódú, bővíthető felépítése lehetővé teszi, hogy a CMake-et szükség szerint hozzá lehessen igazítani az adott projektekhez.[23]
IDE konfigurációs támogatás
A CMake képes projektfájlokat generálni több népszerű IDE-hez, például a Microsoft Visual Studio, az Xcode és az Eclipse CDT számára. Emellett képes build scripteket készíteni az MSBuild vagy NMake számára Windowson; a Unix Make számára Unix-szerű platformokon, mint például Linux, macOS és Cygwin; és a Ninja számára Windowson és Unix-szerű platformokon egyaránt.
A fordítói funkciók felismerése
A CMake lehetővé teszi azoknak a tulajdonságoknak a megadását, amelyeket a fordítónak támogatnia kell ahhoz, hogy a célprogram vagy könyvtár lefordításra kerüljön.[24]
Compiler támogatás
A CMake számos fordítóprogramot támogat, többek között a következőket: Apple Clang, Clang, GNU GCC, MSVC, Oracle Developer Studio és Intel C++ Compiler.[25]
Csomagkezelés
A CMake képes csomagokat feldolgozni és előállítani is. A CMake funkciókat biztosít a csomagok távoli szerverről való lehívására, amelyeket a build folyamat részeként lehet használni. A CPack segítségével a fájlok csomagolhatók egy archív fájlba a célplatform által támogatott csomagkezelő vagy telepítő számára.[26](pp132,142)[27][28]
GUI
A Cmake futtatható egy ncurses programmal, mint a ccmake, amely a projektek konfigurálására használható parancssori felületen keresztül.
Előfordított fejlécek
A 3.6-os verzió óta lehetőség van előre lefordított fejlécek generálására a CMake segítségével.[29]
JSON strings
A CMake támogatja a JSON-adat karakterláncokból történő értékek kivonását a változókba (a 3.19-es verzió óta).[30]
Remove ads
Nyelv
A CMake tartalmaz egy értelmezőt egy viszonylag egyszerű, egyéni, imperatív szkriptnyelvhez, amely támogatja a változókat, a karakterlánc-kezelést, a tömböket, a függvény- és makródeklarációt, valamint a modulok felvételét (importálását).
Az értelmező a CMake nyelvi parancsokat a CMakeLists.txt nevű fájlokból olvassa be, amelyek megadják a forrásfájlokat és az építési[5] beállításokat. A CMake ezeket az információkat használja a natív eszközkonfigurációs fájlok létrehozásához. Ezenkívül .cmake végződésű fájlok további szkriptek tárolására is használhatók.[31]
Parancs szintaxis
A CMake nyelvi parancsok formátuma a következő:
name(argument ...)
Az argumentumok szóközzel vannak elválasztva, és tartalmazhatnak kulcsszavakat az argumentumcsoportok elválasztására. Például a következő parancsban a COMPILE_FLAGS kulcsszó a forrásfájlok listáját választja el a fordítói flagektől.[32]
set_source_file_properties(filename ... COMPILE_FLAGS compile_flag ...)
Remove ads
Megvalósítás
A CMake szkriptnyelv Yacc és Lex generátorokon keresztül valósul meg.
A CMake, CPack és CTest futtatható programok C++ nyelven íródtak.
A CMake funkcionalitásának nagy része a CMake nyelven írt modulokban van implementálva.[33]
A CMake dokumentáció (a 3.0-s kiadás óta) reStructuredText jelölést használ. A HTML oldalakat és a man oldalakat a Sphinx dokumentációgenerátor hozza létre.
Remove ads
További eszközök
A CMake számos .cmake szkriptfájlt és fejlesztői eszközt tartalmaz, amelyek megkönnyítik az olyan feladatokat, mint a függőségek keresése (beépített és külső, pl. FindXYZ modulok), az eszköztár környezetének és a futtatható állományoknak a tesztelése, a kiadások csomagolása (CPack) és a külső projektek függőségeinek kezelése (ExternalProject modul). A további fejlesztési eszközök közé tartoznak:[34][35]
Remove ads
Adoptálás
A CMake nagyon széles körben elterjedt a kereskedelmi, nyílt forráskódú és tudományos szoftverprojektek körében. Néhány neves felhasználó: Android NDK, Netflix, Inria, MySQL, Boost (C++ könyvtárak), KeePassXC, KDE, KiCAD, FreeCAD, WebKit, Blender,[38] Biicode, ReactOS, Apache Qpid, az ATLAS experiment,[39] és a Second Life.[40]
Építési folyamat
A CMake segítségével történő építés[5] két fő szakaszból áll.[8] Először is, a natív építőeszköz konfigurációs fájlokat a CMake konfigurációs fájlokból generálják – a CMake szkriptnyelvén írva. A parancssori szintaxis a következő: cmake <dir>, ahol a <dir> egy könyvtár, amely egy cmake <dir> fájlt tartalmaz. Ezután a natív build-eszközöket vagy a CMake-en keresztül (cmake --build <dir>), vagy közvetlenül a natív eszköz felületén keresztül hívjuk meg. A natív build eszközök a generált fájlokat használják.[23][41]
Remove ads
Példák
Hello world
Az alábbiakban bemutatjuk a CMake konfigurálását egy C++ nyelven írt hello world program elkészítéséhez, és a CMake használatát a program elkészítéséhez.
hello.cpp:
#include <iostream>
int main() {
std::cout << "Hello, world!" << std::endl;
return 0;
}
CMakeLists.txt:
cmake_minimum_required(VERSION 3.5)
project(HelloWorld CXX)
add_executable(hello hello.cpp)
A CMake-kel való építéshez először menjünk a fenti két fájlt tartalmazó könyvtárba. Ezután generálja a natív build config fájlokat a cross-platform CMake paranccsal:
cmake -B out .
Minden generált fájl a -B out segítségével megadott out könyvtárban lesz.
Ezután építsük a CMake által támogatott natív építőeszközzel (build tool):
cmake --build out
A program ezután futtatható. A Bash segítségével a parancs olyan, mint a ./out/hello. Windowson a kimeneti fájl a .exe végződéssel végződik.
Beépítés
Ez a példa a preprocesszor include elérési útvonalának konfigurálását mutatja be.
hello.cpp:
#include "hello.h"
#include <iostream>
int main() {
for (int i = 0; i < Times; i++) {
std::cout << "Hello, world!" << std::endl;
}
return 0;
}
hello.h:
const int Times = 10;
CMakeLists.txt:
cmake_minimum_required(VERSION 3.5)
project(HelloWorld CXX)
include_directories(${PROJECT_SOURCE_DIR})
add_executable(hello hello.cpp)
Lásd még
Jegyzetek
További információk
Fordítás
Wikiwand - on
Seamless Wikipedia browsing. On steroids.
Remove ads