जिनजा 2 सी ++ दुनिया में, भाग दो। प्रतिपादन

यह जिन्जा 2 टेम्पलेट इंजन को C ++ में पोर्ट करने के बारे में कहानी का दूसरा भाग है। आप यहां पहले एक को पढ़ सकते हैं: तीसरा-ऑर्डर टेम्प्लेट, या मैंने जिन्जा 2 को C ++ में कैसे पोर्ट किया । यह टेंडर देने की प्रक्रिया पर ध्यान केंद्रित करेगा। या, दूसरे शब्दों में, एक अजगर की तरह भाषा की व्याख्या करने वाले से लिखने के बारे में।

इस तरह प्रतिपादन

पार्स करने के बाद, टेम्प्लेट तीन प्रकार के नोड्स वाले पेड़ में बदल जाता है: सादा पाठ , गणना की गई अभिव्यक्तियाँ और नियंत्रण संरचनाएँ । तदनुसार, रेंडरिंग प्रक्रिया के दौरान, सादा पाठ को आउटपुट स्ट्रीम में किसी भी बदलाव के बिना रखा जाना चाहिए, अभिव्यक्तियों की गणना की जानी चाहिए, पाठ में परिवर्तित की जाएगी, जिसे स्ट्रीम में रखा जाएगा, और नियंत्रण संरचनाओं को निष्पादित किया जाना चाहिए। पहली नज़र में, प्रतिपादन प्रक्रिया को लागू करने में कुछ भी जटिल नहीं था: आपको बस पेड़ के सभी नोड्स के चारों ओर जाने की जरूरत है, सब कुछ की गणना करें, सब कुछ निष्पादित करें और पाठ उत्पन्न करें। सब कुछ सरल है। वास्तव में जब तक दो शर्तें पूरी होती हैं: ए) सभी काम केवल एक ही प्रकार के स्ट्रिंग (स्ट्रिंग या wstring) के साथ किया जाता है; b) केवल बहुत ही सरल भाव और मूल का उपयोग किया जाता है। वास्तव में, यह ऐसे प्रतिबंधों के साथ है जो कि inja और Jinja2CppLight लागू हैं। मेरे जिंजाकोप के मामले में , दोनों स्थितियां काम नहीं करती हैं। सबसे पहले, मैंने शुरू में दोनों प्रकार के तारों के लिए पारदर्शी समर्थन दिया। दूसरे, पूरे विकास की शुरुआत सिर्फ जिन्जा 2 विनिर्देशन को लगभग पूरा करने के लिए की गई थी, और यह, संक्षेप में, एक पूर्ण पटकथा वाली भाषा है। इसलिए, मुझे पार्सिंग के साथ प्रतिपादन के साथ गहरी खुदाई करनी पड़ी।

अभिव्यक्ति का मूल्यांकन

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

{% set param1=10 %} {{ param1 }} 

इसके प्रतिपादन के परिणामस्वरूप, पाठ 10 प्राप्त होगा
विकल्प थोड़ा और अधिक जटिल है:

 {% set param1=10 %} {{ param1 }} {% for param1 in range(10) %}-{{ param1 }}-{% endfor %} {{ param1 }} 

रेंडर 10-0--1--2--3--4--5--6--7--8--9-10
चक्र एक नया स्कोप उत्पन्न करता है जिसमें आप अपने स्वयं के परिवर्तनीय मापदंडों को परिभाषित कर सकते हैं, और ये पैरामीटर स्कोप के बाहर दिखाई नहीं देंगे, जैसे कि वे बाहरी एक ही पैरामीटर के मानों को पीसेंगे नहीं। यहां तक ​​कि निर्माण के साथ पेचीदा / ब्लॉक निर्माण भी होता है, लेकिन जिनजा 2 प्रलेखन में इसके बारे में पढ़ना बेहतर है।

इस प्रकार, गणना का संदर्भ प्रकट होता है। या बल्कि, सामान्य रूप में प्रतिपादन:

 class RenderContext { public: RenderContext(const InternalValueMap& extValues, IRendererCallback* rendererCallback); InternalValueMap& EnterScope(); void ExitScope(); auto FindValue(const std::string& val, bool& found) const { for (auto p = m_scopes.rbegin(); p != m_scopes.rend(); ++ p) { auto valP = p->find(val); if (valP != p->end()) { found = true; return valP; } } auto valP = m_externalScope->find(val); if (valP != m_externalScope->end()) { found = true; return valP; } found = false; return m_externalScope->end(); } auto& GetCurrentScope() const; auto& GetCurrentScope(); auto& GetGlobalScope(); auto GetRendererCallback(); RenderContext Clone(bool includeCurrentContext) const; private: InternalValueMap* m_currentScope; const InternalValueMap* m_externalScope; std::list<InternalValueMap> m_scopes; IRendererCallback* m_rendererCallback; }; 

