ChaiScript - C ++ के लिए स्क्रिप्टिंग भाषा

जब C ++ प्रोजेक्ट में स्क्रिप्टिंग भाषा को एम्बेड करने की आवश्यकता होती है, तो सबसे पहली बात जो लोग याद करते हैं वह है Lua। इस लेख में यह नहीं होगा, मैं दूसरे के बारे में बात करूंगा, कोई भी कम सुविधाजनक और आसान भाषा सीखने के लिए नहीं है जिसे चायस्क्रिप्ट कहा जाता है।

संक्षिप्त परिचय

जब मैंने जेसन टर्नर के व्याख्यान में से एक भाषा के रचनाकारों को देखा तो मैंने संयोग से चाईस्क्रिप्ट पर ठोकर खाई। इसने मुझे दिलचस्पी दी, और उस क्षण जब इस परियोजना में एक स्क्रिप्टिंग भाषा का चयन करना आवश्यक था, मैंने फैसला किया - क्यों नहीं ChaiScript की कोशिश की? परिणाम ने मुझे आश्चर्यचकित कर दिया (मेरा व्यक्तिगत अनुभव लेख के अंत के करीब लिखा जाएगा), हालांकि, कोई बात नहीं कितनी अजीब लग सकती है, हब पर एक भी लेख नहीं था जिसने इस भाषा का कम से कम किसी भी तरह से उल्लेख किया, और मैंने फैसला किया कि उसके बारे में लिखना अच्छा होगा। बेशक, भाषा में प्रलेखन और एक आधिकारिक साइट है , लेकिन हर कोई इसे टिप्पणियों से नहीं पढ़ेगा, और लेख का प्रारूप कई (मेरे सहित) के करीब है।

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

• चियास्क्रिप्ट सिंटेक्स
• C ++ में कार्यान्वयन
• व्यक्तिगत अनुभव

भाषा वाक्य रचना

ChaiScript अपने सिंटैक्स में C ++ और JS के समान है। सबसे पहले, यह, स्क्रिप्टिंग भाषाओं के विशाल बहुमत की तरह, गतिशील रूप से टाइप किया जाता है, हालांकि, जावास्क्रिप्ट के विपरीत, इसमें सख्त टंकण (कोई 1 + "2" ) नहीं है। एक अंतर्निहित कचरा कलेक्टर भी है, भाषा पूरी तरह से व्याख्या योग्य है, जो आपको बायटेकोड में संकलन के बिना, लाइन द्वारा कोड लाइन निष्पादित करने की अनुमति देता है। इसमें अपवादों के लिए समर्थन है (अतिरिक्त, संयुक्त, आपको स्क्रिप्ट के अंदर और सी ++ में दोनों को पकड़ने की अनुमति देता है), लैम्ब्डा फ़ंक्शन, ऑपरेटर ओवरलोडिंग। यह रिक्त स्थान के प्रति संवेदनशील नहीं है, जो आपको अर्धविराम के माध्यम से एक पंक्ति के रूप में लिखने की अनुमति देता है, या अजगर शैली में, एक नई पंक्ति के साथ अभिव्यक्ति को अलग करता है।

आदिम प्रकार

डिफ़ॉल्ट रूप से पूर्णांक स्टोरेज वैरिएबल के द्वारा ChaiScript इंट, डबल के रूप में वास्तविक, और std :: string के साथ स्ट्रिंग्स। यह कॉलिंग कोड के साथ संगतता सुनिश्चित करने के लिए मुख्य रूप से किया जाता है। भाषा में संख्याओं के लिए प्रत्यय भी होता है, ताकि हम स्पष्ट रूप से संकेत कर सकें कि हमारा चर किस प्रकार का है:

 /*   chaiscript    js    ,  var / auto `;`      */ var myInt = 1 // int var myLongLong = 1ll // long long int var myFloating = 3.3 // double var myBoolean = false // bool var myString = "hello world!\n" // std::string 

चर के प्रकार को बदलने से काम नहीं चलता, सबसे अधिक संभावना है कि आपको इन प्रकारों के लिए अपने स्वयं के `=` ऑपरेटर को परिभाषित करने की आवश्यकता होगी, अन्यथा आप या तो एक अपवाद को फेंकने का जोखिम चलाते हैं (हम इस बारे में बाद में बात करेंगे) या इस तरह चक्कर का शिकार हो सकते हैं:

 var integer = 3 integer = 5.433 print(integer) //  5    double    int! integer = true //   -   `=`  (int, bool) 

हालाँकि, आप किसी मान को बताए बिना एक वैरिएबल की घोषणा कर सकते हैं, उस स्थिति में जब तक इसे एक मान निर्दिष्ट नहीं किया जाता है, तब तक यह अपरिभाषित रहेगा।

