👁‍🗨 🧛🏻 👨🏽‍🔧 एक स्क्रिप्ट दुभाषिया और एक स्टैक मशीन लिखना 💐 🅰️ 🔥

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

एक बार, मेरे एक दोस्त ने शिकायत की कि मुझे डब्ल्यूएसएच पर एक स्वचालन स्क्रिप्ट लिखने की आवश्यकता थी, लेकिन वह वीबीएसस्क्रिप्ट या जावास्क्रिप्ट नहीं जानता था। तब "महान" सूत्रीकरण अपने आप उत्पन्न हुआ ... आपको एक मित्र की मदद करने की आवश्यकता है। परिणामस्वरूप, एक संकलक और एक निष्पादन मशीन लिखी गई, जो आपको VBScript और JS का सहारा लिए बिना Windows स्क्रिप्ट होस्ट के लिए स्क्रिप्ट निष्पादित करने की अनुमति देता है। कट के तहत - परियोजना की संक्षिप्त पृष्ठभूमि और इसकी आंतरिक संरचना और स्वयं प्रोग्रामिंग भाषा।

संक्षिप्त पृष्ठभूमि

सज्जनों, मैं आपको एक भयानक रहस्य बताऊंगा। मुझे पता है कि इस तरह के पाप को कबूल करना बहुत शर्मनाक है, लेकिन फिर भी, मैं कबूल करता हूं। मैं वन-एसनिक हूं। हां, हां, हां, मैं पीले फ्रेमवर्क का उपयोग करके बड़े और छोटे फैसले लिखता हूं और मेरी अंतरात्मा मुझे परेशान नहीं करती)))।

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

प्रोग्रामिंग भाषा के बारे में थोड़ा सा

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

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

"स्टैक मशीन" क्या है और यह कैसे काम करती है

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

एक बाइटकोड एक निर्देश का एक सेट है जो एक मशीन निष्पादित करेगा।

प्रत्येक निर्देश 0 से 255 तक एक सिंगल-बाइट ऑपरेशन कोड है, जिसके बाद रजिस्टर या मेमोरी एड्रेस ( विकिपीडिया ) जैसे पैरामीटर हैं।

हमारी मशीन में, टीम की एक निश्चित लंबाई और दो नंबर होंगे - ऑपरेशन कोड और ऑपरेशन तर्क। प्रत्येक कमांड स्टैक में डेटा पर क्रियाओं के एक सेट का अर्थ है।

उदाहरण के लिए, अतिरिक्त ऑपरेशन "1 + 2" का छद्म कोड इस तरह दिखाई दे सकता है:

Push 1 Push 2 Add

पहली दो टीमों ने स्टैक पर शर्तें लगाईं, तीसरी टीम ने अतिरिक्त प्रदर्शन किया और स्टैक पर परिणाम डाला। इस स्थिति में, असाइनमेंट ऑपरेशन "A = 1 + 2" इस तरह दिख सकता है:

 Push 1 ;    "1" Push 2 ;    "2" Add ;    "1"  "2",      . LoadVar A ;         ""

यह देखा जा सकता है कि पुश और लोडवर कमांड में एक तर्क है, एड कमांड को एक तर्क की आवश्यकता नहीं है।

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

एक खड़ी मशीन लिखने का कार्य निर्देशों का आवश्यक सेट "आविष्कार" करने के लिए नीचे आता है जिसे यह मशीन समझ जाएगी।

संकलक यंत्र

कंपाइलर का कार्य किसी दिए गए भाषा में कोड को मशीन के बाइटकोड में बदलना है जो इसे निष्पादित करेगा। क्लासिक कंपाइलर में 3 घटक होते हैं:

लेक्सिकल एनालाइज़र (पार्सर)
पार्सर
कोड जनरेटर

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

पार्सर यह सत्यापित करता है कि लेक्सिकल एनालाइज़र ने जो टोकन का सेट दिया है, वह सार्थक है, कि हमारे पास एक कार्यक्रम है, न कि अक्षरों का अर्थहीन सेट।

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

कोड जनरेटर बायटेकोड बनाता है, सिंटैक्स ट्री के नोड्स को दरकिनार करता है।

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

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

स्टेट मशीन

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

वर्चुअल मशीन डिवाइस

दृश्यता संदर्भ

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

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

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

स्मृति

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

सूची	प्रसंग संख्या	चर संख्या
0	0	0
1	0	1
2	1	3

उदाहरण के लिए, यदि कमांड PushVar 1 प्राप्त हुआ था , तो सूचकांक 1 में तालिका में एक रिकॉर्ड चुना जाता है जिसमें यह कहा जाता है - संदर्भ 0 से चर संख्या 1 लेने के लिए।

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