यहाँ से ।

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

अब मापदंडों के बारे में थोड़ा। बाहरी इंटरफ़ेस (और उसके उपयोगकर्ताओं) के दृष्टिकोण से, Jinja2 मान्य प्रकारों की निम्नलिखित सूची का समर्थन करता है:

• संख्या (इंट, डबल)
• स्ट्रिंग्स (संकीर्ण, चौड़ी)
• bool
• ऐरे (अधिक आयामहीन ट्यूपल्स की तरह)
• शब्दकोशों
• प्रतिबिंबित C ++ संरचनाएं

यह सब बढ़ावा देने के आधार पर बनाए गए एक विशेष डेटा प्रकार द्वारा वर्णित किया गया है :: संस्करण:

 using ValueData = boost::variant<EmptyValue, bool, std::string, std::wstring, int64_t, double, boost::recursive_wrapper<ValuesList>, boost::recursive_wrapper<ValuesMap>, GenericList, GenericMap>; class Value { public: Value() = default; template<typename T> Value(T&& val, typename std::enable_if<!std::is_same<std::decay_t<T>, Value>::value>::type* = nullptr) : m_data(std::forward<T>(val)) { } Value(const char* val) : m_data(std::string(val)) { } template<size_t N> Value(char (&val)[N]) : m_data(std::string(val)) { } Value(int val) : m_data(static_cast<int64_t>(val)) { } const ValueData& data() const {return m_data;} ValueData& data() {return m_data;} private: ValueData m_data; }; 

यहाँ से ।

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

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

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

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

 struct StringJoiner : BaseVisitor<> { using BaseVisitor::operator (); InternalValue operator() (EmptyValue, const std::string& str) const { return str; } InternalValue operator() (const std::string& left, const std::string& right) const { return left + right; } }; 

यहाँ से ।

इस तरह के एक आगंतुक को बहुत सरलता से कहा जाता है:

 InternalValue delimiter = m_args["d"]->Evaluate(context); for (const InternalValue& val : values) { if (isFirst) isFirst = false; else result = Apply2<visitors::StringJoiner>(result, delimiter); result = Apply2<visitors::StringJoiner>(result, val); } 

Apply2 यहाँ boost::apply_visitor लिए एक आवरण है boost::apply_visitor , जो टेम्पलेट पैरामीटर द्वारा निर्दिष्ट प्रकार के विज़िटर को विभिन्न प्रकार के मानों की एक जोड़ी पर लागू करता है, पहले यदि आवश्यक हो तो कुछ रूपांतरण कर रहा है। यदि विज़िटर के डिज़ाइनर को मापदंडों की आवश्यकता होती है, तो वे उन वस्तुओं के बाद पारित हो जाते हैं, जिन पर आगंतुक लागू होता है:

 comparator = [](const KeyValuePair& left, const KeyValuePair& right) { return ConvertToBool(Apply2<visitors::BinaryMathOperation>(left.value, right.value, BinaryExpression::LogicalLt, BinaryExpression::CaseSensitive)); }; 

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

फिल्टर और टेस्ट

जिन्जा 2 में "मानक पुस्तकालय" को अन्य भाषाओं में "फिल्टर" कहा जाता है। संक्षेप में, एक फ़िल्टर '' | 'साइन के बाईं ओर के मान पर एक प्रकार का जटिल ऑपरेशन है, जिसका परिणाम एक नया मूल्य होगा। पाइप लाइन को व्यवस्थित करके एक श्रृंखला में फिल्टर की व्यवस्था की जा सकती है:
{{ menuItems | selectattr('visible') | map(attribute='title') | map('upper') | join(' -> ') }}
यहां, केवल उन तत्वों को दिखाया गया है, जो वास्तविक पर सेट किए गए दृश्यमान मेनू मेनू से चुने जाएंगे, फिर शीर्षक विशेषता को इन तत्वों से लिया जाएगा, ऊपरी मामले में परिवर्तित किया जाएगा, और परिणामी सूची को विभाजक के साथ चिपका दिया जाएगा ->> एक पंक्ति में। या, जीवन से एक उदाहरण के रूप में कहें:

 {% macro MethodsDecl(class, access) %} {% for method in class.methods | rejectattr('isImplicit') | selectattr('accessType', 'in', access) %} {{ method.fullPrototype }}; {% endfor %} {% endmacro %} 

