Halo, Habr! Selama beberapa minggu sekarang, saya telah mengembangkan bahasa pemrograman Rust saya. Saya ingin berbicara tentang apa yang mungkin dihadapi seorang pemula dalam bisnis ini dan apa yang harus dia ketahui.

Sejarah Singkat

Semuanya dimulai dengan fork ein , saya fork untuk mempelajari bagaimana bahasa pemrograman dibangun. Karena ein ditafsirkan dari dan ke, kecepatan eksekusi bukan yang tertinggi, dan setelah saya mulai memahami sesuatu, saya memutuskan untuk mulai menulis juru bahasa saya sendiri, yang pada akhirnya juga ditinggalkan.

Namun terlalu dini untuk putus asa! Saya membaca beberapa artikel tentang VM dan apa itu dan memutuskan untuk menulis VM sederhana.

Apa itu "mesin virtual bertumpuk" dan bagaimana cara kerjanya?

Pada habr ada artikel otdelny tentang hal itu, tetapi untuk tidak mengemudi di tautan saya akan menjelaskan secara singkat arti dari hal kecil ini.

Tumpukan VM melakukan semua operasi pada data yang disimpan dalam bentuk tumpukan, setiap operasi mengekstrak jumlah data yang diperlukan untuk operasi dan, setelah selesai, itu dapat "mengirim" nomor baru ke tumpukan.

Memulai

Pertama, Anda perlu membuat proyek baru menggunakan kargo:

cargo new habr_vm 

Pertama, kita perlu membuat beberapa operasi dasar untuk VM kita:

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

Ini adalah operasi dasar kami, perintah Push akan menambahkan nomor baru ke tumpukan, Tambah dan Sub akan mengambil dua angka dari tumpukan dan melakukan tindakan dengan mereka (masing-masing penambahan dan pengurangan), saya tidak perlu menjelaskan AddAssign dan SubAssign.

Tugas selanjutnya adalah membuat mesin virtual itu sendiri, untuk ini kita akan membuat struktur yang tidak rumit:

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

Dan kami menerapkannya:

 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); } } } } } 

Kami menerapkan struktur kami, apa selanjutnya? Selanjutnya kita perlu membuat "program" kami.

Begini tampilannya:

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

Sederhana, bukan? Jika demikian, maka mari kita jalankan program kami!

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

Ini sangat sederhana bagi saya, sehingga Anda dapat menambahkan opcode yang cukup untuk operasi yang Anda butuhkan.

Kesimpulan

Saya berpikir bahwa saya cukup jelas menjelaskan bagaimana menulis semua ini pada masa lalu dan bagaimana cara kerjanya.

Saya ingin menambahkan bahwa Anda dapat dengan mudah menulis YP Anda sendiri berkat VM yang serupa, pada dasarnya Anda hanya perlu menulis parser, lexer dan "compiler", dan jika Anda ingin melihat proyek yang sudah jadi, Anda dapat mengikuti tautan ini.

Semua kode dari artikel tersedia di repositori ini .

Semoga beruntung Habr!