कॉल स्टैक

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

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

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

एक विधि कॉल के साथ स्यूडोकोड का एक टुकड़ा।

 0: Push 1 1: Push 2 2: Add 3: Return 4: Nop 5: Nop 6: Call 0 7: LoadVar

मान लीजिए कि वर्तमान निर्देश संख्या 6 है। यह 0. पते के लिए एक कॉल है। स्थानीय चर और वर्तमान अनुदेश संख्या कॉल स्टैक में संग्रहीत हैं। अगला, नियंत्रण 0 पते पर स्थानांतरित किया जाता है, और फिर 6 पते पर लौटता है, जहां अगले निर्देश के लिए एक संक्रमण होता है।

टीम का क्रियान्वयन

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

कमांड निष्पादन का मुख्य चक्र

 private void ExecuteCode() { while (true) { try { MainCommandLoop(); break; } catch (RuntimeException exc) { if (_exceptionsStack.Count == 0) throw; var handler = _exceptionsStack.Pop(); SetFrame(handler.handlerFrame); _currentFrame.InstructionPointer = handler.handlerAddress; _lastException = exc; } } } private void MainCommandLoop() { try { while (_currentFrame.InstructionPointer >= 0 && _currentFrame.InstructionPointer < _module.Code.Length) { var command = _module.Code[_currentFrame.InstructionPointer]; _commands[(int)command.Code](command.Argument); } } catch (RuntimeException) { throw; } catch (Exception exc) { throw new ExternalSystemException(exc); } }

निष्पादन योग्य यूनिट डिवाइस

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

सबसे पहले, विचार करें कि 1 सी में स्रोत मॉड्यूल क्या होते हैं।

इसके 3 अलग-अलग खंड हैं:

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

चूंकि मॉड्यूल का शरीर अनिवार्य रूप से एक नाम के बिना एक विधि है, हम कह सकते हैं कि केवल दो प्रकार के विषम निर्माण हैं - चर और निष्पादन योग्य कोड की घोषणा।

स्थिरांक

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

,

और

।

किसी भी कंप्यूटर में 2 और 2 को जोड़ने के लिए, आपको यह समझाने की आवश्यकता है कि "2" क्या है और इसे कहाँ प्राप्त करना है। इस प्रयोजन के लिए, कोड में उपयोग किए गए सभी स्थिरांक का एक विवरण संकलित मॉड्यूल में शामिल है। यदि कोड " = ""

" कहता है, तो यह शब्द "हैलो" स्थिरांक की सूची में होना चाहिए।

चर

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

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

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

स्टैक चर संचालन

 private void PushVar(int arg) { var vm = _module.VariableRefs[arg]; var scope = _scopes[vm.ContextIndex]; _operationStack.Push(scope.Variables[vm.CodeIndex]); NextInstruction(); } private void LoadVar(int arg) { var vm = _module.VariableRefs[arg]; var scope = _scopes[vm.ContextIndex]; scope.Variables[vm.CodeIndex].Value = BreakVariableLink(_operationStack.Pop()); NextInstruction(); }

तरीकों

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

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

चर की तरह तरीके, मॉड्यूल के लिए बाहरी हो सकते हैं (यानी, विश्व स्तर पर कहीं घोषित)। तरीकों तक पहुंच उसी तरह से आयोजित की जाती है जैसे कि चर में - एक पत्राचार तालिका के माध्यम से जो उस संदर्भ को परिभाषित करता है जिसमें बुलाया विधि स्थित है।

मॉड्यूल की अंतिम संरचना

उपरोक्त सभी को मिलाएं और संकलित मॉड्यूल की निम्न संरचना प्राप्त करें:

संकलन के बाद, मॉड्यूल एक संरचना है जिसमें शामिल हैं:

मॉड्यूल स्तर चर की संख्या
स्थिरांक की सूची
विधि हस्ताक्षर सूची
मॉड्यूल बायटेकोड
चर मानचित्र
विधि का नक्शा
मॉड्यूल में प्रवेश बिंदु है कि विधि की संख्या (मॉड्यूल शरीर)

मूल्यों के साथ काम करें

1C भाषा में सख्त टाइपिंग नहीं है। एक वैरिएबल को एक प्रकार मिलता है जब इसे एक मान सौंपा जाता है कोई भी मूल्य अनिवार्य रूप से सार्वभौमिक प्रकार VARIANT है। संचालन करते समय, वांछित मूल्य के साथ सार्वभौमिक मूल्य दिया जाता है। उदाहरण के लिए, जब अंकगणितीय संक्रियाओं को एक नंबर पर रखा जाता है, और जब बूलियन ऑपरेशन - बूलियन मानों को।

निम्नलिखित मूल मूल्य प्रकार मौजूद हैं:

अपरिभाषित
पंक्ति
संख्या
तिथि
बूलियन
वस्तु
टाइप

उत्तरार्द्ध प्रकारों के साथ काम करने के लिए एक आदिम प्रकार है। (.NET में System.Type

एनालॉग)

सार्वभौमिक मूल्य को IValue

इंटरफ़ेस द्वारा IValue

है:

 interface IValue : IComparable<IValue>, IEquatable<IValue> { DataType DataType { get; } TypeDescriptor SystemType { get; } double AsNumber(); DateTime AsDate(); bool AsBoolean(); string AsString(); TypeDescriptor AsType(); IRuntimeContextInstance AsObject(); }

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

किसी अभिव्यक्ति का मूल्यांकन करते समय, अंतिम परिणाम का प्रकार पहले ऑपरेंड के प्रकार द्वारा निर्धारित किया जाता है। तो, अभिव्यक्ति "12345" + 10

को एक स्ट्रिंग परिणाम उत्पन्न करना चाहिए। इसके अलावा प्रदर्शन करते समय, दूसरे तर्क को स्ट्रिंग में डाला जाएगा और समवर्ती प्रदर्शन किया जाएगा।

इसके विपरीत, ऑपरेशन 10 + "12345"

एक नंबर पर स्ट्रिंग "12345" डालने का प्रयास करेगा। यदि यह कास्ट संभव नहीं है, तो अपवाद "संख्या प्रकार के लिए एक त्रुटि" होता है।

उपरोक्त उदाहरणों में, AsString () विधि को उस वर्ग पर कहा जाता है जो संख्या प्रकार को लागू करता है, और AsNumber () विधि को उस वर्ग पर कहा जाता है जो स्ट्रिंग प्रकार को लागू करता है।

