CMake અને C++ કાયમ ભાઈઓ છે

વિકાસ દરમિયાન, મને કમ્પાઈલર બદલવા, બિલ્ડ મોડ્સ, ડિપેન્ડન્સી વર્ઝન, સ્ટેટિક એનાલિસિસ, પરફોર્મન્સ માપવા, કવરેજ એકત્રિત કરવા, દસ્તાવેજીકરણ વગેરે બનાવવાનું ગમે છે. અને હું ખરેખર CMake ને પ્રેમ કરું છું કારણ કે તે મને જે જોઈએ છે તે કરવા દે છે.

ઘણા લોકો સીમેકની ટીકા કરે છે, અને ઘણી વાર તે યોગ્ય રીતે, પરંતુ જો તમે તેને જુઓ, તો બધું એટલું ખરાબ નથી, અને તાજેતરમાં બિલકુલ ખરાબ નથી, અને વિકાસની દિશા તદ્દન હકારાત્મક છે.

આ નોંધમાં, હું તમને જણાવવા માંગુ છું કે નીચેની કાર્યક્ષમતા મેળવવા માટે સીમેક સિસ્ટમમાં C++ માં હેડર લાઇબ્રેરી કેવી રીતે ગોઠવવી:

1. વિધાનસભા;
2. ઑટોરન પરીક્ષણો;
3. કોડ કવરેજ માપન;
4. સ્થાપન;
5. સ્વતઃ-દસ્તાવેજીકરણ;
6. ઑનલાઇન સેન્ડબોક્સ જનરેશન;
7. સ્થિર વિશ્લેષણ.

કોઈપણ જે પહેલાથી જ ફાયદા અને સી-મેકને સમજે છે તે સરળ રીતે કરી શકે છે પ્રોજેક્ટ ટેમ્પલેટ ડાઉનલોડ કરો અને તેનો ઉપયોગ કરવાનું શરૂ કરો.

અનુક્રમણિકા

1. અંદરથી પ્રોજેક્ટ
   1. પ્રોજેક્ટ માળખું
   2. મુખ્ય CMake ફાઇલ (./CMakeLists.txt)
      1. પ્રોજેક્ટ માહિતી
      2. પ્રોજેક્ટ વિકલ્પો
      3. સંકલન વિકલ્પો
      4. પ્રાથમિક ધ્યેય
      5. સ્થાપન
      6. પરીક્ષણો
      7. Документация
      8. ઑનલાઇન સેન્ડબોક્સ
   3. ટેસ્ટ સ્ક્રિપ્ટ (test/CMakeLists.txt)
      1. પરીક્ષણ
      2. કવરેજ
   4. દસ્તાવેજીકરણ માટેની સ્ક્રિપ્ટ (doc/CMakeLists.txt)
   5. ઑનલાઇન સેન્ડબોક્સ માટે સ્ક્રિપ્ટ (online/CMakeLists.txt)
2. બહાર પ્રોજેક્ટ
   1. વિધાનસભા
      1. પેrationી
      2. વિધાનસભા
   2. વિકલ્પો
      1. MYLIB_COVERAGE
      2. MYLIB_TESTING
      3. MYLIB_DOXYGEN_LANGUAGE
   3. એસેમ્બલી લક્ષ્યો
      1. મૂળભૂત રીતે
      2. mylib-યુનિટ-પરીક્ષણો
      3. તપાસો
      4. કવરેજ
      5. ડૉક
      6. વેન્ડબોક્સ
   4. ઉદાહરણો
3. સાધનો
4. સ્થિર વિશ્લેષણ
5. ઉચ્ચારણ

અંદરથી પ્રોજેક્ટ

પ્રોજેક્ટ માળખું

.
├── CMakeLists.txt
├── README.en.md
├── README.md
├── doc
│   ├── CMakeLists.txt
│   └── Doxyfile.in
├── include
│   └── mylib
│       └── myfeature.hpp
├── online
│   ├── CMakeLists.txt
│   ├── mylib-example.cpp
│   └── wandbox.py
└── test
    ├── CMakeLists.txt
    ├── mylib
    │   └── myfeature.cpp
    └── test_main.cpp