इनलाइन कंटेनर

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

 var v = [ 1, 2, 3u, 4ll, "16", `+` ] //      var m = [ "key1" : 1, "key2": "Bob" ]; //    - var M = Map() //    var V = Vector() //    //        C++ : v.push_back(123) //    ,     v.push_back_ref(m); // m -   //      m["key"] = 3 //       (reference assignment): m["key"] := m //       

ये दोनों वर्ग लगभग पूरी तरह से पुनरावृत्तियों के साथ C ++ में अपने समकक्षों को दोहराते हैं, क्योंकि उनके बजाय विशेष कक्षाएं हैं रेंज और कॉन्स्ट_रंगे। वैसे, सभी कंटेनरों को संदर्भ द्वारा पास किया जाता है, भले ही आप = के माध्यम से असाइनमेंट का उपयोग करें, जो मेरे लिए बहुत ही अजीब है, क्योंकि मूल्य के आधार पर अन्य सभी प्रकार की नकल के लिए।

सशर्त निर्माण

शर्तों और चक्रों के लगभग सभी निर्माणों का शाब्दिक रूप से एक उदाहरण कोड में वर्णन किया जा सकता है:

 var a = 5 var b = -1 //  if-else if (a > b) { print("a > b") } else if (a == b){ print("a == b") } else { print("a < b") } // switch -    if- //      //  break    ,    C++ var str = "hello" switch(str) { case("hi") { print("hi!"); break; } case("hello") { print("hello!" break; } case("bye") { print("bye-bye!") break; } default { print("what have you said?") } } var x = true //     ,       while (x) { print("x was true") x = false; } //    C.        ,    ,    ,    for (var i = 0; i < 10; ++i) //   -,    { print(i); //  0 ... 9  10  } // ranged-for loop for(element : [1, 2, 3, 4, 5]) { puts(element) //   12345 } //  :   C++17 if-init statements: if(var x = get_value(); x < 10) { print(x) // x     if } 

मुझे लगता है कि C ++ के परिचित लोगों को कुछ भी नया नहीं मिला। यह आश्चर्य की बात नहीं है, क्योंकि ChaiScript सीखने के लिए "शिक्षार्थियों" के लिए एक आसान भाषा के रूप में तैनात है, और इसलिए सभी प्रसिद्ध शास्त्रीय डिजाइनों को उधार लेता है। यदि आप वास्तव में ऑटो के साथ प्लसस पसंद करते हैं, तो लेखकों ने चर - var और auto घोषित करने के लिए दो कीवर्ड को उजागर करने का निर्णय लिया।

निष्पादन का संदर्भ

ChaiScript का एक स्थानीय और वैश्विक संदर्भ है। कोड को लाइन से ऊपर से नीचे की रेखा से निष्पादित किया जाता है, हालांकि इसे कार्यों में निकाला जा सकता है और बाद में बुलाया जा सकता है (लेकिन पहले नहीं)। फ़ंक्शंस या शर्तों / लूप्स के अंदर घोषित चर बाहर से डिफ़ॉल्ट रूप से दिखाई नहीं देते हैं, लेकिन आप var बजाय global पहचानकर्ता का उपयोग करके इस व्यवहार को बदल सकते हैं। वैश्विक चर सामान्य लोगों से भिन्न होते हैं, सबसे पहले, वे स्थानीय संदर्भ के बाहर दिखाई देते हैं, और दूसरी बात, उन्हें फिर से घोषित किया जा सकता है (यदि पुन: घोषणा के दौरान मूल्य निर्धारित नहीं किया जाता है, तो यह वही रहता है)

 //     chaiscript def foo(x) { global G = 2 print(x) } foo(0) //  foo(x), G = 2 print(G) //  2 global G = 3 //  G = 3,   global -  ! 

वैसे, यदि आपके पास एक चर है, और आपको यह जांचने की आवश्यकता है कि क्या यह एक मान असाइन किया गया है, तो is_var_undef अंतर्निहित फ़ंक्शन का उपयोग करें, जो कि चर अपरिभाषित होने पर सच हो जाता है।

स्ट्रिंग इंटरपोलेशन

आधार ऑब्जेक्ट या उपयोगकर्ता ऑब्जेक्ट जिनके पास एक to_string() विधि to_string() , को ${object} सिंटैक्स का उपयोग करके स्ट्रिंग में डाला जा सकता है। यह अनावश्यक स्ट्रिंग संघनन से बचा जाता है और आम तौर पर बहुत अधिक सख्त दिखता है:

 var x = 3 var y = 4 //  sum of 3 + 4 = 7 print("sum of ${x} + ${y} = ${x + y}") 

