CMake

CMake

FejlesztőAndy Cedilnik, Bill Hoffman, Brad King, Ken Martin, Alexander Neundorf (Kitware(wd))
Első kiadás2000. (2000)
Legfrissebb stabil kiadás4.0.0 / 2025. március
Programozási nyelvC, C++
Operációs rendszerUnix-szerű operációs rendszer, Windows
PlatformCross-platform+
Elérhetőangol
KategóriaC library, Programozási eszközök, Build
LicencBSD-3-Clause
Kódtárhttps://gitlab.kitware.com/cmake/cmake
[www.openhub.net/p/cmake A CMake weboldala]

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.

Meta-építő eszközként a CMake konfigurálja a natív build-eszközöket, amelyek viszont a kódbázist építik. 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 számára. A többi eszköz a közvetlenebb építésért 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ő.

A CMake által támogatott fontosabb natív építőeszközök a következők: Make, Qt Creator(wd), Ninja(wd), Android Studio, Xcode és Visual Studio.

A CMake szabad és nyílt forráskódú szoftver, amely a BSD-3 klauzula licenc alatt áll.

Története

A kezdeti fejlesztés 1999-ben kezdődött a Kitware-nél(wd) a United States National Library of Medicine(wd) finanszírozásával a Visible Human Project részeként. A CMake 2000-ben jelent meg először.

A CMake-et az Insight Segmentation and Registration Toolkit (ITK) több platformra történő építésének 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(wd) és a libtool(wd) 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(wd) és Make fájlok Unix platformokon, valamint Visual Studio projektfájlok Windowson.

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(wd)) építésének támogatására – a Unix Make fájlokat NMake(wd) fájlokká alakította a Windowson történő építéshez. A gmake(wd) 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:

Különböző okokból a CMake fejlesztői úgy döntöttek, hogy a Tcl(wd) – az akkoriban népszerű építési(wd) 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.

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, a Brad King által hozzáadott CABLE funkciókat, és a GE Corporate R&D-t(wd) a DART támogatására. További funkciókat hoztak létre, amikor a VTK(wd) á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. A „Modern CMake” kezdetének nevezték. 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. 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.

Név

Brad King, a CMake fejlesztője azt nyilatkozta, hogy „a 'C' a CMake-ben a »cross-platform«-ot jelenti”.

Jellemzők

Generátorok

Minden egyes natív építőeszköz 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 -G Unix Makefiles build szkripteket hoz létre a make számára.

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(wd) is) építését. A CMake képes olyan objektumfájlokat(wd) 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.

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.

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.

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.

Ez lehetővé teszi a többszörös építést 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(wd) 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(wd) komponensek újraépüljenek, amikor a forrásai megváltoznak vagy épülnek.

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.

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(wd) vagy NMake(wd) 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.

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(wd), Oracle Developer Studio(wd) és Intel C++ Compiler(wd).

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(wd) segítségével a fájlok csomagolhatók egy archív fájlba(wd) a célplatform által támogatott csomagkezelő vagy telepítő számára.(pp132,142) A CMake függvényeket biztosít csomagok távoli szerverről történő letöltéséhez, amelyek felhasználhatók a build folyamat részeként, vagy korábban telepített cmake csomagok csatolására.

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(wd) generálására a CMake segítségével. A 3.28-as verziótól kezdve a CMake modulok(wd) fordítására is képes. Kísérleti támogatás van a fejlécegységekhez is.

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).

Nyelv

A CMake tartalmaz egy értelmezőt egy viszonylag egyszerű, egyéni, imperatív szkriptnyelvhez(wd), 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 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.

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.

set_source_file_properties(filename ... COMPILE_FLAGS compile_flag ...)

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.

A CMake dokumentáció (a 3.0-s kiadás óta) reStructuredText(wd) jelölést használ. A HTML oldalakat és a man oldalakat a Sphinx(wd) dokumentációgenerátor(wd) hozza létre.

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:

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(wd), Netflix, Inria(wd), MySQL, Boost (C++ könyvtárak)(wd), KeePassXC(wd), KDE, KiCAD(wd), FreeCAD(wd), WebKit, Blender, Biicode, ReactOS, Apache Qpid, az ATLAS experiment, és a Second Life.

Építési folyamat