અમે મુખ્યત્વે સીમેક સ્ક્રિપ્ટ્સ કેવી રીતે ગોઠવવી તે વિશે વાત કરીશું, તેથી તેમની વિગતવાર ચર્ચા કરવામાં આવશે. બાકીની ફાઈલો કોઈપણ સીધી જોઈ શકે છે નમૂના પ્રોજેક્ટ પૃષ્ઠ પર.

મુખ્ય CMake ફાઇલ (./CMakeLists.txt)

પ્રોજેક્ટ માહિતી

સૌ પ્રથમ, તમારે સીમેક સિસ્ટમના આવશ્યક સંસ્કરણની વિનંતી કરવાની જરૂર છે. CMake વિકસિત થઈ રહ્યું છે, આદેશની સહી અને વિવિધ પરિસ્થિતિઓમાં વર્તન બદલાઈ રહ્યું છે. સીમેકને તરત જ સમજવા માટે કે આપણે તેનાથી શું ઇચ્છીએ છીએ, અમારે તેના માટેની અમારી જરૂરિયાતોને તરત જ રેકોર્ડ કરવાની જરૂર છે.

cmake_minimum_required(VERSION 3.13)

પછી અમે અમારા પ્રોજેક્ટ, તેનું નામ, સંસ્કરણ, વપરાયેલી ભાષાઓ, વગેરેને નિયુક્ત કરીશું (જુઓ. команду project).

આ કિસ્સામાં અમે ભાષા સૂચવીએ છીએ CXX (અને આનો અર્થ C++ છે) જેથી CMake C લેંગ્વેજ કમ્પાઇલર માટે તાણ અને શોધ ન કરે (ડિફોલ્ટ રૂપે, CMake બે ભાષાઓનો સમાવેશ કરે છે: C અને C++).

project(Mylib VERSION 1.0 LANGUAGES CXX)

અહીં તમે તરત જ તપાસ કરી શકો છો કે અમારો પ્રોજેક્ટ સબપ્રોજેક્ટ તરીકે અન્ય પ્રોજેક્ટમાં સામેલ છે કે નહીં. આ ભવિષ્યમાં ઘણી મદદ કરશે.

get_directory_property(IS_SUBPROJECT PARENT_DIRECTORY)

પ્રોજેક્ટ વિકલ્પો

અમે બે વિકલ્પો આપીશું.

પ્રથમ વિકલ્પ છે MYLIB_TESTING - એકમ પરીક્ષણોને અક્ષમ કરવા માટે. આ જરૂરી હોઈ શકે છે જો અમને ખાતરી હોય કે પરીક્ષણો સાથે બધું વ્યવસ્થિત છે, પરંતુ અમે ફક્ત ઇચ્છીએ છીએ, ઉદાહરણ તરીકે, અમારા પ્રોજેક્ટને ઇન્સ્ટોલ અથવા પેકેજ કરવા. અથવા અમારા પ્રોજેક્ટનો સબપ્રોજેક્ટ તરીકે સમાવેશ કરવામાં આવ્યો છે - આ કિસ્સામાં, અમારા પ્રોજેક્ટના વપરાશકર્તાને અમારા પરીક્ષણો ચલાવવામાં રસ નથી. તમે જે નિર્ભરતાનો ઉપયોગ કરો છો તેનું તમે પરીક્ષણ કરતા નથી, શું તમે?

option(MYLIB_TESTING "Включить модульное тестирование" ON)

વધુમાં, અમે એક અલગ વિકલ્પ બનાવીશું MYLIB_COVERAGE પરીક્ષણો દ્વારા કોડ કવરેજને માપવા માટે, પરંતુ તેને વધારાના સાધનોની જરૂર પડશે, તેથી તેને સ્પષ્ટ રીતે સક્ષમ કરવાની જરૂર પડશે.

option(MYLIB_COVERAGE "Включить измерение покрытия кода тестами" OFF)

સંકલન વિકલ્પો

અલબત્ત, અમે કૂલ પ્લસ પ્રોગ્રામર છીએ, તેથી અમે કમ્પાઇલર પાસેથી કમ્પાઇલ-ટાઇમ ડાયગ્નોસ્ટિક્સનું મહત્તમ સ્તર ઇચ્છીએ છીએ. એક પણ ઉંદર સરકી જશે નહીં.

add_compile_options(
    -Werror

    -Wall
    -Wextra
    -Wpedantic

    -Wcast-align
    -Wcast-qual
    -Wconversion
    -Wctor-dtor-privacy
    -Wenum-compare
    -Wfloat-equal
    -Wnon-virtual-dtor
    -Wold-style-cast
    -Woverloaded-virtual
    -Wredundant-decls
    -Wsign-conversion
    -Wsign-promo
)

