🐦 ✂️ 🌪️ यूनिवर्सल डीएसएल। क्या यह संभव है? 🔣 🐾 🤽🏽

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

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

परिचय

एप्लिकेशन प्रोजेक्ट को विकसित करने के दो तरीके हैं: इसे इतना सरल बनाने के लिए कि यह स्पष्ट है कि इसकी कोई कमी नहीं है, या इसे इतना जटिल बनाना है कि इसमें स्पष्ट कमियां न हों। सी। ई। आर। होर (कार होरे)

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

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

प्रोग्रामिंग प्रोग्रामिंग की प्रक्रिया का मुख्य लक्ष्य प्रोग्रामिंग और प्रोग्राम पढ़ने की प्रक्रिया को सरल बनाना है। मशीन कोड की तुलना में asm में लिखना आसान है, C में लिखना asm की तुलना में आसान है, C # में भी सरल है और इसी तरह।

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

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

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

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

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

यदि सफलतापूर्वक लागू किया जाता है, तो यह दृष्टिकोण सिस्टम के व्यवहार को परिभाषित और विस्तारित करने वाली कॉम्पैक्ट स्क्रिप्ट लिखने की संभावना के कारण विकसित होने वाले उत्पाद के लचीलेपन को काफी बढ़ा सकता है। इस दृष्टिकोण के लिए कई अनुप्रयोग हो सकते हैं, जैसा कि इस दृष्टिकोण की व्यापकता से पता चलता है, क्योंकि DSL हर जगह है। आम HTML एक दस्तावेज़ विवरण भाषा है, SQL एक संरचित क्वेरी भाषा है, JSON एक संरचित डेटा विवरण भाषा, XAML, पोस्टस्क्रिप्ट, Emacs लिस्प, nnCron और कई अन्य है।

सभी फायदों के साथ, सिस्टम डेवलपर के लिए DSL की एक महत्वपूर्ण कमी है - उच्च आवश्यकताएं।

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

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

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

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

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

इस तरह की लचीलापन इन भाषाओं को सार्वभौमिक डीएसएल इंजन की भूमिका के लिए अच्छा उम्मीदवार बनाती है।

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

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

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

इस पोस्ट में, मैं फोर्ट भाषा का एक सरल दुभाषिया बनाने का प्रस्ताव करता हूं और दिखाता हूं कि विशिष्ट समस्याओं को हल करने के लिए इसे कैसे अनुकूलित किया जाए।

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

पता दुभाषिया

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

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

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

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

हमारे किले की मशीन में लीनियर मेमोरी, डेटा स्टैक, रिटर्न स्टैक, इंस्ट्रक्शन पॉइंटर, वर्ड पॉइंटर होते हैं। आदिमों को संग्रहीत करने के लिए हमारे पास एक अलग स्थान होगा।

public object[] Mem; //   public Stack<int> RS; //   public Stack<object> DS; //   public int IP; //   public int WP; //   public delegate void CoreCall(); public List<CoreCall> Core; //

व्याख्या का सार स्मृति में पते पर नेविगेट करना और वहां बताए गए निर्देश को निष्पादित करना है। पूरा पता दुभाषिया - भाषा का दिल - हमारे मामले में एक फ़ंक्शन में परिभाषित किया जाएगा अगला ()।

 public void Next() { while (true) { if (IP == 0) return; WP = (int)Mem[IP++]; Core[(int)Mem[WP]](); } }

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

 public void DoList() { RS.Push(IP); IP = WP + 1; }

शब्द से बाहर निकलने के लिए, एक्जिट कमांड का उपयोग करें, जो रिटर्न स्टैक से पते को पुनर्स्थापित करता है।

 public void Exit() { IP = RS.Pop(); }

दुभाषिया के सिद्धांत के एक दृश्य प्रदर्शन के लिए, हम एक कमांड पेश करते हैं, यह उपयोगी काम का अनुकरण करेगा। चलो इसे हैलो कहते हैं ()।

 public void Hello() { Console.WriteLine("Hello"); }