A CMake segítségével történő építés két fő szakaszból áll. 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.

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

  1. ↑ CMake 4.0.0 available for download 28 March 2025. Retrieved 29 March 2025.
  2. ↑ "The CMake Open Source Project on OpenHub". OpenHub. Hozzáférés: 2016. április 9.
  3. ↑ "CMake".
  4. ↑ A számítástechnikában a natív(wd) szoftverek vagy adatformátumok olyanok, amelyeket egy adott operációs rendszeren való futtatásra terveztek. Technikai értelemben a natív kód kifejezetten egy adott processzorhoz írt kód.
  5. 1 2 3 4 5 6 7 8 9 10 A szoftverösszeállítás (software build) az a folyamat, amelynek során a forráskódfájlokat önálló szoftvertermék(ek)ké alakítják, amelyek ennek eredményeként számítógépen futtathatók.
  6. ↑ A szoftverfejlesztésben a 'kódbázis (codebase(wd)) egy adott szoftverrendszer, alkalmazás vagy szoftverkomponens felépítéséhez(wd) használt forráskódok gyűjteménye.
  7. ↑ A konfigurációs fájl-okat számítógépes programok, alkalmazások vagy operációs rendszerek paramétereinek kezdeti beállításaira használják.
  8. 1 2 3 4 5 6 7 8 9 10 11 "The Architecture of Open Source Applications (Volume 1)CMake". aosabook.org. Hozzáférés: 2023. június 11.
  9. ↑ "Licenses · master · CMake / CMake". GitLab (angol nyelven). Hozzáférés: 2020. november 13.
  10. ↑ A Visible Human Project(wd) az emberi testről készült keresztmetszeti fényképek részletes adatkészletének létrehozására tett erőfeszítés, az anatómiai vizualizációs alkalmazások megkönnyítése érdekében.
  11. ↑ Az ITK (Insight Segmentation and Registration Toolkit(wd)) egy többplatformos, nyílt forráskódú alkalmazásfejlesztő keretrendszer, amelyet széles körben használnak képszegmentáló(wd) és képregisztrációs(wd) programok fejlesztésére.
  12. ↑ "FLOSS Weekly 111: CMake". podcast. TWiT Network. Hozzáférés: 2011. február 27.
  13. ↑ A VXL(wd), a Vision-something-Library a nyílt forráskódú C++ könyvtárak nagy gyűjteménye a számítógépes megjelenítéshez(wd).
  14. ↑ "The CABLE". 2013. június 19. dátummal az eredeti címről archiválva. Hozzáférés: 2010. november 10.
  15. ↑ A GE Aerospace Research a GE Aerospace(wd) kutatási és fejlesztési részlege.
  16. ↑ Maynard, Robert (2014. június 10.). "[CMake] [ANNOUNCE] CMake 3.0.0 Released".
  17. ↑ "Effective Modern CMake". Gist.
  18. 1 2 3 Binna, Manuel (2018. július 22.). "Effective Modern CMake".
  19. ↑ https://public.kitware.com/Bug/view.php?id=14012#c32631
  20. ↑ "cmake-buildsystem(7) — CMake 3.19.0-rc3 Documentation". cmake.org. Hozzáférés: 2020. november 14.
  21. 1 2 Pfeifer, Daniel (2017. május 19.). Effective Cmake (PDF). CPPNow.
  22. ↑ A szoftverfejlesztésben a downstream a forráskódként terjesztett szoftver eredeti szerzőitől vagy karbantartóitól való távolodásra utal, és a javítás minősítése.
  23. 1 2 Neundorf, Alexander (2006. június 21.). "Why the KDE project switched to CMake—and how". LWN.net.
  24. ↑ "CMake compiler feature detect". www.scivision.dev (amerikai angol nyelven). 2020. november 15. Hozzáférés: 2022. január 22.
  25. ↑ "Supported Compilers". CMake Documentation. Hozzáférés: 2022. január 22.
  26. ↑ Berner, Dominik (2022). CMake Best Practices : Discover Proven Techniques for Creating and Maintaining Programming Projects with CMake. Mustafa Kemal Gilor. Birmingham: Packt Publishing, Limited. ISBN 978-1-80324-424-2. OCLC 1319218167.
  27. ↑ "cmake-packages(7) — CMake 3.24.1 Documentation". cmake.org. Hozzáférés: 2022. szeptember 11.
  28. 1 2 "Exposing a module's configuration (advanced) — CMake build procedure 1.0 documentation". docs.salome-platform.org. Hozzáférés: 2022. szeptember 11.
  29. ↑ "target_precompile_headers — CMake 3.21.20210925-gb818e3c Documentation". cmake.org. Hozzáférés: 2021. szeptember 25.
  30. ↑ "CXX_MODULE_HEADER_UNIT_SETS". cmake.org. Kitware. Hozzáférés: 2025. október 31.
  31. ↑ "CMake 3.19 Release Notes — CMake 3.19.7 Documentation". cmake.org. Hozzáférés: 2021. március 15.
  32. ↑ "cmake-language(7) — CMake 3.19.0-rc2 Documentation". cmake.org. Hozzáférés: 2020. október 29.
  33. ↑ Cedilnik, Andrej (2003. október 30.). "Cross-Platform Software Development Using CMake Software". Linux Journal. Hozzáférés: 2021. január 29.
  34. ↑ "cmake-language(7) — CMake 3.19.0-rc1 Documentation". cmake.org. Hozzáférés: 2020. október 25.
  35. ↑ "cmake-modules(7) — CMake 3.14.7 Documentation". cmake.org. Hozzáférés: 2020. október 24.
  36. ↑ "ExternalProject — CMake 3.14.7 Documentation". cmake.org. Hozzáférés: 2020. október 24.
  37. ↑ "Packaging With CPack". CMake Community Wiki (angol nyelven).
  38. ↑ cpack(1) Linux General Commands Manual.
  39. ↑ "Building Blender - Blender Developer Wiki". wiki.blender.org. Hozzáférés: 2021. július 1.
  40. ↑ Elmsheuser, J; Krasznahorkay, A; Obreshkov, E; Undrus, A (2017). "Large Scale Software Building with CMake in ATLAS" (PDF). CERN. 2018. július 28. dátummal az eredetiből archiválva (PDF).
  41. ↑ "CMake Success". cmake.org. Kitware. 2011. Hozzáférés: 2022. március 12.
  42. ↑ "cmake-toolchains(7) — CMake 3.19.0-rc2 Documentation". cmake.org. Hozzáférés: 2020. október 29.

További információk

Fordítás