वेक्टर, मैप, मैपपेयर और सभी प्राइमिटिव भी इस सुविधा का समर्थन करते हैं। वेक्टर को [o1, o2, ...] , मानचित्र में [<key1, val1>, <key2, val2>, ...] , और MapPair: <key, val> ।

कार्य और उनकी बारीकियाँ

ChaiScript फ़ंक्शंस हर चीज़ की तरह ऑब्जेक्ट हैं। उन्हें पकड़ा जा सकता है, चर को सौंपा जा सकता है, अन्य कार्यों में नेस्टेड बनाया जा सकता है, और एक तर्क के रूप में पारित किया जा सकता है। इसके अलावा, आप इनपुट मानों के प्रकार को निर्दिष्ट कर सकते हैं (जो कि गतिशील रूप से टाइप की गई भाषाओं की कमी है!), इसके लिए आपको फ़ंक्शन पैरामीटर घोषित करने से पहले टाइप निर्दिष्ट करना होगा। यदि कहा जाता है, तो पैरामीटर को निर्दिष्ट एक में बदला जा सकता है, फिर सी ++ नियमों के अनुसार रूपांतरण होगा, अन्यथा एक अपवाद फेंक दिया जाएगा:

 def adder(int x, int y) { return x + y } def adder(bool x, bool y) { return x || y } adder(1, 2) // ,  3 adder(1.22, -3.7) // ,  1 + (-3) = 2 adder(true, true) // ,  true adder(true, 3) // ,    adder(bool, int) 

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

 def div(x, y) : y != 0 { x / y } //  `y`    -    `x`  `y` print(div(2, 0.5)) //  4.0 print(div(2, 0)) // , `y`  0! 

कक्षाएं और डायनेमिक_ऑब्जेक्ट

यदि आपको जटिल वस्तुओं में हेरफेर करने की आवश्यकता है, तो ChaiScript में OOP की रुढ़ियां हैं, जो एक निश्चित प्लस है। भाषा का एक विशेष प्रकार है - डायनामिक_ऑब्जेक्ट। वास्तव में, वर्गों और नामस्थानों के सभी उदाहरण पूर्वनिर्धारित गुणों के साथ बिल्कुल Dynamic_Object हैं। एक डायनामिक ऑब्जेक्ट आपको स्क्रिप्ट के निष्पादन के दौरान फ़ील्ड को जोड़ने की अनुमति देता है, और फिर उन्हें एक्सेस करता है:

 var obj = Dynamic_Object(); obj.x = 3; obj.f = fun(arg) { print(this.x + arg); } //  obj   f (     `x` obj.f(-3); //  0 