C++ ભાષાના ધોરણનું સંપૂર્ણ પાલન કરવા માટે અમે એક્સ્ટેંશનને પણ અક્ષમ કરીશું. તેઓ CMake માં મૂળભૂત રીતે સક્ષમ છે.

if(NOT CMAKE_CXX_EXTENSIONS)
    set(CMAKE_CXX_EXTENSIONS OFF)
endif()

પ્રાથમિક ધ્યેય

અમારી લાઇબ્રેરીમાં ફક્ત હેડર ફાઇલોનો સમાવેશ થાય છે, જેનો અર્થ છે કે અમારી પાસે સ્ટેટિક અથવા ડાયનેમિક લાઇબ્રેરીના રૂપમાં કોઈ એક્ઝોસ્ટ નથી. બીજી બાજુ, અમારી લાઇબ્રેરીનો બાહ્ય રીતે ઉપયોગ કરવા માટે, તેને ઇન્સ્ટોલ કરવાની જરૂર છે, તે સિસ્ટમમાં શોધી શકાય તેવું અને તમારા પ્રોજેક્ટ સાથે કનેક્ટેડ હોવું જરૂરી છે, અને તે જ સમયે આ સમાન હેડરો, તેમજ સંભવતઃ કેટલાક વધારાના, તે ગુણધર્મો સાથે જોડાયેલ છે.

આ હેતુ માટે, અમે ઇન્ટરફેસ લાઇબ્રેરી બનાવીએ છીએ.

add_library(mylib INTERFACE)

અમે હેડરોને અમારી ઇન્ટરફેસ લાઇબ્રેરીમાં બાંધીએ છીએ.

સીમેકનો આધુનિક, ફેશનેબલ, યુવા ઉપયોગ સૂચવે છે કે હેડર્સ, પ્રોપર્ટીઝ વગેરે. એક જ લક્ષ્ય દ્વારા પ્રસારિત. તેથી તે કહેવું પૂરતું છે target_link_libraries(target PRIVATE dependency), અને લક્ષ્ય સાથે સંકળાયેલા તમામ હેડરો dependency, લક્ષ્ય સાથે જોડાયેલા સ્ત્રોતો માટે ઉપલબ્ધ રહેશે target. અને તમારે કોઈની જરૂર નથી [target_]include_directories. આ વિશ્લેષણમાં નીચે દર્શાવવામાં આવશે એકમ પરીક્ષણો માટે CMake સ્ક્રિપ્ટ.

તે કહેવાતા પર ધ્યાન આપવાનું પણ યોગ્ય છે. выражения-генераторы: $<...>.

આ આદેશ આપણી ઇન્ટરફેસ લાઇબ્રેરી સાથે જરૂરી હેડરોને સાંકળે છે, અને જો અમારી લાઇબ્રેરી સમાન CMake હાઇરાર્કીમાં કોઈપણ લક્ષ્ય સાથે જોડાયેલ હોય, તો ડિરેક્ટરીમાંથી હેડરો તેની સાથે સંકળાયેલા હશે. ${CMAKE_CURRENT_SOURCE_DIR}/include, અને જો અમારી લાઇબ્રેરી સિસ્ટમ પર ઇન્સ્ટોલ કરેલી હોય અને આદેશનો ઉપયોગ કરીને બીજા પ્રોજેક્ટ સાથે જોડાયેલ હોય find_package, પછી ડિરેક્ટરીમાંથી હેડરો તેની સાથે સંકળાયેલ હશે include સ્થાપન ડિરેક્ટરી સંબંધિત.

