परिचय

CMake , C / C ++ में प्रोजेक्ट पैकेजों के परीक्षण, संकलन और निर्माण को स्वचालित करने के लिए डिज़ाइन की गई उपयोगिताओं का एक खुला और क्रॉस-प्लेटफ़ॉर्म सेट है। एक बार एक छोटी सी स्क्रिप्ट लिखकर जिसे हर कोई समझता है, आप अपनी परियोजना के उसी निर्माण को किसी भी मंच पर सुनिश्चित करेंगे जहां सीएमके उपलब्ध है।

CMake भाषा , एक मूल विधानसभा फ़ाइल (उदाहरण के लिए, मेकफाइल या निंजा) में अनुवादित की जा रही है, सभी परियोजना प्रबंधन की प्रक्रिया को परिभाषित करती है। आपके निपटान में, कार्यात्मक पक्ष पर, केवल ऐसी टीम हैं जो काफी जटिल संरचनाओं में बनाई जा सकती हैं। हम उनके साथ शुरू करेंगे।

सीएमके लॉन्च

निम्नलिखित सीमेक भाषा का उपयोग करने के उदाहरण हैं जिनका आपको अभ्यास करना चाहिए। मौजूदा आदेशों को संशोधित करके और नए जोड़कर स्रोत कोड के साथ प्रयोग करें। इन उदाहरणों को चलाने के लिए, आधिकारिक वेबसाइट से CMake इंस्टॉल करें ।

आदेशों

CMake में कमांड कई प्रोग्रामिंग भाषाओं में फ़ंक्शन के समान हैं। कमांड को कॉल करने के लिए, आपको उसका नाम लिखना होगा, और फिर इसे कोष्ठकों में संलग्न तर्क पास करना होगा, रिक्त स्थान द्वारा अलग किया जाएगा। उपरोक्त उदाहरण में, कंसोल के आउटपुट के लिए message कमांड में छह तर्क दिए गए हैं:

 #    "CMake is the most powerful buildsystem!" message("CMake " "is " "the " "most " "powerful " "buildsystem!") 

बहस

दोहरे उद्धरण चिह्नों में तैयार किए गए तर्क आपको अपने अंदर के चर से बचने और बदलने की अनुमति देते हैं। अनधिकृत तर्क ऐसी चीजों के उत्पादन की अनुमति नहीं देते हैं और इसमें वर्ण ()#"\ और रिक्त स्थान शामिल नहीं हो सकते हैं, लेकिन उपयोग करने के लिए अधिक सुविधाजनक हैं। उदाहरण:

 #  "Hello, my lovely CMake",    "!": message("Hello, my lovely CMake\t!") #  "Hello,_my_lovely_CMake!"  : message(Hello,_my_lovely_CMake!) 

यह ध्यान देने योग्य है कि तर्क Walk;around;the;forest का विस्तार सूची में होगा Walk;around;the;forest Walk around the forest , क्योंकि कोई भी अपरिचित तर्क स्वचालित रूप से मूल्यों की सूची में फैल जाता है (बशर्ते कि मूल तर्क के मूल्य अर्धविराम से अलग हो जाते हैं), लेकिन एक डबल के साथ एक तर्क के रूप में उद्धरण चिह्नों में ऐसा परिवर्तन नहीं होता है (अर्धविराम वर्ण केवल गायब हो जाते हैं)। टिप्पणियों में इस विशेषता का उल्लेख किया गया था।

टिप्पणियाँ

टिप्पणियां पाउंड के संकेत के साथ शुरू होती हैं और उस पंक्ति के अंत में समाप्त होती हैं जहां वे मुद्रित किए गए थे। टिप्पणियों में निहित पाठ को बिल्ड सिस्टम द्वारा अनदेखा किया जाता है और इसके संचालन पर कोई प्रभाव नहीं पड़ता है। ऊपर दिए गए उदाहरण भी टिप्पणियों के उपयोग को प्रदर्शित करते हैं।

चर

