🏙️ 🥫 🖨️ लुआ एपीआई ++ 👨🏿‍🤝‍👨🏾 〰️ ⬜️

नमस्कार साथियों!
मैं आपको अपनी छोटी परियोजना से परिचित कराना चाहता हूं, जो मुझे आशा है कि आपके लिए उपयोगी हो सकता है।

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

मैं यह नहीं कह सकता कि मैं लुआ एपीआई से असंतुष्ट हूं: यह कार्यों का एक उत्कृष्ट सेट है, सुविधाजनक और उपयोग करने में आसान है। अपने आवेदन में भाषा को एकीकृत करने और अपने स्वयं के एक्सटेंशन को जोड़ने से कोई कठिनाई नहीं हुई, और कोई "नुकसान" भी नहीं हुआ। लेकिन फिर भी, इस सी-उन्मुख एपीआई का उपयोग करते समय, मुझे इस विचार से नहीं छोड़ा गया कि यह प्रक्रिया अधिक सुविधाजनक हो सकती है। एक सुविधाजनक ऑब्जेक्ट-ओरिएंटेड रैपर बनाने का पहला प्रयास विफल रहा: उपलब्ध धन के साथ, मैं ऐसा कुछ नहीं बना सका जो अस्तित्व के योग्य हो, सब कुछ बहुत बोझिल और स्पष्ट नहीं था।

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

प्रमुख अभिनेता

पुस्तकालय द्वारा उपयोग की जाने वाली बुनियादी अवधारणाओं और उनके बीच संबंध के साथ परिचित होना शुरू होना चाहिए। जैसा कि अपेक्षित था, ये अवधारणाएँ संबंधित प्रकारों में परिलक्षित होती हैं।

`State`

State लुआ राज्य का मालिक है। यह एक स्वतंत्र प्रकार है, व्यावहारिक रूप से पुस्तकालय के बाकी हिस्सों से असंबंधित है। राज्य के निर्माण और विनाश को नियंत्रित करने के अलावा, यह फाइलों, स्ट्रिंग्स और लुआ-संगत कार्यों को निष्पादित करने के लिए केवल साधन प्रदान करता है। उनके ऑपरेशन के दौरान होने वाली त्रुटियां अपवादों में बदल जाती हैं।

`LFunction`

लाइब्रेरी में बाकी सब कुछ LFunction अंदर होता है, Lua API ++ के साथ संगत एक विशेष प्रारूप के कार्य। यह लुआ-संगत कार्यों का एक एनालॉग है, जिसे बदले में नाम दिया गया था CFunction । मुख्य रूप से हमारे अगले चरित्र में जाने के लिए एक विशेष फ़ंक्शन प्रारूप की आवश्यकता थी:

`Context`

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

मूल्य

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

`Valref`

यह स्टैक पर रखे गए मान का लिंक है, या यूँ कहें कि लुआ स्टैक पर किसी विशिष्ट स्लॉट के मूल्य के लिए इतना नहीं है। Valref स्टैक पर मूल्यों को रखने या हटाने Valref साथ Valref नहीं करता है, लेकिन केवल मूल्य पर संचालन पर केंद्रित है। Lua API ++ Valref एक मॉडल के रूप में कार्य करता है जो अन्य प्रकार के इंटरफ़ेस का अनुसरण करता है जो मूल्यों का प्रतिनिधित्व करते हैं।

अस्थायी

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

एंकर

एंकरों का नाम इसलिए रखा गया है क्योंकि वे आपको ढेर में एक या अधिक मान "पिन" करने की अनुमति देते हैं। Value एक एकल मूल्य के लिए एक सार्वभौमिक "लंगर" है, Table तालिकाओं के लिए विशिष्ट है, और Valset कई मूल्यों को संग्रहीत करता है।

अब जब मुख्य पात्र हमारे सामने प्रस्तुत किए जाते हैं, तो हम उनके साथ क्या कर सकते हैं, इसका अधिक विस्तृत विश्लेषण शुरू कर सकते हैं।

`State`