सबसे पहले आपको मशीन को इनिशियलाइज़ करने की ज़रूरत है और दुभाषिए के लिए सही तरीके से काम करने के लिए प्राइमिटिव्स को निर्दिष्ट करना है। आपको प्रोग्राम मेमोरी में प्रिमिटिव के पते भी निर्दिष्ट करने होंगे।

 Mem = new Object[1024]; RS = new Stack<int>(); DS = new Stack<object>(); Core = new List<CoreCall>(); Core.Add(Next); Core.Add(DoList); Core.Add(Exit); Core.Add(Hello); const int opNext = 0; const int opDoList = 1; const int opExit = 2; const int opHello = 3; // core pointers Mem[opNext] = opNext; Mem[opDoList] = opDoList; Mem[opExit] = opExit; Mem[opHello] = opHello;

अब हम एक साधारण प्रोग्राम बना सकते हैं, हमारे मामले में, उपयोगकर्ता कोड पता 4 पर शुरू होगा और इसमें दो उपप्रोग्राम शामिल होंगे। पहली दिनचर्या पता 7 से शुरू होती है और दूसरे को कॉल करती है, जो पता 4 से शुरू होती है और हैलो शब्द को प्रदर्शित करती है।

 // program Mem[4] = opDoList; // 3)    IP = 9   ,   IP = WP + 1 = 5 Mem[5] = opHello; // 4)     Mem[6] = opExit; // 5)   ,  IP = 9    Mem[7] = opDoList; // 1)     Mem[8] = 4; // 2)     4,  WP = 4 Mem[9] = opExit; // 6)   ,  IP = 0

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

 var entryPoint = 7; //    IP = 0; //  IP = 0,        WP = entryPoint; //  WP = 7      DoList(); //     ,  IP = 0    Next(); //

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

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

पाठ दुभाषिया

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

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

 public Dictionary<string, List<WordHeader>> Entries;

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

 public class WordHeader { public int Address; public bool Immediate; }

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

हम इसका उपयोग करने के लिए TextReader का उपयोग इनपुट स्ट्रीम, और TextWriter को पढ़ने के लिए करेंगे।

 public TextReader Input; public TextWriter Output;