target_include_directories(mylib INTERFACE
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

ચાલો ભાષાનું ધોરણ નક્કી કરીએ. અલબત્ત, ખૂબ જ છેલ્લું. તે જ સમયે, અમે ફક્ત ધોરણનો સમાવેશ જ નથી કરતા, પણ જેઓ અમારી લાઇબ્રેરીનો ઉપયોગ કરશે તેમના સુધી પણ તેનો વિસ્તાર કરીએ છીએ. આ એ હકીકતને કારણે પ્રાપ્ત થાય છે કે સેટ પ્રોપર્ટીની કેટેગરી છે INTERFACE (જુઓ target_compile_features આદેશ).

target_compile_features(mylib INTERFACE cxx_std_17)

ચાલો આપણી લાઈબ્રેરી માટે ઉપનામ બનાવીએ. તદુપરાંત, સૌંદર્ય માટે, તે વિશિષ્ટ "નેમસ્પેસ" માં હશે. જ્યારે અમારી લાઇબ્રેરીમાં વિવિધ મોડ્યુલ દેખાય ત્યારે આ ઉપયોગી થશે, અને અમે તેને એકબીજાથી સ્વતંત્ર રીતે કનેક્ટ કરવા જઈએ છીએ. ઉદાહરણ તરીકે, બુસ્ટાની જેમ.

add_library(Mylib::mylib ALIAS mylib)

સ્થાપન

સિસ્ટમમાં અમારા હેડરો ઇન્સ્ટોલ કરી રહ્યાં છીએ. અહીં બધું સરળ છે. અમે કહીએ છીએ કે બધા હેડરો સાથેનું ફોલ્ડર ડિરેક્ટરીમાં જવું જોઈએ include સ્થાપન સ્થાન સંબંધિત.

install(DIRECTORY include/mylib DESTINATION include)

આગળ, અમે બિલ્ડ સિસ્ટમને જાણ કરીએ છીએ કે અમે તૃતીય-પક્ષ પ્રોજેક્ટ્સમાં આદેશને કૉલ કરવા માટે સક્ષમ બનવા માંગીએ છીએ find_package(Mylib) અને ધ્યેય મેળવો Mylib::mylib.

install(TARGETS mylib EXPORT MylibConfig)
install(EXPORT MylibConfig NAMESPACE Mylib:: DESTINATION share/Mylib/cmake)

આગળની જોડણી આ રીતે સમજવી જોઈએ. જ્યારે તૃતીય-પક્ષ પ્રોજેક્ટમાં આપણે આદેશને કૉલ કરીએ છીએ find_package(Mylib 1.2.3 REQUIRED), અને ઇન્સ્ટોલ કરેલ લાઇબ્રેરીનું વાસ્તવિક સંસ્કરણ સંસ્કરણ સાથે અસંગત હશે 1.2.3CMake આપમેળે એક ભૂલ જનરેટ કરશે. એટલે કે, તમારે વર્ઝનને મેન્યુઅલી ટ્રૅક કરવાની જરૂર રહેશે નહીં.

include(CMakePackageConfigHelpers)
write_basic_package_version_file("${PROJECT_BINARY_DIR}/MylibConfigVersion.cmake"
    VERSION
        ${PROJECT_VERSION}
    COMPATIBILITY
        AnyNewerVersion
)
install(FILES "${PROJECT_BINARY_DIR}/MylibConfigVersion.cmake" DESTINATION share/Mylib/cmake)

પરીક્ષણો

જો પરીક્ષણોનો ઉપયોગ સ્પષ્ટ રીતે અક્ષમ કરવામાં આવે છે અનુરૂપ વિકલ્પ અથવા અમારો પ્રોજેક્ટ સબપ્રોજેક્ટ છે, એટલે કે, તે આદેશનો ઉપયોગ કરીને અન્ય CMake પ્રોજેક્ટ સાથે જોડાયેલ છે add_subdirectory, અમે વંશવેલો સાથે આગળ વધતા નથી, અને સ્ક્રિપ્ટ, જે પરીક્ષણો જનરેટ કરવા અને ચલાવવા માટેના આદેશોનું વર્ણન કરે છે, તે ફક્ત ચાલતી નથી.

if(NOT MYLIB_TESTING)
    message(STATUS "Тестирование проекта Mylib выключено")
elseif(IS_SUBPROJECT)
    message(STATUS "Mylib не тестируется в режиме подмодуля")
else()
    add_subdirectory(test)
endif()

Документация

સબપ્રોજેક્ટના કિસ્સામાં દસ્તાવેજીકરણ પણ જનરેટ કરવામાં આવશે નહીં.

if(NOT IS_SUBPROJECT)
    add_subdirectory(doc)
endif()

ઑનલાઇન સેન્ડબોક્સ

તેવી જ રીતે, સબપ્રોજેક્ટમાં ઓનલાઈન સેન્ડબોક્સ પણ હશે નહીં.

if(NOT IS_SUBPROJECT)
    add_subdirectory(online)
endif()

ટેસ્ટ સ્ક્રિપ્ટ (test/CMakeLists.txt)

પરીક્ષણ

સૌ પ્રથમ, અમે જરૂરી પરીક્ષણ ફ્રેમવર્ક સાથેનું પેકેજ શોધીએ છીએ (તમારા મનપસંદ સાથે બદલો).

find_package(doctest 2.3.3 REQUIRED)

ચાલો ટેસ્ટ સાથે અમારી એક્ઝેક્યુટેબલ ફાઈલ બનાવીએ. સામાન્ય રીતે હું એક્ઝેક્યુટેબલ બાઈનરીમાં સીધું જ એ ફાઈલ ઉમેરું છું જેમાં ફંક્શન હશે main.

add_executable(mylib-unit-tests test_main.cpp)

અને હું ફાઇલો ઉમેરું છું જેમાં પરીક્ષણો પોતે પછીથી વર્ણવવામાં આવે છે. પરંતુ તમારે તે કરવાની જરૂર નથી.

target_sources(mylib-unit-tests PRIVATE mylib/myfeature.cpp)

અમે નિર્ભરતાને જોડીએ છીએ. મહેરબાની કરીને નોંધ કરો કે અમે ફક્ત સીમેક લક્ષ્યોને અમારી બાઈનરી સાથે લિંક કર્યા છે અને આદેશને કૉલ કર્યો નથી target_include_directories. ટેસ્ટ ફ્રેમવર્ક અને અમારા તરફથી હેડિંગ Mylib::mylib, તેમજ બિલ્ડ પેરામીટર્સ (અમારા કિસ્સામાં, આ C++ લેંગ્વેજ સ્ટાન્ડર્ડ છે) આ ધ્યેયો સાથે આવ્યા હતા.

target_link_libraries(mylib-unit-tests
    PRIVATE
        Mylib::mylib
        doctest::doctest
)

અંતે, અમે એક ડમી લક્ષ્ય બનાવીએ છીએ, જેનું "બિલ્ડ" ચાલી રહેલ પરીક્ષણો સમાન છે, અને આ લક્ષ્યને ડિફોલ્ટ બિલ્ડમાં ઉમેરીએ છીએ (આ માટે વિશેષતા જવાબદાર છે. ALL). આનો અર્થ એ છે કે ડિફૉલ્ટ બિલ્ડ પરીક્ષણોને ચલાવવા માટે ટ્રિગર કરે છે, એટલે કે અમે તેને ચલાવવાનું ક્યારેય ભૂલીશું નહીં.

add_custom_target(check ALL COMMAND mylib-unit-tests)

કવરેજ

આગળ, જો યોગ્ય વિકલ્પ સ્પષ્ટ કરેલ હોય તો અમે કોડ કવરેજ માપન સક્ષમ કરીએ છીએ. હું વિગતોમાં જઈશ નહીં, કારણ કે તેઓ CMake કરતાં કવરેજ માપવાના સાધન સાથે વધુ સંબંધિત છે. માત્ર એ નોંધવું અગત્યનું છે કે પરિણામોના આધારે એક ધ્યેય બનાવવામાં આવશે coverage, જેની સાથે કવરેજને માપવાનું શરૂ કરવું અનુકૂળ છે.

find_program(GCOVR_EXECUTABLE gcovr)
if(MYLIB_COVERAGE AND GCOVR_EXECUTABLE)
    message(STATUS "Измерение покрытия кода тестами включено")

    target_compile_options(mylib-unit-tests PRIVATE --coverage)
    target_link_libraries(mylib-unit-tests PRIVATE gcov)

    add_custom_target(coverage
        COMMAND
            ${GCOVR_EXECUTABLE}
                --root=${PROJECT_SOURCE_DIR}/include/
                --object-directory=${CMAKE_CURRENT_BINARY_DIR}
        DEPENDS
            check
    )
elseif(MYLIB_COVERAGE AND NOT GCOVR_EXECUTABLE)
    set(MYLIB_COVERAGE OFF)
    message(WARNING "Для замеров покрытия кода тестами требуется программа gcovr")
endif()

દસ્તાવેજીકરણ માટેની સ્ક્રિપ્ટ (doc/CMakeLists.txt)

ડોક્સિજન મળ્યો.

find_package(Doxygen)

આગળ, અમે તપાસીએ છીએ કે શું વપરાશકર્તાએ ભાષા ચલ સેટ કર્યું છે. જો હા, તો અમે તેને સ્પર્શતા નથી, જો નહીં, તો અમે રશિયન ભાષા લઈએ છીએ. પછી અમે ડોક્સિજન સિસ્ટમ ફાઇલોને ગોઠવીએ છીએ. ભાષા સહિત તમામ જરૂરી ચલો, રૂપરેખાંકન પ્રક્રિયા દરમિયાન ત્યાં જાય છે (જુઓ. команду configure_file).

પછી આપણે એક ધ્યેય બનાવીએ છીએ doc, જે દસ્તાવેજીકરણ બનાવવાનું શરૂ કરશે. વિકાસ પ્રક્રિયામાં દસ્તાવેજીકરણ જનરેટ કરવું એ સૌથી મોટી જરૂરિયાત ન હોવાથી, લક્ષ્ય મૂળભૂત રીતે સક્ષમ કરવામાં આવશે નહીં; તેને સ્પષ્ટ રીતે શરૂ કરવું પડશે.

if (Doxygen_FOUND)
    if (NOT MYLIB_DOXYGEN_LANGUAGE)
        set(MYLIB_DOXYGEN_LANGUAGE Russian)
    endif()
    message(STATUS "Doxygen documentation will be generated in ${MYLIB_DOXYGEN_LANGUAGE}")
    configure_file(Doxyfile.in Doxyfile)
    add_custom_target(doc COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
endif ()

ઑનલાઇન સેન્ડબોક્સ માટે સ્ક્રિપ્ટ (online/CMakeLists.txt)

અહીં આપણે ત્રીજો પાયથોન શોધીએ છીએ અને લક્ષ્ય બનાવીએ છીએ wandbox, જે સેવા API ને અનુરૂપ વિનંતી જનરેટ કરે છે વાન્ડબોક્સ, અને તેને દૂર મોકલે છે. પ્રતિસાદ ફિનિશ્ડ સેન્ડબોક્સની લિંક સાથે આવે છે.

find_program(PYTHON3_EXECUTABLE python3)
if(PYTHON3_EXECUTABLE)
    set(WANDBOX_URL "https://wandbox.org/api/compile.json")

    add_custom_target(wandbox
        COMMAND
            ${PYTHON3_EXECUTABLE} wandbox.py mylib-example.cpp "${PROJECT_SOURCE_DIR}" include |
            curl -H "Content-type: application/json" -d @- ${WANDBOX_URL}
        WORKING_DIRECTORY
            ${CMAKE_CURRENT_SOURCE_DIR}
        DEPENDS
            mylib-unit-tests
    )
else()
    message(WARNING "Для создания онлайн-песочницы требуется интерпретатор ЯП python 3-й версии")
endif()

બહાર પ્રોજેક્ટ

હવે આ બધાનો ઉપયોગ કેવી રીતે કરવો તે જોઈએ.

વિધાનસભા

સીમેક બિલ્ડ સિસ્ટમ પરના કોઈપણ અન્ય પ્રોજેક્ટની જેમ આ પ્રોજેક્ટનું નિર્માણ, બે તબક્કાઓનો સમાવેશ કરે છે:

પેrationી

cmake -S путь/к/исходникам -B путь/к/сборочной/директории [опции ...]

જો ઉપરોક્ત આદેશ સીમેકના જૂના સંસ્કરણને કારણે કામ કરતું નથી, તો અવગણવાનો પ્રયાસ કરો -S:

cmake путь/к/исходникам -B путь/к/сборочной/директории [опции ...]

વિકલ્પો વિશે વધુ.

પ્રોજેક્ટનું નિર્માણ

cmake --build путь/к/сборочной/директории [--target target]

એસેમ્બલી લક્ષ્યો વિશે વધુ.

વિકલ્પો

MYLIB_COVERAGE

cmake -S ... -B ... -DMYLIB_COVERAGE=ON [прочие опции ...]

લક્ષ્યનો સમાવેશ થાય છે coverage, જેની સાથે તમે પરીક્ષણો દ્વારા કોડ કવરેજને માપવાનું શરૂ કરી શકો છો.

MYLIB_TESTING

cmake -S ... -B ... -DMYLIB_TESTING=OFF [прочие опции ...]

યુનિટ ટેસ્ટ બિલ્ડ અને લક્ષ્યને અક્ષમ કરવાની ક્ષમતા પ્રદાન કરે છે check. પરિણામે, પરીક્ષણો દ્વારા કોડ કવરેજનું માપન બંધ છે (જુઓ. MYLIB_COVERAGE).

જો પ્રોજેક્ટ આદેશનો ઉપયોગ કરીને સબપ્રોજેક્ટ તરીકે બીજા પ્રોજેક્ટ સાથે જોડાયેલ હોય તો પરીક્ષણ પણ આપમેળે અક્ષમ થઈ જાય છે add_subdirectory.

MYLIB_DOXYGEN_LANGUAGE

cmake -S ... -B ... -DMYLIB_DOXYGEN_LANGUAGE=English [прочие опции ...]

લક્ષ્ય જનરેટ કરે છે તે દસ્તાવેજોની ભાષાને સ્વિચ કરે છે doc આપેલને. ઉપલબ્ધ ભાષાઓની સૂચિ માટે, જુઓ ડોક્સિજન સિસ્ટમ વેબસાઇટ.

રશિયન મૂળભૂત રીતે સક્ષમ છે.

એસેમ્બલી લક્ષ્યો

મૂળભૂત રીતે

cmake --build path/to/build/directory
cmake --build path/to/build/directory --target all

જો લક્ષ્ય નિર્દિષ્ટ ન હોય (જે લક્ષ્યની સમકક્ષ છે all), તે જે કરી શકે તે બધું એકત્રિત કરે છે, અને લક્ષ્યને પણ કૉલ કરે છે check.

mylib-યુનિટ-પરીક્ષણો

cmake --build path/to/build/directory --target mylib-unit-tests

એકમ પરીક્ષણો કમ્પાઇલ કરે છે. ડિફૉલ્ટ રૂપે સક્ષમ.

તપાસો

cmake --build путь/к/сборочной/директории --target check

એકત્રિત કરેલ (એકત્ર કરેલ, જો પહેલાથી ન હોય તો) એકમ પરીક્ષણો ચલાવે છે. ડિફૉલ્ટ રૂપે સક્ષમ.

આ પણ જુઓ mylib-unit-tests.

કવરેજ

cmake --build путь/к/сборочной/директории --target coverage

પ્રોગ્રામનો ઉપયોગ કરીને પરીક્ષણો દ્વારા કોડ કવરેજ માટે ચાલતા (રન, જો પહેલાથી ન હોય તો) યુનિટ પરીક્ષણોનું વિશ્લેષણ કરે છે gcovr.

કોટિંગ એક્ઝોસ્ટ કંઈક આના જેવો દેખાશે:

------------------------------------------------------------------------------
                           GCC Code Coverage Report
Directory: /path/to/cmakecpptemplate/include/
------------------------------------------------------------------------------
File                                       Lines    Exec  Cover   Missing
------------------------------------------------------------------------------
mylib/myfeature.hpp                            2       2   100%   
------------------------------------------------------------------------------
TOTAL                                          2       2   100%
------------------------------------------------------------------------------

જ્યારે વિકલ્પ સક્ષમ હોય ત્યારે જ લક્ષ્ય ઉપલબ્ધ થાય છે MYLIB_COVERAGE.

આ પણ જુઓ check.

ડૉક

cmake --build путь/к/сборочной/директории --target doc

સિસ્ટમનો ઉપયોગ કરીને કોડ દસ્તાવેજીકરણ બનાવવાનું શરૂ કરે છે ડોક્સિજન.

વેન્ડબોક્સ

cmake --build путь/к/сборочной/директории --target wandbox

સેવા તરફથી પ્રતિસાદ કંઈક આના જેવો દેખાય છે:

{
    "permlink" :    "QElvxuMzHgL9fqci",
    "status" :  "0",
    "url" : "https://wandbox.org/permlink/QElvxuMzHgL9fqci"
}

આ માટે સેવાનો ઉપયોગ કરવામાં આવે છે વાન્ડબોક્સ. મને ખબર નથી કે તેમના સર્વર કેટલા લવચીક છે, પરંતુ મને લાગે છે કે આ તકનો દુરુપયોગ થવો જોઈએ નહીં.

ઉદાહરણો

કવરેજ માપન સાથે ડીબગ મોડમાં પ્રોજેક્ટ બનાવો

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug -DMYLIB_COVERAGE=ON
cmake --build путь/к/сборочной/директории --target coverage --parallel 16

પ્રારંભિક એસેમ્બલી અને પરીક્ષણ વિના પ્રોજેક્ટ ઇન્સ્ટોલ કરવું

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DMYLIB_TESTING=OFF -DCMAKE_INSTALL_PREFIX=путь/к/установойной/директории
cmake --build путь/к/сборочной/директории --target install

આપેલ કમ્પાઇલર સાથે રિલીઝ મોડમાં બનાવો

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=g++-8 -DCMAKE_PREFIX_PATH=путь/к/директории/куда/установлены/зависимости
cmake --build путь/к/сборочной/директории --parallel 4

અંગ્રેજીમાં દસ્તાવેજીકરણ જનરેટ કરવું

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Release -DMYLIB_DOXYGEN_LANGUAGE=English
cmake --build путь/к/сборочной/директории --target doc

સાધનો

1. સી.એમ.કે. 3.13

   વાસ્તવમાં, CMake સંસ્કરણ 3.13 માત્ર આ મદદમાં વર્ણવેલ કેટલાક કન્સોલ આદેશોને ચલાવવા માટે જરૂરી છે. સીમેક સ્ક્રિપ્ટ્સના વાક્યરચનાનાં દૃષ્ટિકોણથી, જો જનરેશનને અન્ય રીતે બોલાવવામાં આવે તો આવૃત્તિ 3.8 પર્યાપ્ત છે.

2. પરીક્ષણ પુસ્તકાલય doctest

   પરીક્ષણ અક્ષમ કરી શકાય છે (જુઓ опцию MYLIB_TESTING).

3. ડોક્સિજન

   જે ભાષામાં દસ્તાવેજીકરણ જનરેટ કરવામાં આવશે તેને બદલવા માટે, એક વિકલ્પ આપવામાં આવે છે MYLIB_DOXYGEN_LANGUAGE.

4. ભાષા દુભાષિયા પાયથોન 3

   આપોઆપ જનરેશન માટે ઑનલાઇન સેન્ડબોક્સ.

સ્થિર વિશ્લેષણ

CMake અને કેટલાક સારા સાધનો સાથે, તમે ન્યૂનતમ પ્રયત્નો સાથે સ્થિર વિશ્લેષણ પ્રદાન કરી શકો છો.

સીપીપીચેક

CMake પાસે સ્ટેટિક એનાલિસિસ ટૂલ માટે બિલ્ટ-ઇન સપોર્ટ છે સીપીપીચેક.

આ કરવા માટે તમારે વિકલ્પનો ઉપયોગ કરવાની જરૂર છે CMAKE_CXX_CPPCHECK:

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_CPPCHECK="cppcheck;--enable=all;-Iпуть/к/исходникам/include"

આ પછી, જ્યારે પણ સ્ત્રોતનું સંકલન અને પુનઃસંકલન કરવામાં આવે ત્યારે સ્થિર વિશ્લેષણ આપમેળે શરૂ થશે. વધારાનું કંઈ કરવાની જરૂર નથી.

રણકાર

એક અદ્ભુત સાધનની મદદથી scan-build તમે ઓછા સમયમાં સ્થિર વિશ્લેષણ પણ ચલાવી શકો છો:

scan-build cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug
scan-build cmake --build путь/к/сборочной/директории

અહીં, Cppcheck સાથેના કેસથી વિપરીત, તમારે દર વખતે બિલ્ડ ચલાવવાની જરૂર છે scan-build.

ઉચ્ચારણ

CMake એક ખૂબ જ શક્તિશાળી અને લવચીક સિસ્ટમ છે જે તમને દરેક સ્વાદ અને રંગ માટે કાર્યક્ષમતા અમલમાં મૂકવાની મંજૂરી આપે છે. અને, જો કે વાક્યરચના ક્યારેક ઇચ્છિત થવા માટે ઘણું છોડી દે છે, શેતાન હજુ પણ તેટલો ભયંકર નથી જેટલો તેને દોરવામાં આવ્યો છે. સમાજ અને આરોગ્યના લાભ માટે સીમેક બિલ્ડ સિસ્ટમનો ઉપયોગ કરો.

→ પ્રોજેક્ટ ટેમ્પલેટ ડાઉનલોડ કરો

સોર્સ: www.habr.com