कक्षाएं काफी सरलता से परिभाषित की जाती हैं। उन्हें खेतों, विधियों, निर्माणकर्ताओं में सेट किया जा सकता है। दिलचस्प set_explicit(object, value) से, विशेष फ़ंक्शन set_explicit(object, value) आप कक्षा घोषित होने के बाद नए तरीकों या विशेषताओं के अतिरिक्त को प्रतिबंधित करके ऑब्जेक्ट के क्षेत्रों को "ठीक" कर सकते हैं (यह आमतौर पर कंस्ट्रक्टर में किया जाता है):

 class Widget { var id; //  id def Widget() { this.id= 0 } //    def Widget(id) { this.id = id } //   1  def get_id() { id } //   } var w = Widget(10) print(w.get_id()) //  10 (w.id) print(w.get_id) //   10,        set_explicit(w, true) //    wx = 3 //      Widget   x 

एक महत्वपूर्ण बिंदु - वास्तव में, वर्ग विधियां केवल ऐसे कार्य हैं जिनका पहला तर्क स्पष्ट रूप से निर्दिष्ट प्रकार के साथ एक वर्ग की वस्तु है। इसलिए, निम्न कोड एक मौजूदा वर्ग में एक विधि जोड़ने के बराबर है:

 def set_id(Widget w, id) { w.id = id } w.set_id(9) // w.id = 9 set_id(w, 9) //  , w.id = 9 

C # से परिचित कोई भी व्यक्ति उस दर्द को बदल सकता है जो एक विस्तार विधि की तरह दिखता है, और सच्चाई के करीब होगा। इस प्रकार, भाषा में आप अंतर्निहित कक्षाओं के लिए भी नई कार्यक्षमता जोड़ सकते हैं, उदाहरण के लिए, एक स्ट्रिंग या इंट के लिए। लेखकों ने ऑपरेटरों को ओवरलोड करने के लिए एक मुश्किल तरीका भी पेश किया है: ऐसा करने के लिए, आपको ऑपरेटर प्रतीक को एक टिल्ड (`) के साथ घेरने की आवश्यकता है जैसा कि नीचे दिए गए उदाहरण में है:

 //   +     Widget def `+`(Widget w1, Widget w2) { print("merging two widgets!") } var widget1 = Widget() var widget2 = Widget() widget1 + widget2 //      //        : var plus = `+` print(plus(1, 7)) //  8 

नामस्थान

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

 namespace("math") //    math //   math.square = fun(x) { x * x } math.hypot_squared= fun(x, y) { math.square(x) + math.square(y) } print(math.square(4)) //  16 print(math.hypot_squared(3, 4)) //  25 

लैम्ब्डा भाव और अन्य विशेषताएं

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

 var func_object = fun(x) { x * x } func_object(9) //  81 var name = "John" var greet = fun[name]() { "Hello, " + name } print(greet()) //  Hello, John name = "Bob" print(greet()) //  Hello, Bob var message = bind(fun(msg, name) { msg + " from " + name }, _, "ChaiScript"); print(message("Hello")) //  Hello from ChaiScript 

अपवाद

स्क्रिप्ट निष्पादन के दौरान अपवाद हो सकते हैं। उन्हें ChaiScript में ही इंटरसेप्ट किया जा सकता है (जो हम यहां चर्चा करेंगे) और C ++ में। सिंटैक्स प्लसस के साथ बिल्कुल समान है, आप एक संख्या या एक स्ट्रिंग भी बाहर फेंक सकते हैं:

 try { eval(x + 1) // x   } catch (e) { print("Error during evaluation")) } //   C++   ChaiScript //   Vector -   std::vector,    std::exception      try { var vec = [1, 2] var val = vec[3] //     } catch (e) { print("index out of range: " + e.what()); // e.what    ChaiScript } //  atch   guard     ,    `:` try { throw(5.2) } catch(e) : is_type(e, "int") { print("Int: ${e}"); //   `e`  int } catch(e) : is_type(e, "double") { print("Double: ${e}"); //  `e`  double } 

एक अच्छे तरीके से, आपको अपने अपवादों के वर्ग को परिभाषित करना चाहिए और इसे फेंक देना चाहिए। हम इस बारे में बात करेंगे कि इसे दूसरे खंड में C ++ में कैसे इंटरसेप्ट किया जाए। दुभाषिया अपवादों के लिए, ChaScript अपने अपवादों को निकालता है, जैसे कि eval_error, bad_boxed_cast, आदि।

दुभाषिया स्थिरांक

मेरे आश्चर्य के लिए, भाषा कुछ प्रकार के संकलक मैक्रोज़ बन गए - उनमें से केवल 4 हैं और वे सभी संदर्भ की पहचान करने के लिए काम करते हैं और ज्यादातर त्रुटि से निपटने के लिए उपयोग किए जाते हैं:

फँसाने में त्रुटि

यदि आप जिस फ़ंक्शन को कॉल कर रहे हैं वह घोषित नहीं किया गया है, तो एक अपवाद फेंक दिया गया है। यदि यह आपके लिए अस्वीकार्य है, तो आप एक विशेष फ़ंक्शन - method_missing(object, func_name, params) को परिभाषित कर सकते हैं, जिसे त्रुटि के मामले में संबंधित तर्कों के साथ कहा जाएगा:

 def method_missing(Widget w, string name, Vector v) { print("widget method ${name} with params {v} was not found") } w = Widget() w.invoke_error(1, 2, 3) //  widget method invoke_error with params [1, 2, 3] was not found 

अंतर्निहित कार्य

ChaiScript कई अंतर्निहित कार्यों को परिभाषित करता है, और लेख में मैं विशेष रूप से उपयोगी लोगों के बारे में बात करना चाहता हूं। उनमें से: eval(str) , eval_file(filename) , to_json(object) , from_json(str) :

 var x = 3 var y = 5 var res = eval("x * y") // res = 15,  eval     //     : //  eval_file eval_file("source.chai") //   use,  ,         use("source.chai") // to_json    Map    var w = Widget(0) var j = to_json(w) // j = "{ "id" : 0 }" // from_json    Map ( ,   ) var m = from_json(" { "x": 0, "y": 3, "z": 2 }") print(m) //  Map  [<x, 0>, <y, 3>, <z, 2>] 

C ++ में कार्यान्वयन

स्थापना

ChaiScript एक C ++ टेम्पलेट-आधारित हेडर-केवल लाइब्रेरी है। तदनुसार, स्थापना के लिए आपको बस एक क्लोन रिपॉजिटरी बनाने की जरूरत है या बस इस फ़ोल्डर से सभी फाइलों को अपनी परियोजना में डालें। चूंकि, IDE के आधार पर, यह सब अलग-अलग तरीके से किया जाता है और लंबे समय तक मंचों पर विस्तार से वर्णन किया गया है, तो हम मान लेंगे कि आप लाइब्रेरी को जोड़ने में कामयाब रहे, और इसमें शामिल कोड: #include <chaiscript/chaiscript.hpp> संकलित है।

C ++ कोड मंगलाचरण और स्क्रिप्ट लोड हो रहा है

ChaScript का उपयोग करने वाला सबसे छोटा नमूना कोड नीचे दिखाया गया है। हम C ++ में एक साधारण फ़ंक्शन को परिभाषित करते हैं जो std :: string लेता है और बदले हुए स्ट्रिंग को लौटाता है, और फिर हम इसे कॉल करने के लिए ChaiScript ऑब्जेक्ट में एक लिंक जोड़ते हैं। संकलन में काफी समय लग सकता है, लेकिन यह मुख्य रूप से इस तथ्य के कारण है कि संकलक के लिए बड़ी संख्या में टेम्पलेट्स को त्वरित करना आसान नहीं है:

 #include <string> #include <chaiscript/chaiscript.hpp> std::string greet_name(const std::string& name) { return "hello, " + name; } int main() { chaiscript::ChaiScript chai; //  chaiscript chai.add(chaiscript::fun(&greet_name), "greet"); //    greet //  eval      chai.eval(R"( print(greet("John")); )"); } 

मुझे आशा है कि आप सफल हुए, और आपने फ़ंक्शन का परिणाम देखा। बस एक बारीकियों को नोट करना चाहते हैं - यदि आप एक ChaiScript ऑब्जेक्ट को स्थिर के रूप में घोषित करते हैं, तो आपको एक अप्रिय रनटाइम त्रुटि मिलती है। यह इस तथ्य के कारण है कि भाषा डिफ़ॉल्ट रूप से मल्टीथ्रेडिंग का समर्थन करती है और स्थानीय प्रवाह चर को संग्रहीत करती है जो इसके विध्वंसक में एक्सेस होती हैं। हालाँकि, स्थैतिक आवृत्ति के विध्वंसक कहे जाने से पहले वे नष्ट हो जाते हैं, और परिणामस्वरूप, हमारे पास पहुँच उल्लंघन या विभाजन दोष त्रुटि होती है। #define CHAISCRIPT_NO_THREADS पर समस्या के आधार पर, सबसे सरल समाधान यह होगा कि #define CHAISCRIPT_NO_THREADS को कंपाइलर सेटिंग में या लाइब्रेरी फ़ाइल को शामिल करने से पहले, जिससे मल्टीथ्रेडिंग अक्षम हो सके। जैसा कि मैंने इसे समझा, इस त्रुटि को ठीक करना संभव नहीं था।

अब हम विस्तार से विश्लेषण करेंगे कि C ++ और ChaiScript के बीच बातचीत कैसे होती है। लाइब्रेरी एक विशेष टेम्प्लेट फंक्शन fun को परिभाषित करती है, जो एक पॉइंटर को किसी फंक्शन, फंटर, या पॉइंटर को क्लास वेरिएबल में ले जा सकती है, और फिर एक विशेष ऑब्जेक्ट लौटाती है जो स्टेट को स्टोर करता है। एक उदाहरण के रूप में, चलो C ++ कोड में विजेट वर्ग को परिभाषित करते हैं और इसे विभिन्न तरीकों से ChaScript के साथ जोड़ने का प्रयास करते हैं:

 class Widget { int Id; public: Widget(int id) : Id(id) { } int GetId() const { return this->Id; } }; std::string ToString(const Widget& w) { return "widget #" + std::to_string(w.GetId()); } int main() { chaiscript::ChaiScript chai; Widget w(2); //  Widget  C++  chai.add(chaiscript::fun([&w] { return w; }), "get_widget"); //         chai.add(chaiscript::fun(ToString), "to_string"); //   chai.add(chaiscript::fun(&Widget::GetId), "get_id"); //   //    ,   Widget    GetId,    to_string,    chai.eval(R"( var w = get_widget() print(w.get_id) //  2 print(w) //  widget #2 )"); } 

जैसा कि आप देख सकते हैं, ChaiScript सी + + कक्षाओं के साथ बिल्कुल शांति से काम करता है जो इसके लिए अज्ञात है और उनके तरीकों को कॉल कर सकता है। यदि आप कोड में कहीं गलती करते हैं, तो सबसे अधिक संभावना है कि स्क्रिप्ट error in function dispatch एक प्रकार की error in function dispatch का अपवाद फेंक देगी, जो कि सभी के लिए महत्वपूर्ण नहीं है। हालांकि, न केवल फ़ंक्शन आयात किया जा सकता है, आइए देखें कि लाइब्रेरी का उपयोग करके स्क्रिप्ट में एक चर कैसे जोड़ा जाए। ऐसा करने के लिए, कार्य को थोड़ा कठिन चुनें - आयात std :: वेक्टर <विजेट>। chaiscript::var फंक्शन और add_global विधि हमें इसमें मदद करेगी। हम अपने विजेट में Data सार्वजनिक फ़ील्ड को भी जोड़ेंगे, यह देखने के लिए कि क्लास फ़ील्ड को कैसे आयात किया जाए:

 class Widget { int Id; public: int Data = 0; Widget(int id) noexcept : Id(id) { } int GetId() const { return this->Id; } }; std::string ToString(const Widget& w) { return "widget #" + std::to_string(w.GetId()) + " with data: " + std::to_string(w.Data); int main() { chaiscript::ChaiScript chai; std::vector<Widget> W; //    Widget W.emplace_back(1); W.emplace_back(2); W.emplace_back(3); chai.add(chaiscript::fund(ToString), "to_string"); chai.add(chaiscript::fun(&Widget::Data), "data"); //     //     ChaiScript chai.add_global(chaiscript::var(std::ref(W)), "widgets"); //     std::ref chai.add(chaiscript::fun(&std::vector<Widget>::size), "size"); //   // .        using IndexFuncType = Widget& (std::vector<Widget>::*)(const size_t); chai.add(chaiscript::fun(IndexFuncType(&std::vector<Widget>::operator[])), "[]"); chai.eval(R"( for(var i = 0; i < vec.size; ++i) { vec[i].data = i * 2; print(vec[i]) } )"); } 

उपरोक्त कोड प्रदर्शित करता है: widget #1 with data: 0 , widget #2 with data: 2 , widget #3 with data: 4 । हमने ChaiScript में क्लास फ़ील्ड में एक पॉइंटर जोड़ा, और चूंकि फ़ील्ड एक आदिम प्रकार निकला, हम इसके मूल्य को बदलते हैं। साथ ही, operator[] सहित std::vector साथ काम करने के लिए कई तरीके जोड़े गए। जो लोग एसटीएल से परिचित हैं, वे जानते हैं कि std::vector दो अनुक्रमण विधियां हैं - एक निरंतर लिंक देता है, दूसरा एक सरल लिंक। यही कारण है कि अतिभारित कार्यों के लिए, आपको स्पष्ट रूप से उनके प्रकार को इंगित करना होगा - अन्यथा अस्पष्टता उत्पन्न होती है, और संकलक एक त्रुटि फेंक देगा।

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

 chai.add(chaiscript::var(x), "x"); // x   ChaiScript chai.add(chaiscript::var(std::ref(x), "x"); //  ,    C++  ChaiScript auto shared_x = std::make_shared<int>(5); chai.add(chaiscript::var(shared_x), "x"); // shared_ptr      C++  ChaiScript chai.add(chaiscript::const_var(x), "x"); //   ChaiScript    chai.add_global_const(chaiscript::const_var(x), "x"); // global const . ,  x   chai.add_global(chaiscript::var(x), "x"); // global , .  x   chai.set_global(chaiscript::var(x), "x"); //   global ,    const 

एसटीएल कंटेनरों का उपयोग करना

यदि आप ChaiScript के लिए आदिम प्रकार के एसटीएल कंटेनरों को पास करना चाहते हैं, तो आप अपनी स्क्रिप्ट में एक टेम्पलेट कंटेनर इंस्टेंटेशन जोड़ सकते हैं ताकि आप प्रत्येक प्रकार के लिए विधियों को आयात न करें।

 using MyVector = std::vector<std::pair<int, std::string>>; MyVector V; V.emplace_back(1, "John"); V.emplace_back(3, "Bob"); //    - vector  pair chai.add(chaiscript::bootstrap::standard_library::vector_type<MyVector>("MyVec")); chai.add(chaiscript::bootstrap::standard_library::pair_type<MyVector::value_type>("MyVecData")); chai.add(chaiscript::var(std::ref(V)), "vec"); chai.eval(R"( for(var i = 0; i < vec.size; ++i) { print(to_string(vec[i].first) + " " + vec[i].second) } )"); 

ChaiScript, . , STL-, . c std::vector<Widget> , , , ChaiScript vector_type , Widget .

++ ChaiScript

ChaiScript, . , . Widget WindowWidget, , :

 class Widget { int Id; public: Widget(int id) : Id(id) { } int GetId() const { return this->Id; } }; class WindowWidget : public Widget { std::pair<int, int> Size; public: WindowWidget(int id, int width, int height) : Widget(id), Size(width, height) { } int GetWidth() const { return this->Size.first; } int GetHeight() const { return this->Size.second; } }; int main() { chaiscript::ChaiScript chai; //   Widget    chai.add(chaiscript::user_type<Widget>(), "Widget"); chai.add(chaiscript::constructor<Widget(int)>(), "Widget"); //   WindowWidget    chai.add(chaiscript::user_type<WindowWidget>(), "WindowWidget"); chai.add(chaiscript::constructor<WindowWidget(int, int, int)>(), "WindowWidget"); // ,  Widget -    WindowWidget chai.add(chaiscript::base_class<Widget, WindowWidget>()); //   Widget  WindowWidget chai.add(chaiscript::fun(&Widget::GetId), "get_id"); chai.add(chaiscript::fun(&WindowWidget::GetWidth), "width"); chai.add(chaiscript::fun(&WindowWidget::GetHeight), "height"); //  WindowWidget     chai.eval(R"( var window = WindowWidget(1, 800, 600) print("${window.width} * ${window.height}") print("widget.id is ${window.get_id}") )"); } 

ChaiScript , C++ , . - (, ), , std::vector<Widget> .

. ChaiScript , , :

 Widget w(3); w.Data = 4444; //  Widget w chai.add(chaiscript::fun(&Widget::GetId, &w), "widget_id"); chai.add(chaiscript::fun(&Widget::Data, &w), "widget_data"); chai.eval(R"( print(widget_id) print(widget_data) )"); 

«» C++ ChaiScript ( , vec3, complex, matrix) . ChaiScript type_conversion . Complex int double :

 class Complex { public: float Re, Im; Complex(float re, float im = 0.0f) : Re(re), Im(im) { } }; int main() { chaiscript::ChaiScript chai; //  Complex,   re, im,    `=` chai.add(chaiscript::user_type<Complex>(), "Complex"); chai.add(chaiscript::bootstrap::standard_library::assignable_type<Complex>("Complex")); chai.add(chaiscript::constructor<Complex(float, float)>(), "Complex"); chai.add(chaiscript::fun(&Complex::Re), "re"); chai.add(chaiscript::fun(&Complex::Im), "im"); //     double  int  Complex chai.add(chaiscript::type_conversion<int, Complex>()); chai.add(chaiscript::type_conversion<double, Complex>()); //     `+`    chai.eval(R"( def `+`(Complex c, x) { var res = Complex(0, 0) res.re = c.re + x.re res.im = c.im + x.im return res } var c = Complex(1, 2) c = c + 3 print("${c.re} + ${c.im}i") )"); // : `4 + 2i` } 

इस प्रकार, C ++ में रूपांतरण फ़ंक्शन लिखना आवश्यक नहीं है, और केवल तब इसे ChaiScript को निर्यात करें। आप रूपांतरण जोड़ सकते हैं, और पहले से ही स्क्रिप्ट कोड में नई कार्यक्षमता का वर्णन कर सकते हैं। यदि दो प्रकारों के लिए रूपांतरण nontrivial है, तो आप एक फ़ंक्शन के तर्क के रूप में लैम्ब्डा पास कर सकते हैं type_conversion। कास्टिंग करते समय इसे कहा जाएगा।

इसी तरह के सिद्धांत का उपयोग वेक्टर या मैप चाईस्क्रिप्ट को आपके कस्टम प्रकार में बदलने के लिए किया जाता है। इसके लिए, vector_conversionऔर पुस्तकालय में परिभाषित हैं map_conversion।

ChaiScript रिटर्न मान को अनपैक करना

विधियाँ evalऔर eval_fileएक ऑब्जेक्ट के रूप में अंतिम निष्पादित अभिव्यक्ति का मान लौटाते हैं Boxed_Value। इसे अनपैक करने और C ++ कोड में परिणाम का उपयोग करने के लिए, आप रिटर्न मान के प्रकार को स्पष्ट रूप से निर्दिष्ट कर सकते हैं या फ़ंक्शन का उपयोग कर सकते हैं boxed_cast<T>। यदि प्रकारों के बीच रूपांतरण मौजूद है, तो इसे निष्पादित किया जाएगा, अन्यथा एक अपवाद उठाया जाएगा bad_boxed_cast:

 //       double d = chai.eval<double>("5.3 + 2.1"); //     Boxed_Value,     auto v = chai.eval("5.3 + 2.1"); double d = chai.boxed_cast<double>(v); 

चाईस्क्रिप्ट के अंदर सभी वस्तुओं को साझा करने के लिए संग्रहीत किया जाता है। आप इसके साथ आगे के काम के लिए एक सूचक के रूप में वस्तु प्राप्त कर सकते हैं। ऐसा करने के लिए, वापसी मान को परिवर्तित करते समय शेअर_प्ट्र प्रकार को स्पष्ट रूप से निर्दिष्ट करें:

 auto x = chai.eval<std::shared_ptr<double>>("var x = 3.2"); 

, shared_ptr, access violation , .

, ChaiScript , ChaiScript. , Complex :

 auto printComplex = chai.eval<std::function<void(Complex)>>(R"( fun(Complex c) { print("${c.re} + ${c.im}i"); } )"); //  ,   ,      C++ printComplex(Complex(2, 3)); //  chaiscript,  `2 + 3i` 

ChaiScript

लेखक उन लोगों के अलावा तीन प्रकार के अपवादों को पकड़ने की सलाह देते हैं जो आप स्वयं उत्पन्न करते हैं। यह eval_errorरनटाइम त्रुटियों के लिए है, bad_boxed_castयह तब कहा जाता है जब रिटर्न मान गलत तरीके से अनपैक किए जाते हैं और std::exceptionबाकी सब के लिए। यदि आप अपने स्वयं के अपवादों को फेंकने की योजना बनाते हैं, तो आप C ++ प्रकारों में स्वचालित रूपांतरण कॉन्फ़िगर कर सकते हैं:

 class MyException : public std::exception { public: int Data; MyException(int data) : std::exception("MyException"), Data(data) { } }; int main() { chaiscript::ChaiScript chai; //      chaiscript chai.add(chaiscript::user_type<MyException>(), "MyException"); chai.add(chaiscript::constructor<MyException(int)>(), "MyException"); try { //          chai.eval("throw(MyException(11111))", chaiscript::exception_specification<MyException, std::exception>()); } catch (MyException& e) { std::cerr << e.Data; //   `11111` } catch (chaiscript::exception::eval_error& e) { std::cerr << e.pretty_print(); } catch(std::exception& e) { std::cerr << e.what(); } } 

ऊपर का उदाहरण दिखाता है कि C ++ में अधिकांश अपवादों को कैसे पकड़ा जाए। विधि के अलावा pretty_print, eval_errorअभी भी बहुत सारे उपयोगी डेटा हैं, जैसे कॉल स्टैक, फ़ाइल का नाम, त्रुटि विवरण, लेकिन हम इस लेख में इस वर्ग में नहीं जाएंगे।

ChaiScript लाइब्रेरी

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

 #include <chaiscript/chaiscript.hpp> #include <chaiscript/extras/math.hpp> int main() { chaiscript::ChaiScript chai; //   auto mathlib = chaiscript::extras::math::bootstrap(); chai.add(mathlib); std::cout << chai.eval<double>("acos(0.5)"); // ~1.047 } 

आप अपनी लाइब्रेरी को भाषा के लिए भी लिख सकते हैं और फिर आयात कर सकते हैं। यह काफी सरलता से किया जाता है, इसलिए मैं आपको सलाह देता हूं कि आप ओपन सोर्स गणित या रिपॉजिटरी में किसी अन्य स्रोत से खुद को परिचित करें। सिद्धांत रूप में, सी ++ के साथ एकीकरण के भाग के रूप में, हमने लगभग हर चीज की जांच की, इसलिए मुझे लगता है कि इस पर अनुभाग पूरा हो सकता है।

व्यक्तिगत अनुभव

3D- OpenGL , , . , , , « », .

, ChaiScript , Lua. , , : , C++ C, - C-style . , , .

, . ImGui, chaiscript. , :

 //      3D-: // rotation CHAI_IMPORT(&GLInstance::RotateX, rotate_x); CHAI_IMPORT(&GLInstance::RotateY, rotate_y); CHAI_IMPORT(&GLInstance::RotateZ, rotate_z); // scale CHAI_IMPORT((GLInstance&(GLInstance::*)(float))&GLInstance::Scale, scale); CHAI_IMPORT((GLInstance&(GLInstance::*)(float, float, float))&GLInstance::Scale, scale); // translation CHAI_IMPORT(&GLInstance::Translate, translate); CHAI_IMPORT(&GLInstance::TranslateX, translate_x); CHAI_IMPORT(&GLInstance::TranslateY, translate_y); CHAI_IMPORT(&GLInstance::TranslateZ, translate_z); // hide / show CHAI_IMPORT(&GLInstance::Hide, hide); CHAI_IMPORT(&GLInstance::Show, show); // getters CHAI_IMPORT(&GLInstance::GetTranslation, translation); CHAI_IMPORT(&GLInstance::GetRotation, rotation); CHAI_IMPORT(&GLInstance::GetScale, scale); 

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


चैसस्क्रिप्ट से इमगुई तक कंसोल: ऑब्जेक्ट को कमांड के माध्यम से डाउनलोड करना और इंस्टॉल

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

. C++ ( Lua ), ChaiScript . . .

• ChaiScript: chaiscript.com
• : ChaiScript cheatsheet
• : codedocs.xyz/ChaiScript/ChaiScript
• ChaiScript: github.com/MomoDeve/MomoEngine