उपरोक्त योजना के अनुसार दुभाषिया का कार्यान्वयन एक कार्य में होगा दुभाषिया ()।

 void Interpreter() { while (true) { var word = ReadWord(Input); if (string.IsNullOrWhiteSpace(word)) return; // EOF var lookup = LookUp(word); if (IsEvalMode) { if (lookup != null) { Execute(lookup.Address); } else if (IsConstant(word)) { DS.Push(ParseNumber(word)); } else { DS.Clear(); Output.WriteLine($"The word {word} is undefined"); } } else { // program mode if (lookup != null) { if (lookup.Immediate) { Execute(lookup.Address); } else { AddOp(lookup.Address); } } else if (IsConstant(word)) { AddOp(LookUp("doLit").Address); AddOp(ParseNumber(word)); } else { IsEvalMode = true; DS.Clear(); Output.WriteLine($"The word {word} is undefined"); } } } }

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

 static string ReadWord(TextReader sr) { var sb = new StringBuilder(); var code = sr.Read(); while (IsWhite((char)code) && code > 0) { code = sr.Read(); } while (!IsWhite((char)code) && code > 0) { sb.Append((char)code); code = sr.Read(); } return sb.ToString(); } static bool IsWhite(char c) { return " \n\r\t".Any(ch => ch == c); }

शब्द को पढ़ने के बाद, इसे शब्दकोश में खोजने का प्रयास किया जाता है। यदि सफल, शब्द का शीर्षक वापस आ गया है, अन्यथा, अशक्त।

 public WordHeader LookUp(string word) { if (Entries.ContainsKey(word)) { return Entries[word].Last(); } return null; }

आप यह जांच सकते हैं कि दर्ज किया गया मान पहले दो वर्णों की संख्या है या नहीं। यदि पहला वर्ण एक संख्या है, तो हम मान लेते हैं कि यह एक संख्या है। यदि पहला वर्ण "+" या "-" चिन्ह है, और दूसरा एक अंक है, तो सबसे अधिक संभावना है कि यह भी एक संख्या है।

 static bool IsConstant(string word) { return IsDigit(word[0]) || (word.Length >= 2 && (word[0] == '+' || word[0] == '-') && IsDigit(word[1])); }

स्ट्रिंग को एक संख्या में बदलने के लिए, आप मानक विधियों Int32.TryParse और Double.TryParse का उपयोग कर सकते हैं। लेकिन वे कई कारणों से गति में भिन्न नहीं होते हैं, इसलिए मैं एक कस्टम समाधान का उपयोग करता हूं।

 static object ParseNumber(string str) { var factor = 1.0; var sign = 1; if (str[0] == '-') { sign = -1; str = str.Remove(0, 1); } else if (str[0] == '+') { str = str.Remove(0, 1); } for (var i = str.Length - 1; i >= 0; i--) { if (str[i] == '.') { str = str.Remove(i, 1); return IntParseFast(str) * factor * sign; } factor *= 0.1; } return IntParseFast(str) * sign; } static int IntParseFast(string value) { // An optimized int parse method. var result = 0; foreach (var c in value) { if (!(c >= '0' && c <= '9')) return result; // error result = 10 * result + (c - 48); } return result; }

ParseNumber विधि पूर्णांक मान और फ़्लोटिंग पॉइंट संख्या दोनों को परिवर्तित कर सकती है, उदाहरण के लिए, "1.618"।

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

 public void Execute(int address) { try { if (address < Core.Count) { // eval core Core[address](); // invoke core function } else { // eval word IP = 0; // set return address WP = address; // set eval address DoList(); // fake doList Next(); // run evaluator } } catch (Exception e) { Output.WriteLine(e.Message); var wpEntry = Entries.FirstOrDefault(d => d.Value.Any(en => en.Address == WP)); var ipEntry = Entries.FirstOrDefault(d => d.Value.Any(en => en.Address == SearchKnowAddress(IP))); Output.WriteLine($"WP = {WP:00000} - '{wpEntry.Key}', IP = {IP:00000} - '{ipEntry.Key}'"); if (RS.Any()) { Output.WriteLine("Stack trace..."); foreach (var a in RS) { var ka = SearchKnowAddress(a); var sEntry = Entries.FirstOrDefault(d => d.Value.Any(en => en.Address == ka)); Output.WriteLine($"...{a:00000} -- {sEntry.Key}"); } RS.Clear(); DS.Clear(); } else if (address < Core.Count) { var entry = Entries.FirstOrDefault(d => d.Value.Any(en => en.Address == address)); Output.WriteLine($"Core word is {entry.Key}"); } IP = WP = 0; } }

जब दुभाषिया संकलन मोड में है और शब्द तत्काल निष्पादन के लिए चिह्नित नहीं है, तो इसका पता स्मृति को लिखा जाना चाहिए।

 public void AddOp(object op) { Mem[Here++] = op; }

यहाँ चर अगले मुफ्त सेल का पता संग्रहीत करता है। चूंकि यह चर फोर्ट भाषा के एक चर के रूप में रनटाइम वातावरण से सुलभ होना चाहिए, इसलिए यहां दिए गए मूल्य को प्रोग्राम मेमोरी में एक ऑफसेट पर संग्रहीत किया जाता है।

 public int _hereShift; public int Here { get => (int)Mem[_hereShift]; set => Mem[_hereShift] = value; }

व्याख्या के दौरान एक संख्यात्मक निरंतर और एक शब्द पते के बीच अंतर करने के लिए, संकलन के दौरान प्रत्येक निरंतर से पहले doLit शब्द का संकलन होता है, जो मेमोरी में अगले मूल्य को पढ़ता है और इसे डेटा स्टैक पर रखता है।

 public void DoLit() { DS.Push(Mem[IP++]); }

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

यहाँ वर्णित दुभाषिया में, मैंने मूल शब्दों के शब्दकोश को अनावश्यक रूप से नहीं बढ़ाने का भी प्रयास किया। लेकिन .net प्लेटफ़ॉर्म के साथ एकीकरण में आसानी के लिए, मैंने गणित, बुलियन संचालन को लागू करने का फैसला किया, और निश्चित रूप से, आदिम के सेट के माध्यम से प्रतिबिंब। इसी समय, किले कार्यान्वयन में प्रायः कुछ शब्द जो आदिम हैं, दुभाषिया के माध्यम से कार्यान्वयन का अर्थ करते हुए, यहां गायब हैं।

लेखन के समय, मूल सेट 68 शब्द है।

 // Core SetCoreWord("nop", Nop); SetCoreWord("next", Next); SetCoreWord("doList", DoList); SetCoreWord("exit", Exit); SetCoreWord("execute", Execute); SetCoreWord("doLit", DoLit); SetCoreWord(":", BeginDefWord); SetCoreWord(";", EndDefWord, true); SetCoreWord("branch", Branch); SetCoreWord("0branch", ZBranch); SetCoreWord("here", GetHereAddr); SetCoreWord("quit", Quit); SetCoreWord("dump", Dump); SetCoreWord("words", Words); SetCoreWord("'", Tick); SetCoreWord(",", Comma); SetCoreWord("[", Lbrac, true); SetCoreWord("]", Rbrac); SetCoreWord("immediate", Immediate, true); // Mem SetCoreWord("!", WriteMem); SetCoreWord("@", ReadMem); SetCoreWord("variable", Variable); SetCoreWord("constant", Constant); // RW SetCoreWord(".", Dot); SetCoreWord(".s", DotS); SetCoreWord("cr", Cr); SetCoreWord("bl", Bl); SetCoreWord("word", ReadWord, true); SetCoreWord("s\"", ReadString, true); SetCoreWord("key", Key); // Comment SetCoreWord("(", Comment, true); SetCoreWord("\\", CommentLine, true); // .net mem SetCoreWord("null", Null); SetCoreWord("new", New); SetCoreWord("type", GetType); SetCoreWord("m!", SetMember); SetCoreWord("m@", GetMember); SetCoreWord("ms@", GetStaticMember); SetCoreWord("ms!", SetStaticMember); SetCoreWord("load-assembly", LoadAssembly); SetCoreWord("invk", invk); // Boolean SetCoreWord("true", True); SetCoreWord("false", False); SetCoreWord("and", And); SetCoreWord("or", Or); SetCoreWord("xor", Xor); SetCoreWord("not", Not); SetCoreWord("invert", Invert); SetCoreWord("=", Eql); SetCoreWord("<>", NotEql); SetCoreWord("<", Less); SetCoreWord(">", Greater); SetCoreWord("<=", LessEql); SetCoreWord(">=", GreaterEql); // Math SetCoreWord("-", Minus); SetCoreWord("+", Plus); SetCoreWord("*", Multiply); SetCoreWord("/", Devide); SetCoreWord("mod", Mod); SetCoreWord("1+", Inc); SetCoreWord("1-", Dec); // Stack SetCoreWord("drop", Drop); SetCoreWord("swap", Swap); SetCoreWord("dup", Dup); SetCoreWord("over", Over); SetCoreWord("rot", Rot); SetCoreWord("nrot", Nrot);

नए उपयोगकर्ता शब्दों को परिभाषित करने के लिए, दो कर्नेल शब्दों का उपयोग किया जाता है: ":" और ";"। शब्द ":" इनपुट स्ट्रीम से एक नए शब्द का नाम पढ़ता है, इस कुंजी के साथ एक हेडर बनाता है, बेस शब्द doList का पता प्रोग्राम मेमोरी में जोड़ा जाता है, और दुभाषिया को संकलन मोड में डाल दिया जाता है। इसके बाद के सभी शब्दों को संकलित किया जाएगा, जिन्हें तत्काल चिह्नित किया जाएगा।

 public void BeginDefWord() { AddHeader(ReadWord(Input)); AddOp(LookUp("doList").Address); IsEvalMode = false; }

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

 Eval(": ? @ . ;"); Eval(": allot here @ + here ! ;"); Eval(": if immediate doLit [ ' 0branch , ] , here @ 0 , ;"); Eval(": then immediate dup here @ swap - swap ! ;"); Eval(": else immediate [ ' branch , ] , here @ 0 , swap dup here @ swap - swap ! ;"); Eval(": begin immediate here @ ;"); Eval(": until immediate doLit [ ' 0branch , ] , here @ - , ;"); Eval(": again immediate doLit [ ' branch , ] , here @ - , ;"); Eval(": while immediate doLit [ ' 0branch , ] , here @ 0 , ;"); Eval(": repeat immediate doLit [ ' branch , ] , swap here @ - , dup here @ swap - swap ! ;"); Eval(": // immediate [ ' \\ , ] ;"); // C like comment

मैं यहां बाकी मानक शब्दों का वर्णन नहीं करूंगा - नेटवर्क पर संबंधित विषयगत संसाधनों पर उनके बारे में पर्याप्त जानकारी है। मंच के साथ बातचीत करने के लिए, मैंने 9 शब्दों को परिभाषित किया:

"नल" - स्टैक पर नल को धक्का देता है;
"टाइप" - "TrueForth.MyClass प्रकार" शब्द के ढेर पर वर्ग प्रकार को धक्का देता है;
"नया" - स्टैक से प्रकार लेता है, वर्ग का एक उदाहरण बनाता है और इसे स्टैक पर रखता है, निर्माता तर्क देता है, यदि कोई हो, तो स्टैक पर भी होना चाहिए "शब्द TrueForth.MyClass टाइप नया";
"एम!" - स्टैक से किसी ऑब्जेक्ट, फ़ील्ड नाम, मान का एक उदाहरण लेता है और निर्दिष्ट फ़ील्ड पर एक मान प्रदान करता है;
"एम @" - स्टैक से किसी ऑब्जेक्ट का एक उदाहरण उठाता है, फ़ील्ड नाम और स्टैक से फ़ील्ड का मान लौटाता है;
"सुश्री" और "एमएस @" - पिछले वाले के समान, लेकिन स्थिर क्षेत्रों के लिए, उदाहरण के बजाय, स्टैक पर एक प्रकार होना चाहिए;
"लोड-असेंबली" - स्टैक से लेता है, इसे असेंबली में जाने देता है और मेमोरी में लोड करता है;
"Invk" - स्टैक से प्रतिनिधि, तर्क लेता है और इसे कहता है "1133 शब्द SomeMethod शब्द TrueForth.MyClass प्रकार नया m @ invk"।

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

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

 public static bool Init4Th() { Interpreter = new OForth(); if (File.Exists(InitFile)) { Interpreter.Eval(File.ReadAllText(InitFile)); return true; } else { Console.WriteLine($"  {InitFile}  !"); return false; } }

वितरण प्रणाली कॉन्फ़िगरेशन उदाहरण की रिपोर्ट करें

 ( *****   ***** ) word GetFReporter word ReportProvider.FlexReports.FReporterEntry type new m@ invk constant fr //       :  word ReportProvider.FlexReports.FDailyReport type new ; //       :  word AddReport fr m@ invk ; //          :  [ ' word , ] ; //   :  [ ' word , ] ; //   :  [ ' s" , ] ; //  ,      " :  ; //  :  dup [ ' word , ] swap word MailSql swap m! ; :  dup [ ' word , ] swap word XlsSql swap m! ; ( *****    ***** ) cr s"   " . cr cr    "  08:00  mail@tinkoff.ru   seizure.sql    ,    "  08:00  mail@tinkoff.ru   fixed-errors-top.sql   fixed-errors.sql         WO"  08:00  mail@tinkoff.ru   wo-wait-complect-dates.sql       "  07:30  mail@tinkoff.ru   top-previous-input-errors.sql   previous-input-errors.sql        "  10:00  mail@tinkoff.ru   collection-report.sql       BPM   "  08:00  mail@tinkoff.ru   bpm-inbox-report.sql       ScanDoc3   7 "  07:50  mail@tinkoff.ru   new-sd3-complects-prevew.sql   new-sd3-complects.sql  ( ******************************** ) cr s"  " . cr

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

 var interpreter = new OForth(); interpreter.DS.Push(this); // Push current instance on DataStack interpreter.Eval("constant arctium"); // Define constant with the instance if (File.Exists(ConfigName)) { interpreter.Eval(File.ReadAllText(ConfigName)); }

कॉन्फ़िगरेशन प्रोग्रामेटिक रूप से उत्पन्न होता है, यह कुछ इस तरह से निकलता है:

 s" @device:pnp:\\?\usb#vid_2b16&pid_6689&mi_00#6&1ef84f63&0&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global" s" Doccamera" word Scanning.Devices.PhotoScanner.PhotoScannerDevice type new dup s" 3264x2448, FPS:20, BIT:24" swap word SetSnapshotMode swap m@ invk dup s" 1280x720, FPS:30, BIT:24" swap word SetPreviewMode swap m@ invk word SetActiveDevice arctium m@ invk

वैसे, स्क्रिप्ट * .ps और * .pdf एक समान तरीके से उत्पन्न होते हैं, क्योंकि पोस्टस्क्रिप्ट और पीएफडी दोनों अनिवार्य रूप से "किले" का एक सबसेट हैं, लेकिन उनका उपयोग विशेष रूप से स्क्रीन या प्रिंटर पर दस्तावेजों को प्रस्तुत करने के लिए किया जाता है।

यह सांत्वना के लिए इंटरैक्टिव मोड को लागू करना आसान है और न केवल एप्लिकेशन। ऐसा करने के लिए, आपको पहले तैयार स्क्रिप्ट के माध्यम से सिस्टम को इनिशियलाइज़ करना होगा, फिर इंटरप्रिटर को स्टैंडर्ड इनपुट STIN पर सेट करके व्याख्या शुरू करनी होगी।

 var interpreter = new OForth(); const string InitFile = "Init.4th"; if (File.Exists(InitFile)) { interpreter.Eval(File.ReadAllText(InitFile)); } else { Console.WriteLine($"  {InitFile}  !"); } interpreter.Eval(Console.In); // Start interactive console

आरंभिक लिपि इस प्रकार हो सकती है:

 ( *****   ***** ) word ComplectBuilder.Program type constant main //     : mode! [ ' word , ] word Mode main ms! ; //    : init word Init main ms@ invk ; //  : load [ ' word , ] word LoadFile main ms@ invk ; //   : start word StartProcess main ms@ invk ; //   : count word Count main ms@ invk ; //   : all count ; //  ( *****  ***** ) init cr cr s"    ,     help" . cr cr ( *****  ***** ) : help s"         :" . cr s" load scandoc_test.csv 0 all start" . cr bl bl s" load scandoc_test.csv --    " . cr bl bl s" 0 all start --  ,  0      all " . cr cr s"     DEV TEST PROD:" . cr s" mode! DEV init" . cr s"     :" . cr s" word Mode main ms@ . cr" . cr ;

इनपुट के रूप में, UI के साथ टेक्स्टबॉक्स एप्लिकेशन से न केवल एक कंसोल या टेक्स्ट हो सकता है, बल्कि एक नेटवर्क भी हो सकता है। इस मामले में, आप सरल इंटरैक्टिव नियंत्रण को लागू कर सकते हैं, उदाहरण के लिए, डिबगिंग के लिए, एक सेवा, घटकों को रोकना। इस तरह के उपयोग की संभावनाएं डेवलपर की कल्पना और हल किए जाने वाले कार्य तक सीमित हैं। , UI - .

. , , .

, :

 public void Callback(string word, MulticastDelegate action) { if (string.IsNullOrWhiteSpace(word) || word.Any(c => " \n\r\t".Any(cw => cw == c))) { throw new Exception("invalid format of word"); } DS.Push(action); Eval($": {word} [ ' doLit , , ] invk ;"); }

DS.Push(action), . , , [ ], , . ' Tick , doLit, , . Comma «,» doLit, .

, . , :

 public class WoConfItem { public string ComplectType; public string Route; public string Deal; public bool IsStampQuery; }

— , :

 public class WoConfig { private OForth VM; private List<WoConfItem> _conf; public WoConfig(string confFile) { _conf = new List<WoConfItem>(); VM = new OForth(); //      VM.Callback("new-conf", new Action(ClearConf)); VM.Callback("{", new Func<WoConfItem>(NewConf)); VM.Callback("}", new Action<WoConfItem>(AddConf)); VM.Callback("complect-type", new Func<WoConfItem,string,WoConfItem>(ConfComplectType)); VM.Callback("route", new Func<WoConfItem,string,WoConfItem>(ConfRoute)); VM.Callback("deal", new Func<WoConfItem,string,WoConfItem>(ConfDeal)); VM.Callback("is-stamp-query", new Func<WoConfItem,bool,WoConfItem>(ConfIsStampQuery)); //  ,   ,       var initScript = new StringBuilder(); initScript.AppendLine(": complect-type [ ' word , ] swap complect-type ;"); initScript.AppendLine(": route [ ' word , ] swap route ;"); initScript.AppendLine(": deal [ ' word , ] swap deal ;"); initScript.AppendLine(": is-stamp-query ' execute swap is-stamp-query ;"); VM.Eval(initScript.ToString()); //   WatchConfig(confFile); } private void ReadConfig(string path) { using (var reader = new StreamReader(File.OpenRead(path), Encoding.Default)) { VM.Eval(reader); } } readonly Func<string, bool> _any = s => s == "*"; public WoConfItem GetConf(string complectType, string routeId) { return _conf?.FirstOrDefault(cr => (cr.ComplectType == complectType || _any(cr.ComplectType)) && (cr.Route == routeId || _any(cr.Route)) ); } public bool IsAllow(string complectType, string routeId) { return GetConf(complectType, routeId) != null; } void WatchConfig(string path) { var directory = Path.GetDirectoryName(path); var fileName = Path.GetFileName(path); //   ,     if (!File.Exists(path)) { if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } var sb = new StringBuilder(); sb.AppendLine("\\ WO passport configuration"); sb.AppendLine("new-conf"); sb.AppendLine(""); sb.AppendLine("\\ Config rules"); sb.AppendLine("\\ { -- begin config item, } -- end config item, * -- match any values"); sb.AppendLine("\\ Example:"); sb.AppendLine("\\ { complect-type * route offer deal 100500 is-stamp-query true }"); sb.AppendLine(""); File.WriteAllText(path, sb.ToString(), Encoding.Default); } //   ReadConfig(path); //     var fsWatcher = new FileSystemWatcher(directory, fileName); fsWatcher.Changed += (sender, args) => { try { fsWatcher.EnableRaisingEvents = false; //        , //     ,   //     Thread.Sleep(1000); ReadConfig(path); } catch (Exception e) { Console.WriteLine(e); } finally { fsWatcher.EnableRaisingEvents = true; } }; fsWatcher.EnableRaisingEvents = true; } //  ,    void ClearConf() { _conf.Clear(); } void AddConf(WoConfItem conf) { _conf.Add(conf); } static WoConfItem NewConf() { return new WoConfItem(); } static WoConfItem ConfComplectType(WoConfItem conf, string complectType) { conf.ComplectType = complectType; return conf; } static WoConfItem ConfRoute(WoConfItem conf, string route) { conf.Route = route; return conf; } static WoConfItem ConfDeal(WoConfItem conf, string deal) { conf.Deal = deal; return conf; } static WoConfItem ConfIsStampQuery(WoConfItem conf, bool isStampQuery) { conf.IsStampQuery = isStampQuery; return conf; } }

 \ WO passport configuration new-conf \ Config rules \ { -- begin config item, } -- end config item, * -- match any values \ Example: \ { complect-type * route offer deal 100500 is-stamp-query true } \ ***** offer ***** { complect-type offer route offer is-stamp-query false deal 5c18e87bfeed2b0b883fd4df } { complect-type KVK route offer is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type offer-cred route offer is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type offer-dep route offer is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type quick-meeting route offer is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type exica route offer is-stamp-query true deal 5d03a894e2f5850001435492 } { complect-type reissue route offer is-stamp-query true deal 5d03a894e2f5850001435492 } \ ***** offer-flow ***** { complect-type KVK route offer-flow is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type offer-cred route offer-flow is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type offer-dep route offer-flow is-stamp-query true deal 5d03a8a1edf8af0001876df0 } { complect-type reissue route offer-flow is-stamp-query true deal 5d03a894e2f5850001435492 }

, , DSL — .

, «». DSL.

, , — , , , , — . , .

— , . — , — !

, .

- .

सौभाग्य है

यूनिवर्सल डीएसएल। क्या यह संभव है?

परिचय

पता दुभाषिया

पाठ दुभाषिया

More articles: