नमस्कार, हेब्र! अब कई हफ्तों के लिए, मैं अपनी Rust प्रोग्रामिंग भाषा विकसित कर रहा हूं। मैं इस बारे में बात करना चाहूंगा कि इस व्यवसाय में क्या नौसिखिया हो सकता है और उसे क्या पता होना चाहिए।

संक्षिप्त इतिहास

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

लेकिन यह निराशा के लिए बहुत जल्दी है! मैंने VM और उनके बारे में कुछ लेख पढ़े और एक सरल स्टैक्ड VM लिखने का निर्णय लिया।

"स्टैक्ड वर्चुअल मशीन" क्या है और यह कैसे काम करती है?

हब्र पर इसके बारे में एक otdelny लेख है, लेकिन यह है कि लिंक पर ड्राइव करने के लिए नहीं मैं संक्षेप में इस छोटी सी बात का अर्थ समझाऊंगा।

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

शुरुआत हो रही है

पहले आपको कार्गो का उपयोग करके एक नई परियोजना बनाने की आवश्यकता है:

cargo new habr_vm 

सबसे पहले, हमें अपने वीएम के लिए कुछ बुनियादी ऑपरेशन बनाने की जरूरत है:

 enum Opcode { Push(i32), Add, AddAssign(i32), Sub, SubAssign(i32), } 

ये हमारे मूल संचालन हैं, पुश कमांड स्टैक में एक नया नंबर जोड़ देगा, ऐड और सब स्टैक से दो नंबर लेगा और उनके साथ क्रियाएं करेगा (इसके अलावा और घटाव, क्रमशः), मुझे AddAssign और SubAddign को समझाने की आवश्यकता नहीं है।

अगला काम खुद वर्चुअल मशीन बनाना है, इसके लिए हम एक जटिल संरचना नहीं बनाएंगे:

 struct Vm { pub stack: Vec<i32>, } 

और हम इसे लागू करते हैं:

 impl Vm { //       pub fn pop(&mut self) -> i32 { self.stack.pop().unwrap() } //      pub fn run(&mut self,program: Vec<Opcode>) { for opcode in program { //      match opcode { Opcode::Push(n) => { //      self.stack.push(n); } Opcode::Add => { //        ,       let value = self.pop() + self.pop(); self.stack.push(value); } Opcode::Sub => { //           let value = self.pop() - self.pop(); self.stack.push(value); } //        Opcode::AddAssign(n) => { let mut value = self.pop(); value += n; self.stack.push(value); } Opcode::SubAssign(n) => { let mut value = self.pop(); value -= n; self.stack.push(value); } } } } } 

हमने अपनी संरचना को लागू किया, आगे क्या? अगला हमें अपना "प्रोग्राम" बनाने की आवश्यकता है।

यहां बताया गया है कि यह कैसा दिखना चाहिए:

 let program = vec![ Opcode::Push(2),// 2    Opcode::Push(4),//  4    Opcode::Sub,//  4 - 2 ]; 

यह आसान है, है ना? यदि ऐसा है, तो चलो हमारे कार्यक्रम को चलाएं!

 let mut vm = Vm {stack: Vec::new()}; vm.run(program); //     ,       2 for i in vm.stack() { println!("{}", i); } //  2 

यह मेरे लिए बहुत ही सरल है, इसलिए आप अपने ऑपरेशन के लिए पर्याप्त ऑपकोड जोड़ सकते हैं।

निष्कर्ष

मुझे लगता है कि मैंने स्पष्ट रूप से समझाया कि यह सब कैसे एक रैस्ट पर लिखना है और यह कैसे काम करता है।

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

लेख का सभी कोड इस भंडार में उपलब्ध है।

गुड लक हेबरा!