यहाँ से ।

 {% macro MethodsDecl(class, access) %} {{ for method in class.methods | rejectattr('isImplicit') | selectattr('accessType', 'in', access) | map(attribute='fullPrototype') | join(';\n') }}; {% endmacro %} 

यह मैक्रो दिए गए वर्ग के सभी तरीकों पर आधारित है, जिनके लिए isImplicit विशेषता सही पर सेट है, को छोड़ देता है, शेष लोगों का चयन करता है जिनके लिए accessType विशेषता का मान दिए गए में से एक से मेल खाता है, और उनके प्रोटोटाइप प्रदर्शित करता है। अपेक्षाकृत स्पष्ट। और यह तीन मंजिला चक्रों की तुलना में आसान है और यदि बाड़ लगाना है। वैसे, C ++ में भी कुछ ऐसा ही किया जा सकता है।

दरअसल, समय में मुख्य चूक लगभग चालीस फिल्टर के कार्यान्वयन से जुड़ी थी, जिसे मैंने मूल सेट में शामिल किया था। किसी कारण से मुझे लगा कि मैं इसे एक या दो सप्ताह में संभाल सकता हूं। यह बहुत आशावादी था। और हालांकि फ़िल्टर का विशिष्ट कार्यान्वयन काफी सरल है: एक मूल्य लें और इसमें कुछ फ़ंक्टर लगाओ, उनमें से बहुत सारे थे, और मुझे टिंकर करना पड़ा।
कार्यान्वयन प्रक्रिया में एक अलग दिलचस्प कार्य प्रसंस्करण तर्कों का तर्क था। जिनजा 2 में, अजगर के रूप में, कॉल के लिए दिए गए तर्क या तो नाम या स्थितिगत हो सकते हैं। और फ़िल्टर घोषणा में पैरामीटर या तो अनिवार्य या वैकल्पिक हो सकते हैं (डिफ़ॉल्ट मानों के साथ)। इसके अलावा, C ++ के विपरीत, वैकल्पिक पैरामीटर विज्ञापन में कहीं भी स्थित हो सकते हैं। विभिन्न मामलों को ध्यान में रखते हुए, इन दो सूचियों के संयोजन के लिए एक एल्गोरिथ्म के साथ आना आवश्यक था। यहाँ, मान लें कि, एक रेंज फंक्शन है: range([start, ]stop[, step]) । इसे निम्नलिखित तरीकों से बुलाया जा सकता है:

 range(10) // -> range(start = 0, stop = 10, step = 1) range(1, 10) // -> range(start = 1, stop = 10, step = 1) range(1, 10, 3) // -> range(start = 1, stop = 10, step = 3) range(step=2, 10) // -> range(start = 0, stop = 10, step = 2) range(2, step=2, 10) // -> range(start = 2, stop = 10, step = 2) 

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

 ParsedArguments ParseCallParams(const std::initializer_list<ArgumentInfo>& args, const CallParams& params, bool& isSucceeded) { struct ArgInfo { ArgState state = NotFound; int prevNotFound = -1; int nextNotFound = -1; const ArgumentInfo* info = nullptr; }; boost::container::small_vector<ArgInfo, 8> argsInfo(args.size()); boost::container::small_vector<ParamState, 8> posParamsInfo(params.posParams.size()); isSucceeded = true; ParsedArguments result; int argIdx = 0; int firstMandatoryIdx = -1; int prevNotFound = -1; int foundKwArgs = 0; // Find all provided keyword args for (auto& argInfo : args) { argsInfo[argIdx].info = &argInfo; auto p = params.kwParams.find(argInfo.name); if (p != params.kwParams.end()) { result.args[argInfo.name] = p->second; argsInfo[argIdx].state = Keyword; ++ foundKwArgs; } else { if (argInfo.mandatory) { argsInfo[argIdx].state = NotFoundMandatory; if (firstMandatoryIdx == -1) firstMandatoryIdx = argIdx; } else { argsInfo[argIdx].state = NotFound; } if (prevNotFound != -1) argsInfo[prevNotFound].nextNotFound = argIdx; argsInfo[argIdx].prevNotFound = prevNotFound; prevNotFound = argIdx; } ++ argIdx; } int startPosArg = firstMandatoryIdx == -1 ? 0 : firstMandatoryIdx; int curPosArg = startPosArg; int eatenPosArgs = 0; // Determine the range for positional arguments scanning bool isFirstTime = true; for (; eatenPosArgs < posParamsInfo.size(); ++ eatenPosArgs) { if (isFirstTime) { for (; startPosArg < args.size() && (argsInfo[startPosArg].state == Keyword || argsInfo[startPosArg].state == Positional); ++ startPosArg) ; isFirstTime = false; continue; } int prevNotFound = argsInfo[startPosArg].prevNotFound; if (prevNotFound != -1) { startPosArg = prevNotFound; } else if (curPosArg == args.size()) { break; } else { int nextPosArg = argsInfo[curPosArg].nextNotFound; if (nextPosArg == -1) break; curPosArg = nextPosArg; } } // Map positional params to the desired arguments int curArg = startPosArg; for (int idx = 0; idx < eatenPosArgs && curArg != -1; ++ idx, curArg = argsInfo[curArg].nextNotFound) { result.args[argsInfo[curArg].info->name] = params.posParams[idx]; argsInfo[curArg].state = Positional; } // Fill default arguments (if missing) and check for mandatory for (int idx = 0; idx < argsInfo.size(); ++ idx) { auto& argInfo = argsInfo[idx]; switch (argInfo.state) { case Positional: case Keyword: continue; case NotFound: { if (!IsEmpty(argInfo.info->defaultVal)) result.args[argInfo.info->name] = std::make_shared<ConstantExpression>(argInfo.info->defaultVal); break; } case NotFoundMandatory: isSucceeded = false; break; } } // Fill the extra positional and kw-args for (auto& kw : params.kwParams) { if (result.args.find(kw.first) != result.args.end()) continue; result.extraKwArgs[kw.first] = kw.second; } for (auto idx = eatenPosArgs; idx < params.posParams.size(); ++ idx) result.extraPosArgs.push_back(params.posParams[idx]); return result; } 

इसे इस तरह कहा जाता है (जैसे, कहते हैं, range ):

 bool isArgsParsed = true; auto args = helpers::ParseCallParams({{"start"}, {"stop", true}, {"step"}}, m_params, isArgsParsed); if (!isArgsParsed) return InternalValue(); 

और निम्न संरचना लौटाता है:

 struct ParsedArguments { std::unordered_map<std::string, ExpressionEvaluatorPtr<>> args; std::unordered_map<std::string, ExpressionEvaluatorPtr<>> extraKwArgs; std::vector<ExpressionEvaluatorPtr<>> extraPosArgs; ExpressionEvaluatorPtr<> operator[](std::string name) const { auto p = args.find(name); if (p == args.end()) return ExpressionEvaluatorPtr<>(); return p->second; } }; 

आवश्यक तर्क जिसमें से इसे केवल इसके नाम से लिया गया है:

 auto startExpr = args["start"]; auto stopExpr = args["stop"]; auto stepExpr = args["step"]; InternalValue startVal = startExpr ? startExpr->Evaluate(values) : InternalValue(); InternalValue stopVal = stopExpr ? stopExpr->Evaluate(values) : InternalValue(); InternalValue stepVal = stepExpr ? stepExpr->Evaluate(values) : InternalValue(); 

मैक्रोज़ और परीक्षकों के साथ काम करते समय एक समान तंत्र का उपयोग किया जाता है। और यद्यपि प्रत्येक फ़िल्टर और परीक्षण के तर्कों का वर्णन करने में कुछ भी जटिल नहीं लगता है, लेकिन ऐसा नहीं है (इसे कैसे लागू किया जाए), लेकिन यहां तक ​​कि "मूल" सेट, जिसमें लगभग पचास और अन्य शामिल थे, कार्यान्वयन के लिए काफी हद तक सही थे। और यह प्रदान करता है कि इसमें सभी प्रकार की मुश्किल चीजें शामिल नहीं थीं, जैसे HTML (या C ++) के लिए स्ट्रिंग्स को प्रारूपित करना, xml या json जैसे प्रारूपों में आउटपुट मान, और इसी तरह।

अगले भाग में, हम कई टेम्पलेट्स (निर्यात, शामिल, मैक्रोज़) के साथ काम के कार्यान्वयन पर ध्यान केंद्रित करेंगे, साथ ही त्रुटि से निपटने और विभिन्न चौड़ाई के तारों के साथ काम करने के साथ आकर्षक कारनामों पर भी ध्यान केंद्रित करेंगे।

परंपरागत रूप से, लिंक:

जिनजा 2 विशिष्टता
Jinja2Cpp कार्यान्वयन