जोड़ आपरेशन

 private void Add(int arg) { var op2 = _operationStack.Pop(); var op1 = _operationStack.Pop(); var type1 = op1.DataType; if (type1 == DataType.String) { var result = op1.AsString() + op2.AsString(); _operationStack.Push(ValueFactory.Create(result)); } else if (type1 == DataType.Date && op2.DataType == DataType.Number) { var date = op1.AsDate(); var result = date.AddSeconds(op2.AsNumber()); _operationStack.Push(ValueFactory.Create(result)); } else { //    . var result = op1.AsNumber() + op2.AsNumber(); _operationStack.Push(ValueFactory.Create(result)); } NextInstruction(); }

ऑब्जेक्ट गुणों और विधियों तक पहुंच

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

 interface IRuntimeContextInstance { bool IsIndexed { get; } IValue GetIndexedValue(IValue index); void SetIndexedValue(IValue index, IValue val); int FindProperty(string name); bool IsPropReadable(int propNum); bool IsPropWritable(int propNum); IValue GetPropValue(int propNum); void SetPropValue(int propNum, IValue newVal); int FindMethod(string name); MethodInfo GetMethodInfo(int methodNumber); void CallAsProcedure(int methodNumber, IValue[] arguments); void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue); }

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

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

संदर्भों और इसके विपरीत वस्तुओं के साथ काम करें

ऊपर, मैंने संदर्भों और उदाहरणों के संदर्भ में वस्तुओं के निर्माण का उल्लेख किया है । आइए इस बात पर करीब से नज़र डालते हैं कि "एक बिंदु के माध्यम से" वस्तुओं का क्या और कैसे आयोजन किया गया था।

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

यदि " MathLibrary

" वर्ग का एक उदाहरण स्कोप स्टैक से जुड़ा हुआ है, तो पाप, कोस और Sqrt फ़ंक्शन को सीधे कहा जा सकता है। वे पुस्तकालय स्तर पर कहीं न कहीं घोषित नियमित विधियों के रूप में दिखाई देंगे।

  = Sin(X); //  Sin   ,      ,       .

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

उसी समय, जब स्क्रिप्ट ए कॉल बी को कॉल करती है, तो स्क्रिप्ट बी मशीन की मेमोरी से जुड़ा होता है, क्योंकि कोड बी का संदर्भ और निष्पादन आगे बढ़ता है जैसे कि बी एकमात्र स्क्रिप्ट थी। मॉड्यूल बी से लौटते समय, यह स्क्रिप्ट ए को डिस्कनेक्ट और निष्पादित करता है।

Bytecode उदाहरण

निम्नलिखित उदाहरण हैं कि कैसे बायटेकोड में कुछ संचालन के निष्पादन का आयोजन किया जाता है।

जोड़ और असाइनमेंट

  = 1;  = 2;  =  + ;

 .constants 0 :type: Number, val: 1 1 :type: Number, val: 2 .code 0 :(PushConst 0) ;   0   1 :(LoadLoc 0) ;       0 2 :(PushConst 1) ;   1   3 :(LoadLoc 1) ;       1 4 :(PushLoc 0) ;     0 5 :(PushLoc 1) ;     1 6 :(Add 0) ;       7 :(LoadLoc 2) ;       2

पूर्ववर्ती लूप (जबकि)

  = 1;   < 5   =  + 1; ;

 .constants 0 :type: Number, val: 1 1 :type: Number, val: 5 .code 0 :(PushConst 0) 1 :(LoadLoc 0) ;      2 :(PushLoc 0) ;   ( ) 3 :(PushConst 1) 4 :(Less 0) ;   ""   №1 ( 5) 5 :(JmpFalse 11) ;    - ,      ( 11) 6 :(PushLoc 0) ;   =  + 1 7 :(PushConst 0) 8 :(Add 0) 9 :(LoadLoc 0) 10 :(Jmp 2) ;        11 :(Nop 0) ;

शर्त

  1 > 2   = 1;   = 0; ;

 .constants 0 :type: Number, val: 1 1 :type: Number, val: 2 2 :type: Number, val: 0 .code 0 :(PushConst 0) 1 :(PushConst 1) 2 :(Greater 0) ;   "" 3 :(JmpFalse 7) ;    -    "" 4 :(PushConst 0) ;    5 :(LoadLoc 0) 6 :(Jmp 9) ;   ,     7 :(PushConst 2) ;    8 :(LoadLoc 0) 9 :(Nop 0);

विधि कॉल

 ("");

 .constants 0 :type: String, val:  .code 0 :(PushConst 0) ;     1 :(ArgNum 1) ;      2 :(CallProc 1) ;  ,        1 .procmap 0 :(1,2) 1 :(0,4) ;  1    0     4.

WSH के बारे में यह क्या था?

WSH स्क्रिप्टिंग बुनियादी ढांचे को COM वस्तुओं की एक संख्या द्वारा दर्शाया गया है। इन वस्तुओं को स्क्रिप्टिंग भाषाओं से अपने सदस्यों के लिए IDispatch के नाम से एक्सेस करके एक्सेस किया जा सकता है। क्या कुछ भी समान नहीं है?

यह IDispatch पर एक छोटा आवरण बनाने के लिए पर्याप्त है, जो मशीन को इन IR वस्तुओं के साथ उल्लेख किए गए IRuntimeContextInstance इंटरफ़ेस के माध्यम से काम करने की अनुमति देगा।

यह आंकड़ा एक परीक्षण एप्लिकेशन विंडो दिखाता है जिसका उपयोग मैंने स्क्रिप्ट को डीबग करने के लिए किया था।यह एक स्क्रिप्ट चलाता है जो Scripting.FileSystemObject ऑब्जेक्ट का उपयोग करके ड्राइव लेबल को सूचीबद्ध करता है।

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

स्रोत और सामान

पूरी परियोजना में दो अनुप्रयोग होते हैं और एक कार इंजन के साथ एक dll होता है।

टेस्टएप एप्लिकेशन एक सहायक जीयूआई-आधारित उपकरण है जिसमें आप इंजन की कोशिश कर सकते हैं, परीक्षण स्क्रिप्ट लिख सकते हैं और उनका निष्पादन चला सकते हैं।

ऑसस्क्रिप्ट कंसोल एप्लिकेशन मुख्य कमांड लाइन टूल है।

समर्थित कमांड ऑकस्क्रिप्ट स्वयं को दिखाता है यदि पैरामीटर के बिना चलाया जाता है।

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

स्रोत कोड बिटबकेट पर उपलब्ध हैं । वहाँ, उपलब्ध भाषा उपकरणों के बारे में एक छोटा विकि।

कौन यह देखने के लिए परवाह करता है कि यह कैसे काम करता है, लेकिन स्रोत से संकलन नहीं करना चाहता -setup.exe

संक्षिप्त निष्कर्ष

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

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

मुझे उम्मीद है कि यह ओपस आपके लिए दिलचस्प था। कांटा परियोजना, आलोचना, मुझे खुशी होगी। सौभाग्य है।

PS 1C के बारे में लेख की टिप्पणियों में एक संदेश होना चाहिए "मैं रूसी में ऑपरेटरों को कैसे लिख सकता हूं?" :)

एक स्क्रिप्ट दुभाषिया और एक स्टैक मशीन लिखना