वेरिएबल्स को set कमांड को कॉल करके परिभाषित किया जा सकता है, और unset कॉल करके हटाया जा सकता है। आप ${VARIABLE} निर्माण करके एक चर का मूल्य प्राप्त कर सकते हैं। यदि चर को अभी तक परिभाषित नहीं किया गया है और कहीं इसका मूल्य प्राप्त करना आवश्यक है, तो यह चर एक खाली स्ट्रिंग में बदल जाएगा। एक उदाहरण:

 #   VARIABLE   "Mr. Thomas": set(VARIABLE "Mr. Thomas") #  "His name is: Mr. Thomas": message("His name is: " ${VARIABLE}) #  "'BINGO' is equal to: []",   "BINGO"  : message("'BINGO' is equal to: [${BINGO}]") #   VARIABLE: unset(VARIABLE) 

विकल्प

CMake सेटिंग विकल्पों का समर्थन करता है जो उपयोगकर्ता संशोधनों के अधीन हैं। विकल्प चर के समान होते हैं और option कमांड द्वारा सेट किए जाते हैं, जिसमें केवल तीन तर्क होते हैं: चर का नाम, चर का स्ट्रिंग विवरण और चर का डिफ़ॉल्ट मान ( ON या OFF ):

 #   `USE_ANOTHER_LIBRARY`   # "Do you want to use an another library?"   "OFF": option(USE_ANOTHER_LIBRARY "Do you want to use an another library?" OFF) 

तार्किक भाव

सशर्त ऑपरेटरों और चक्रीय निर्माणों के अध्ययन के साथ आगे बढ़ने से पहले, तार्किक अभिव्यक्तियों के काम को समझना आवश्यक है। तार्किक अभिव्यक्तियों का उपयोग स्थितियों की जाँच करते समय किया जाता है और दो में से एक मान ले सकते हैं: सही या गलत। उदाहरण के लिए, 52 <58 के बाद से अभिव्यक्ति 52 LESS 58 सही होगी। अभिव्यक्ति 88 EQUAL 88 सत्य होगी, 63 GREATER 104 गलत होगी। आप न केवल संख्या की तुलना कर सकते हैं, बल्कि तार, संस्करण, फाइलें, सूची सदस्यता और नियमित अभिव्यक्ति भी कर सकते हैं। तार्किक अभिव्यक्तियों की एक पूरी सूची यहां पाई जा सकती है ।

सशर्त बयान

CMake में सशर्त संचालक अन्य प्रोग्रामिंग भाषाओं की तरह ही काम करते हैं। इस उदाहरण में, केवल पहला सशर्त ऑपरेटर काम करेगा, जो यह जांचता है कि 5> 1. दूसरी और तीसरी स्थिति झूठी हैं, क्योंकि 5 एक से कम या उसके बराबर नहीं हो सकता है। else कमांड कमांड ब्लॉक वैकल्पिक हैं, और endif आवश्यक है और पिछले चेक के पूरा होने का संकेत देता है।

 #  "Of course, 5 > 1!": if(5 GREATER 1) message("Of course, 5 > 1!") elseif(5 LESS 1) message("Oh no, 5 < 1!") else() message("Oh my god, 5 == 1!") endif() 

चक्र

CMake में लूप्स अन्य प्रोग्रामिंग भाषाओं में लूप के समान हैं। उपरोक्त उदाहरण में, VARIABLE चर को Airport सेट किया गया है, और तब चार नेस्टेड कमांड क्रमिक रूप से निष्पादित किए जाते हैं जब तक कि VARIABLE चर Airport बराबर नहीं होता। अंतिम चौथा set(VARIABLE "Police station") कमांड set(VARIABLE "Police station") में चेक किए गए चर का मान सेट करता है, इसलिए दूसरी पुनरावृत्ति पर पहुंचने से पहले लूप तुरंत बंद हो जाएगा। endwhile आदेश लूप में नेस्टेड कमांड की सूची के पूरा होने का संकेत देता है।

 #      "VARIABLE is still 'Airport'": set(VARIABLE Airport) while(${VARIABLE} STREQUAL Airport) message("VARIABLE is still '${VARIABLE}'") message("VARIABLE is still '${VARIABLE}'") message("VARIABLE is still '${VARIABLE}'") set(VARIABLE "Police station") endwhile() 

यह उदाहरण foreach निम्नानुसार काम करता है: इस लूप के प्रत्येक पुनरावृत्ति पर, VARIABLE वैरिएबल को सूची से निम्न मान असाइन किया गया है Give me the sugar please! और फिर message(${VARIABLE}) कमांड निष्पादित किया जाता है, जो VARIABLE वैरिएबल के वर्तमान मूल्य को प्रदर्शित करता है। जब सूची में कोई मूल्य नहीं होते हैं, तो लूप इसका निष्पादन समाप्त कर देता है। endforeach कमांड लूप में नेस्टेड कमांड की सूची को पूरा करने का संकेत देता है।

 #  "Give me the sugar please!"   : foreach(VARIABLE Give me the sugar please!) message(${VARIABLE}) endforeach() 

foreach लिखने के 3 और रूप हैं। इस उदाहरण में पहला चक्र सूची के स्थान पर 0 से 10 तक पूर्णांक बनाता है, दूसरा चक्र 3 से 15 तक की सीमा में उत्पन्न होता है, और तीसरा चक्र 50 से 90 तक के खंड में काम करता है, लेकिन 10 के एक चरण के साथ।

 #  "0 1 2 3 4 5 6 7 8 9 10"   : foreach(VARIABLE RANGE 10) message(${VARIABLE}) endforeach() #  "3 4 5 6 7 8 9 10 11 12 13 14 15"   : foreach(VARIABLE RANGE 3 15) message(${VARIABLE}) endforeach() #  "50 60 70 80 90"   : foreach(VARIABLE RANGE 50 90 10) message(${VARIABLE}) endforeach() 

कार्य और मैक्रोज़

CMake सिंटैक्स आपको अपने स्वयं के आदेशों को परिभाषित करने की अनुमति देता है जिन्हें बिल्कुल अंतर्निहित कहा जा सकता है। निम्न उदाहरण कार्यों और मैक्रोज़ के उपयोग को प्रदर्शित करता है: पहला, एक फ़ंक्शन और एक मैक्रो को अपने स्वयं के आदेशों के साथ परिभाषित किया जाता है, और जब बुलाया जाता है, तो उनके आदेशों को क्रमिक रूप से निष्पादित किया जाता है।

 #   "print_numbers": function(print_numbers NUM1 NUM2 NUM3) message(${NUM1} " " ${NUM2} " " ${NUM3}) endfunction() #   "print_words": macro(print_words WORD1 WORD2 WORD3) message(${WORD1} " " ${WORD2} " " ${WORD3}) endmacro() #   "print_numbers",   "12 89 225": print_numbers(12 89 225) #   "print_words",   "Hey Hello Goodbye": print_words(Hey Hello Goodbye) 

function कमांड भविष्य के फ़ंक्शन का नाम पहले तर्क के रूप में लेता है, और बाकी तर्क उन मापदंडों के नाम हैं जिनका उपयोग सामान्य चर के रूप में किया जा सकता है। पैरामीटर केवल फ़ंक्शन को परिभाषित किए जाने के लिए दिखाई देते हैं, जिसका अर्थ है कि हम फ़ंक्शन के बाहर इसके मापदंडों तक पहुंच प्राप्त नहीं कर सकते हैं। इसके अलावा, फ़ंक्शन के भीतर परिभाषित और पुनर्परिभाषित अन्य सभी चर केवल स्वयं के लिए दिखाई देते हैं।

मैक्रोज़ इस अपवाद के कार्यों के समान हैं कि उनके पास अपना स्वयं का दायरा नहीं है: मैक्रोज़ के अंदर के सभी चर वैश्विक माने जाते हैं। आप मैक्रोज़ और फ़ंक्शंस के बीच अंतर के बारे में अधिक पढ़ सकते हैं।

जैसा कि टिप्पणियों में कहा गया है, सीएमके में मैक्रोज़ सी प्रीप्रोसेसर में मैक्रोज़ के समान हैं: यदि आप मैक्रो बॉडी में return कमांड डालते हैं, तो आप कॉलिंग फ़ंक्शन (या पूरी स्क्रिप्ट) से बाहर निकल जाएंगे, क्योंकि यह उदाहरण प्रदर्शित करता है:

 #  ,   : macro(demonstrate_macro) return() endmacro() #  ,   : function(demonstrate_func) demonstrate_macro() message("The function was invoked!") endfunction() #  "Something happened with the function!" demonstrate_func() message("Something happened with the function!") 

उपरोक्त उदाहरण में, demonstrate_func फ़ंक्शन के पास संदेश प्रिंट करने का समय नहीं होगा The function was invoked! , पहले की तरह, मैक्रो demonstrate_macro को कॉल करने के स्थान को प्रतिस्थापित demonstrate_macro जाएगा और निकास आदेश निष्पादित किया जाएगा।

पार्सिंग तर्क