State पास एक डिफ़ॉल्ट निर्माता है जो संदर्भ को प्रारंभ करने के लिए आवश्यक सभी क्रियाएं करता है। एक वैकल्पिक निर्माता आपको एक कस्टम मेमोरी प्रबंधन फ़ंक्शन का उपयोग करने की अनुमति देता है । आप getRawState फ़ंक्शन द्वारा Lua API में उपयोग की गई राज्य ऑब्जेक्ट के लिए एक कच्चे पॉइंटर का अनुरोध कर सकते हैं।
सेट में फ़ंक्शंस runFile , runString और call , जो आपको एक सरल दुभाषिया बनाने की अनुमति देते हैं:

सबसे सरल दुभाषिया

 #include <iostream> #include <luapp/lua.hpp> using namespace std; using namespace lua; void interpretLine(State& state, const string& line) { try { state.runString(line); //    } catch(std::exception& e) { //          cerr << e.what() << endl; } } void interpretStream(State& state, istream& in) { string currentLine; while(!in.eof()) { //        getline(in, currentLine); interpretLine(state, currentLine); } } int main() { State state; interpretStream(state, cin); }

हैंडलिंग में त्रुटि

लाइब्रेरी द्वारा उपयोग किया जाने वाला दृष्टिकोण लुआ के पैरों के नीचे नहीं जाना है, इसलिए या तो उन त्रुटियों का पता चलता है जो लाइब्रेरी से ही जुड़े हैं, जैसे कि एक Table से Table बनाने का प्रयास नहीं है, या जिन्हें (संभवतः) उपयोगकर्ता कोड में इंटरसेप्ट किया जाना है। , टाइपकास्टिंग त्रुटियों की तरह। लायब्रेरी उन त्रुटियों को पहले से निदान करने का प्रयास नहीं करती है, जिन्हें लुआ एपीआई कॉल करते समय पता लगाया जा सकता है। इसलिए, एक प्रयास, उदाहरण के लिए, एक मूल्य पर एक फ़ंक्शन कॉल का उपयोग करने के लिए जो वास्तव में एक संख्या है एक अपवाद नहीं उठाएगा। यह lua_call कॉल के अंदर पता लगाया जाएगा और एक Lua- शैली त्रुटि (निष्पादन में व्यवधान और संरक्षित कॉल के निकटतम बिंदु पर लौटने) का कारण बनेगा।

`LFunction`

वास्तव में, पुस्तकालय कार्यों के "पारदर्शी" आवरण का समर्थन करता है जो समर्थित प्रकारों (और यहां तक कि सदस्य कार्यों) पर काम करता है। सीधे उस फ़ंक्शन का नाम बताएं जहां Lua मान अपेक्षित है। लेकिन अगर हम Lua API ++ द्वारा प्रदान की गई सभी Lua सुविधाओं का उपयोग करना चाहते हैं, तो हमें अपने प्रोटेक्शन के अनुसार L- फ़ंक्शन लिखना होगा:

 Retval myFunc(Context& c);

यहां सब कुछ सरल है: हमारा फ़ंक्शन Context प्राप्त करता है, और Retval एक विशेष प्रकार है जो Context::ret फ़ंक्शन के माध्यम से मूल्यों की एक मनमानी संख्या को आसानी से वापस करने में मदद करता है।

mkcf टेम्पलेट आपको LFunction साथ Lua दोस्त बनाने की अनुमति देता है:

 int (*myCfunc)(lua_State*) = mkcf<myFunc>;

इस तरह हम अपने कार्य के लिए स्पष्ट रूप से रैपर बना सकते हैं। एक "पारदर्शी" आवरण भी काम करेगा, लेकिन ओवरहेड थोड़ा अधिक होगा। दूसरी ओर, mkcf प्रत्येक मामले में एक अलग आवरण समारोह बनाएगा।
एक तरह से या किसी अन्य, लेकिन किसी भी मामले में, "आवरण" एक Context वस्तु बनाएगा, इसे हमारे फ़ंक्शन को पास करेगा, और काम पूरा होने पर Retval से Retval माध्यम से Retval गए मानों को पास करेगा। लिपटे फ़ंक्शन के दायरे से परे जाने वाले सभी अपवादों को पकड़ा जाएगा और एक लुआ त्रुटि में परिवर्तित किया जाएगा।