जैसा कि टिप्पणियों में कहा गया है, शक्तिशाली cmake_parse_arguments तंत्र एक फ़ंक्शन या मैक्रो को दिए गए पार्स तर्कों को अनुमति देता है।

यह कमांड चर की परिभाषा में उपयोग किए गए उपसर्ग को स्वीकार करता है (अगला पैराग्राफ देखें), बाद के मूल्यों के बिना उपयोग किए गए विकल्पों की एक सूची, एक मूल्य के बाद कीवर्ड की एक सूची, मूल्यों की सेट के बाद कीवर्ड की एक सूची और फ़ंक्शन के लिए पारित सभी मूल्यों की एक सूची। या मैक्रो।

तर्क पार्सिंग तंत्र का काम प्राप्त तर्कों को चर मानों में बदलना है। इस प्रकार, प्रत्येक विकल्प और कीवर्ड के लिए माना जाने वाला कमांड फॉर्म के अपने स्वयं के चर को परिभाषित करता है <Prefix>_<OptionOrKeyword> , जो एक निश्चित मान को <Prefix>_<OptionOrKeyword> करता है। विकल्पों के लिए, ये बूलियन मान हैं (सत्य - विकल्प इंगित किया गया है; अन्यथा, गलत), और कीवर्ड के लिए, उनके बाद स्थित सभी स्थानांतरित मूल्य।

cmake_parse_arguments फ़ंक्शन में cmake_parse_arguments लिए एक कॉल होता है, और फिर कुछ चर के मूल्यों को प्रिंट करता है। इसके बाद, फ़ंक्शन को तर्कों के साथ बुलाया जाता है LOW NUMBER 30 COLORS red green blue , जिसके बाद इसे स्क्रीन पर मुद्रित किया जाता है:

 function(custom_function) #       : cmake_parse_arguments(CUSTOM_FUNCTION "LOW;HIGH" "NUMBER" "COLORS" ${ARGV}) #  "'LOW' = [TRUE]": message("'LOW' = [${CUSTOM_FUNCTION_LOW}]") # "'HIGH' = [FALSE]": message("'HIGH' = [${CUSTOM_FUNCTION_HIGH}]") #  "'NUMBER' = [30]": message("'NUMBER' = [${CUSTOM_FUNCTION_NUMBER}]") #  "'COLORS' = [red;green;blue]": message("'COLORS' = [${CUSTOM_FUNCTION_COLORS}]") endfunction() #   "custom_function"   : custom_function(LOW NUMBER 30 COLORS red green blue) 

स्कोप

पिछले अनुभाग में, आपने सीखा कि सीएमके में कुछ निर्माण अपने स्वयं के दायरे को परिभाषित कर सकते हैं। वास्तव में, सभी चर को डिफ़ॉल्ट रूप से वैश्विक माना जाता है (उन तक पहुंच हर जगह है), उन लोगों के अपवाद के साथ जो कार्यों में परिभाषित और पुन: परिभाषित किए गए हैं। कैश चर भी हैं जिनका अपना दायरा है, लेकिन वे अक्सर उपयोग नहीं किए जाते हैं।

जैसा कि टिप्पणियों में उल्लेख किया गया है, चर को set(VARIABLE ... PARENT_SCOPE) कमांड set(VARIABLE ... PARENT_SCOPE) का उपयोग करके "मूल" दायरे में परिभाषित किया जा सकता है। यह उदाहरण इस विशेषता को प्रदर्शित करता है:

 # ,   "VARIABLE"   # "In the parent scope..."    : function(demonstrate_variable) set(VARIABLE "In the parent scope..." PARENT_SCOPE) endfunction() #   "VARIABLE"    : demonstrate_variable() #      "VARIABLE" : message("'VARIABLE' is equal to: ${VARIABLE}") 

यदि PARENT_SCOPE VARIABLE वैरिएबल की परिभाषा से हटा दिया PARENT_SCOPE है, तो वैरिएबल केवल PARENT_SCOPE फ़ंक्शन के लिए सुलभ होगा, और वैश्विक स्कोप में यह एक खाली मान लेगा।

निष्कर्ष

यह CMake सिंटैक्स को समाप्त करता है। अगला लेख लगभग एक दो दिनों में जारी किया जाएगा और सीएमके बिल्ड सिस्टम के उपयोग को पेश करेगा। जल्द मिलते हैं!