समारोह में ही लौट रहा है? मुझे दो!

 Retval retSelf(Context& c) { return c.ret(retSelf, mkcf<retSelf>); //    ,  - }

`Context`

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

मान लौटाएं

कोई फर्क नहीं पड़ता कि रिटर्न स्टेटमेंट में फ़ंक्शन से लौटाए गए मूल्यों को केवल इंगित करना कितना अच्छा है, यह असंभव है। मुझे दो निकटतम विकल्पों के बीच एक विकल्प बनाना था: एक अल्पविराम अतिभारित ऑपरेटर या एक फ़ंक्शन कॉल के साथ एक चालाक "स्टार्टर"। ~~मैत्री~~ समारोह जीता। इसलिए, LFunction को LFunction वापस LFunction आवश्यकता होती है, जिसे आप केवल विनम्र नाम के साथ Context विधि तक LFunction बना सकते हैं। यह एक विशेष कार्य है: इसे कहा जाने के बाद, स्टैक के साथ काम करना बंद हो जाता है ताकि हमारे मूल्यों को इससे दूर न किया जाए, इसलिए इसका उपयोग केवल रिटर्न स्टेटमेंट में किया जाना चाहिए। ret कॉल में, आप उतने रिटर्न मानों को सूचीबद्ध कर सकते हैं, जितने की जरूरत है।

तुलना

 return ctx.ret(1, "two", three);

समतुल्य कोड:

 lua_pushinteger(ctx, 1); lua_pushstring(ctx, "two"); lua_pushvalue(ctx, three); return 3;

रिपोर्टिंग में त्रुटि

यह तर्क देते हुए कि Retval बनाने का एकमात्र तरीका Retval फ़ंक्शन का उपयोग करना है, मैंने सच्चाई के खिलाफ पाप नहीं किया है, लेकिन एक चेतावनी है ... औपचारिक दृष्टिकोण से, error फ़ंक्शन भी है, जो इस प्रकार भी लौटाता है। केवल वास्तव में Retval निर्माण तक नहीं पहुंचता है, क्योंकि इस फ़ंक्शन से कोई वापसी नहीं होती है। अधिकतम आप जिस पर भरोसा कर सकते हैं वह है लुआ एरर हैंडलिंग इंजन को अपना संदेश देना। Lua API प्रलेखन रिटर्न स्टेटमेंट में lua_error कॉल का उपयोग करने की सलाह देता है ताकि यह संकेत मिल सके कि कॉल के दौरान फ़ंक्शन बाधित है। उसी दृष्टिकोण का उपयोग Lua API ++ में भी किया जाता है, इसलिए error Retval रूप error घोषित किया जाता है।
एक त्रुटि संदेश के साथ एक Lua मान को एक तर्क के रूप में लिया जाता है, और यहां समवर्ती काफी उपयुक्त होगा, खासकर where फ़ंक्शन स्ट्रिंग बना सकता है, वर्तमान फ़ंक्शन का वर्णन करने वाली एक पंक्ति बना सकता है। यदि संदेश बिल्कुल निर्दिष्ट नहीं है, तो समान मान का उपयोग किया जाता है।

 if(verbose) return ctx.error(ctx.where() & " intentional error " & 42); else return ctx.error(); //   ,  return ctx.error(ctx.where());

समतुल्य कूट

 if(verbose) { luaL_where(ctx, 0); lua_pushstring(ctx, " intentional error "); lua_pushinteger(ctx, 42); lua_concat(ctx, 3); return lua_error(ctx); } else { luaL_where(ctx, 0); return lua_error(ctx); }

पर्यावरण तक पहुंच

हमारा Context स्पष्ट रूप से मूल्यों का प्राथमिक स्रोत है। वास्तव में, वे और कहाँ से आ सकते हैं?
हमें Context वर्ग के सार्वजनिक सदस्यों के रूप में डिज़ाइन किए गए एक्सेस ऑब्जेक्ट्स प्रदान किए जाते हैं, जो हमें पर्यावरण के विभिन्न दिलचस्प स्थानों तक पहुंचने की अनुमति देते हैं। वे सभी पढ़ने और लिखने के मूल्यों की अनुमति देते हैं।

सबसे पहले, ये args , फ़ंक्शन तर्क हैं। अन्य एक्सेस ऑब्जेक्ट्स के विपरीत, जिनमें से प्रत्येक के लिए उपयोगकर्ता के लिए एक विशेष प्रकार का दुर्गम बनाया गया था, यहां सामान्य Valset का उपयोग किया जाता है। इसकी कमी का मतलब केवल यह है कि हम इसका आकार नहीं बदल सकते हैं, लेकिन स्वास्थ्य के लिए तर्कों का अर्थ फिर से लिखना है। चूंकि वलसेट को एसटीएल-संगत कंटेनर के रूप में बनाया गया था, इसलिए इसमें तत्वों की संख्या 0. से शुरू होती है। अन्य मामलों में, पुस्तकालय लुआ नियमों का पालन करता है और इसका मतलब है कि अनुक्रमण 1 से शुरू होता है।

 if(ctx.args.size() > 1 && ctx.args[0].is<string>()) {...};

समतुल्य कूट

  if(nArgs > 1 && lua_isstring(ctx, 1) ) {...};

दूसरे स्थान पर वैश्विक चरों तक पहुंच है। global वस्तु को स्ट्रिंग्स द्वारा अनुक्रमित किया जाता है।

 ctx.global["answer"] = 42; //      ,

समतुल्य कूट

 lua_pushinteger(ctx, 42); lua_setglobal(ctx, "answer");

यदि हमारा LFunction भी बंद है, तो हम पूर्णांक सूचकांक के साथ upvalues माध्यम से upvalues संग्रहीत मूल्यों तक पहुंच सकते हैं (1 से शुरू होकर, सब कुछ सही है)। संग्रहीत मूल्यों की संख्या जानने का कोई तरीका नहीं है: यह माना जाता है कि यह पहले से ही ज्ञात है।

रजिस्ट्री के माध्यम से सुलभ लुआ रजिस्ट्री का उपयोग दो तरीकों से किया जाता है। स्ट्रिंग कुंजी द्वारा, उपयोगकर्ता डेटा के लिए मेटाटैबल्स को वहां संग्रहीत किया जाता है। मानों के भंडार के रूप में रजिस्ट्री का उपयोग करते समय पूर्णांक कुंजियों का उपयोग किया जाता है। registry.store को कॉल करके बनाया जाता है। बाद में registry.store को पढ़ने और लिखने के लिए उपयोग किया जाता है, मान को मिटाते हुए और जब nil लिखा nil है, तब कुंजी जारी होती है।

 auto k = ctx.registry.store(ctx.upvalues[1]); // decltype(k) == int ctx.registry [k] = nil; //  k       store

समतुल्य कूट

 lua_pushvalue(ctx, lua_upvalueindex(1)); auto k = luaL_ref(ctx, LUA_REGISTRYINDEX); luaL_unref(ctx, LUA_REGISTRYINDEX, k);

कार्यों

मैंने अभी उल्लेख किया है कि लुआ आपको क्लोजर बनाने की अनुमति देता है। Context वस्तु में, इसके लिए closure फ़ंक्शन का उपयोग किया जाता है, जो कि CFunction को प्राप्त करता है और उन मूल्यों को जो क्लोजर में संग्रहीत किया जाएगा। परिणाम एक अस्थायी वस्तु है, अर्थात, एक पूर्ण लुआ मान।
CFunction बजाय CFunction हम LFunction तुरंत निर्दिष्ट कर सकते हैं, लेकिन इस लपट की अपनी कीमत है। पहले उत्थान को परिणामी क्लोजर में आरक्षित किया जाएगा (फ़ंक्शन का पता वहां संग्रहीत किया जाता है, क्योंकि आवरण किसी भी LFunction के लिए समान है)। समान परिणामों के साथ LFunction पारदर्शी प्रवास के लिए समान फ़ंक्शन का उपयोग किया जाता है। यह mkcf टेम्पलेट से अंतर है, जो कुछ भी आरक्षित नहीं करता है, लेकिन यह प्रत्येक फ़ंक्शन के लिए एक अलग आवरण फ़ंक्शन बनाता है।

आप विखंडू भी बना सकते हैं: संकलित लुआ कोड। पाठ को स्वयं chunk विधि, और load का उपयोग करके फ़ाइल की सामग्री का उपयोग करके संकलित किया गया है। "पूर्ण और विस्मृत" के मामलों के लिए runString और runFile , बिल्कुल State के समान। उपयोग के संदर्भ में, झूमना एक सामान्य विशेषता है।

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

मान पलायन

Lua API ++ निम्नलिखित मूल प्रकारों का समर्थन करता है:

संख्यात्मक
`int`
`unsigned int`
`long long`
`unsigned long long`
`float`
`double`
तार
*`const char`**
`std::string`
कार्यों
*`CFunction: int () (lua_State)`*
*`LFunction: Retval () (Context&)`**
मनमाना कार्य
सदस्य कार्य
अनेक वस्तुओं का संग्रह
`Nil`
`bool`
*`LightUserData: void`**
पंजीकृत उपयोगकर्ता प्रकार

तालिका में सूचीबद्ध प्रकारों का मान लुआ स्टैक और इसके विपरीत (अपवाद के साथ, निश्चित रूप से, Nil और "लिपटे" फ़ंक्शंस के लिए माइग्रेट कर सकता है, जो रैपर के लिए संकेत बने हुए हैं)।
रिवर्स माइग्रेशन का उपयोग मान प्रकारों में निर्मित अंतर्निहित रूपांतरण ऑपरेटरों का उपयोग करके किया जाता है और cast टेम्पलेट फ़ंक्शन का उपयोग किया जाता है। यदि Lua मान में डेटा है जिसे हम क्या करने की कोशिश कर रहे हैं, उसे परिवर्तित नहीं किया जा सकता है, तो एक अपवाद फेंक दिया जाएगा। optcast फ़ंक्शन अपवादों के बजाय "फ़ॉलबैक" मान लौटाएगा।

 int a = val; auto b = val.cast<int>(); auto c = val.optcast<int>(42);

समतुल्य कूट

 if(!lua_isnumber(ctx, valIdx)){ lua_pushstring(ctx, "Conversion error"); return lua_error(ctx); } int a = lua_tointeger(ctx, valIdx); if(!lua_isnumber(ctx, valIdx)){ lua_pushstring(ctx, "Conversion error"); return lua_error(ctx); } auto b = lua_tointeger(ctx, valIdx); auto c = lua_isnumber(ctx, valIdx) ? lua_tointeger(ctx, valIdx) : 42;

आप फ़ंक्शन के साथ वांछित प्रकार के साथ संगतता की जांच कर सकते हैं, और type साथ, सीधे संग्रहीत मूल्य के प्रकार का पता लगा सकते हैं।

 if(val.is<double>()) ...; if(val.type() == ValueTypes::Number) ...;

एकल मूल्य संचालन

असाइनमेंट

यदि हमारे पास मूल्य है, तो सामान्य स्थिति में, आप इसे कुछ मूल्य, अन्य मूल्य और मूल निवासी दोनों को असाइन कर सकते हैं। लेकिन यह कुछ अस्थायी मूल्यों पर लागू नहीं होता है, उदाहरण के लिए, फ़ंक्शन कॉल या लंबाई के परिणाम के लिए: बाईं ओर = चिह्न होने पर, वे एक मुश्किल त्रुटि उत्पन्न करेंगे। लेकिन अन्य अस्थायी मूल्य, जैसे कि अनुक्रमण या एक मेटाबल, असाइनमेंट काफी स्वीकार्य है। प्रदर्शन की गई क्रिया के अर्थ के अनुसार, यह अनुमान लगाना आसान है कि क्या सौंपा जा सकता है और क्या नहीं।

metatables

mt विधि एक मूल्य के मेटिबेट तक पहुंच देती है जिसे पढ़ा और लिखा जा सकता है।

 { Table mt = val.mt(); val.mt() = nil; }

समतुल्य कूट

 if(!lua_getmetatable(ctx, valIdx)){ lua_pushstring(ctx, "The value has no metatable"); return lua_error(ctx); } int mtIdx = lua_gettop(ctx); lua_pushnil(ctx); lua_setmetatable(ctx, valIdx); lua_pop(ctx, 1);

लंबाई

len फ़ंक्शन का संचालन लुआ के विभिन्न संस्करणों में भिन्न होता है: 5.1 संगतता मोड में, यह देशी size_t लौटाता है, और 5.2 मोड में यह एक अस्थायी मान लौटाता है।

अनुक्रमण

तालिका के प्रमुख तत्वों को अनुक्रमण द्वारा एक्सेस किया जाता है; कुंजी किसी भी समर्थित प्रकार की हो सकती है। लेकिन हमें यह याद रखना चाहिए कि जब रैपिंग फंक्शंस, नए क्लोजर बनाए जाएंगे:

 void myFunc(); Retval example(Context& c) { Table t(c); t[myFunc] = 42; //  myFunc   ... assert(t[myFunc].is<Nil>()); //   -  ,   . t[mkcf<example>] = 42.42; //     CFunction,   "" assert(t[mkcf<example>] == 42.42); }

समतुल्य कूट

 void myFunc(); int wrapped_void_void(lua_State* s) { if(!lua_islightuserdata(ctx, lua_upvalueindex(1))) { lua_pushstring(ctx, "Conversion error"); return lua_error(ctx); } void (*fptr) () = reinterpret_cast<void(*)()>(lua_touserdata(ctx, lua_upvalueindex(1))); fptr(); return 0; } int mkcf_myFunc(lua_State* s) { myFunc(); return 0; } int example(lua_State* ctx) { lua_createtable(ctx, 0, 0); int t = lua_gettop(ctx); lua_pushlightuserdata(ctx, reinterpret_cast<void*>(&myFunc)); lua_pushcclosure(ctx, &wrapped_void_void, 1); lua_pushinteger(ctx, 42); lua_settable(ctx, t); lua_pushlightuserdata(ctx, reinterpret_cast<void*>(&myFunc)); lua_pushcclosure(ctx, &wrapped_void_void, 1); lua_gettable(ctx, t); assert(lua_isnil(ctx, -1)); lua_pushcfunction(ctx, &mkcf_myFunc); lua_pushnumber(ctx, 42.42); lua_settable(ctx, t); lua_pushcfunction(ctx, &mkcf_myFunc); lua_gettable(ctx, t); lua_pushnumber(ctx, 42.42); int result = lua_compare(ctx, -1, -2, LUA_OPEQ); lua_pop(ctx, 2); assert(result == 1); }

फंक्शन कॉल

Lua फ़ंक्शन को नियमित कोष्ठक का उपयोग करके कहा जाता है। स्पष्ट कॉल के लिए एक call विधि है, यदि आपको कुछ अधिक अभिव्यंजक की आवश्यकता है। एक pcall कॉल त्रुटियों को रोकता है।

 int x = fn(1); int y = fn.call(1); //    int z = fn.pcall(1); //     ,

एकाधिक वापसी मान

हमने अभी देखा कि कॉल के परिणाम को सामान्य मूल्य के रूप में सुरक्षित रूप से उपयोग किया जा सकता है। लेकिन उन कार्यों के बारे में जो एक ही बार में कई मान लौटाते हैं? उदाहरण के लिए Lua पर ऐसा कार्य करें:

 function mrv() return 2, 3, 4; end

हमारे पास एक साथ कई विकल्प हैं।
सबसे पहले, आप कॉल एक्सप्रेशन का उपयोग किए बिना कॉल के परिणामों को पूरी तरह से अनदेखा कर सकते हैं। सभी लौटे मानों को केवल बाहर फेंक दिया जाएगा।

 mrv();

समतुल्य कूट

 lua_pushvalue(ctx, mrvIdx); lua_call(ctx, 0, 0);

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

 Value x = mrv(); // x == 2

समतुल्य कूट

 lua_pushvalue(ctx, mrvIdx); lua_call(ctx, 0, 1); int x = lua_gettop(ctx);

तीसरा, मूल्यों के अनुक्रम से संबंधित एक संदर्भ में (उदाहरण के लिए, फ़ंक्शन पैरामीटर), कॉल एक्सप्रेशन का विस्तार किया जाएगा: लौटे मान अनुक्रम का हिस्सा बन जाएंगे।

 print(1, mrv(), 5); //  1 2 3 4 5

समतुल्य कूट

 lua_pushvalue(ctx, printIdx); int oldtop = lua_gettop(ctx); lua_pushinteger(ctx, 1); lua_pushvalue(ctx, mrvIdx); lua_call(ctx, 0, LUA_MULTRET); lua_pushinteger(ctx, 5); int nArgs = lua_gettop(ctx) - oldtop; lua_call(ctx, nArgs, 0);

चौथा, आप केवल Valset को सब कुछ बचा सकते हैं, विशेष रूप से इसके लिए आविष्कार किया गया है।

 Valset vs = mrv.pcall(); // vs.size() == 3, vs.success() == true

समतुल्य कूट

 int vsBegin = lua_gettop(ctx) + 1; lua_pushvalue(ctx, mrvIdx); bool vsSuccess = lua_pcall(ctx, 0, LUA_MULTRET) == LUA_OK; int vsSize = lua_gettop(ctx) + 1 - vsBegin;

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

 print(1, vs, 5); //  1 2 3 4 5

समतुल्य कूट

 lua_pushvalue(ctx, printIdx); int oldTop = lua_gettop(ctx); lua_pushInteger(ctx, 1); lua_pushvalue(ctx, mrvIdx); for(auto i = 0; i < vsSize; ++i) lua_pushvalue(ctx, vsBegin + i); lua_pushinteger(ctx, 5); int nArgs = lua_gettop(ctx) - oldtop; lua_call(ctx, nArgs, 0);

Valset . STL- STL, «» Valref . Valset , push_back pop_back . Valref , ( Valset ), . , .

, Value- , :

 string s = "The answer to question " & val & " is " & 42;

 lua_pushstring(ctx, "The answer to question "); lua_pushvalue(ctx, valIdx); lua_pushstring(ctx, " is "); lua_pushinteger(ctx, 42); lua_concat(ctx, 4); string s = lua_tostring(ctx, -1); lua_pop(ctx, 1);

& . , «» . , Valset .

Lua, .

5.2 , , «» ^ .

, Table , Valref . , , , . raw , , , iterate , for_each . , iterate ( , , ), -. Valref true , false , . :

 Table t = ctx.global["myTable"]; t.iterate([] (Valref k, Valref v) { cout << int(k) << int(v); });

 lua_getglobal(ctx, "myTable"); if(!lua_istable(ctx, -1)){ lua_pushstring(ctx, "Conversion error"); return lua_error(ctx); } int t = lua_gettop(ctx); lua_pushnil(ctx); size_t visited = 0; while(lua_next(ctx, t)) { ++ visited; if(!lua_isnumber(ctx, -2) || !lua_isnumber(ctx, -1)){ lua_pushstring(ctx, "Conversion error"); return lua_error(ctx); } cout << lua_tointeger(ctx, -2) << lua_tointeger(ctx, -1); lua_pop(ctx, 1); }

iterate .

Table — array records . .

 fn(Table::array(ctx, "one", 42, Table::array(ctx, 1, 2, 3))); //  ? !

 lua_pushvalue(ctx, fn); lua_createtable(ctx, 3, 0); lua_pushinteger(ctx, 1); lua_pushstring(ctx, "one"); lua_settable(ctx, -3); lua_pushinteger(ctx, 2); lua_pushinteger(ctx, 42); lua_settable(ctx, -3); lua_pushinteger(ctx, 3); lua_createtable(ctx, 3, 0); lua_pushinteger(ctx, 1); lua_pushinteger(ctx, 1); lua_settable(ctx, -3); lua_pushinteger(ctx, 2); lua_pushinteger(ctx, 2); lua_settable(ctx, -3); lua_pushinteger(ctx, 3); lua_pushinteger(ctx, 3); lua_settable(ctx, -3); lua_settable(ctx, -3); lua_call(ctx, 1, 0);

, . , array , 1. , Valset .

records , -. .

 x.mt() = Table::records(ctx, "__index", xRead, "__newindex", xWrite, "__gc", xDestroy );

 lua_createtable(ctx, 0, 3); lua_pushstring(ctx, "__index"); lua_pushlightuserdata(ctx, reinterpret_cast<void*>(&xRead)); lua_pushcclosure(ctx, &wrapped_signature_1, 1); lua_settable(ctx, -3); lua_pushstring(ctx, "__newindex"); lua_pushlightuserdata(ctx, reinterpret_cast<void*>(&xWrite)); lua_pushcclosure(ctx, &wrapped_signature_2, 1); lua_settable(ctx, -3); lua_pushstring(ctx, "__gc"); lua_pushlightuserdata(ctx, reinterpret_cast<void*>(&xDestroy)); lua_pushcclosure(ctx, &wrapped_signature_3, 1); lua_settable(ctx, -3); lua_setmetatable(ctx, x);

. - , : , cast , .
. LUAPP_USERDATA . , , . , registry -, :

 LUAPP_USERDATA(MyType, "MyType Lua ID") Retval setup(Context& ctx) { ctx.mt<MyType>() = Table::records(ctx); //   ,     ctx.registry["MyType Lua ID"] }

Lua . , , «» , — .

Lua , Lua . Lua API++ placement new , , . POD-. , , .

. , -, , . , Lua , :

 #include <vector> using dvec = std::vector<double>; //      LUAPP_USERDATA(dvec, "Number array") //      dvec aCreate(size_t size) //    . { //  -       . return dvec(size); //  RVO        } void aDestroy(dvec& self) //  -        . { self.~dvec(); } void aWrite(dvec& self, size_t index, double val) //          __newindex { self.at(index) = val; //     at,     Lua } Retval setup(Context& c) { //   c.mt<dvec>() = Table::records(c, //     "__index", static_cast<double& (dvec::*)(size_t)> (&dvec::at), //         at //    (const  -const),      "__newindex", aWrite, "__len", dvec::size, //   size  vector ,    "__gc", aDestroy ); c.global["createArray"] = aCreate; //      return c.ret(); }

निष्कर्ष

, Lua . Lua API ++, . Lua Lua API (coroutine, string buffers, ).

, Lua API, Lua. inline , Lua API , , Link time code generation (LTO GCC). header-only. inline Lua.

, C++11 , Lua STL. Boost Unit Test Framework .

Lua 5.2 ( 5.3 ), 5.1, LuaJIT.

Lua API++ MIT — , Lua, . HTML, .

, - .

लुआ एपीआई ++

प्रमुख अभिनेता

State

LFunction

Context

मूल्य

Valref

अस्थायी

एंकर

State

हैंडलिंग में त्रुटि

LFunction

Context

मान लौटाएं

रिपोर्टिंग में त्रुटि

पर्यावरण तक पहुंच

कार्यों

मान पलायन

एकल मूल्य संचालन

असाइनमेंट

metatables

लंबाई

अनुक्रमण

फंक्शन कॉल

एकाधिक वापसी मान

निष्कर्ष

More articles:

`State`

`LFunction`

`Context`

`Valref`

`State`

`LFunction`

`Context`