If you've ever managed multiple Kubernetes clusters (staging, production, development or client environments), you know the anxiety of running a command and realizing too late you were in the wrong context. That's not a skill issue. That's a tooling issue. And it's exactly the problem I set out to solve.

At the OpenClaw Jakarta Meetup, I walked through how I'm building Kubemotion, a cross-platform Kubernetes desktop client built with Rust and egui, with OpenClaw embedded at its core.

The Problem

Most of us have internalized the Kubernetes friction so deeply that we stop noticing it. But look at the workflow honestly:

• Remembering kubectl flags: resource names, flags, and context switching all live in your head
• Hunting across screens: logs, events, and rollout state are scattered across tabs and commands
• Sharing context in incidents: explaining "what I'm seeing" to a teammate is slower than it should be

When something breaks in production, you don't want to juggle five terminal tabs and a Slack thread. What engineers actually want is simple: "Why is THIS failing?" with context already attached, no copy-pasting. One place to see -> ask -> act. And when writes are involved, safe actions with explicit confirmation.

The Idea: Chat That Drives the Interface

The core insight behind Kubemotion is this: put OpenClaw inside the K8s desktop app. Not "chat in Telegram." Chat that drives the interface.

The interaction model is a three-step loop:

1. Click a resource - a Pod, Deployment, or Namespace automatically becomes the chat context
2. Ask in plain language - "why is this crashing?", "show previous logs", "what changed?"
3. The UI reacts and answers - it opens logs/events, highlights the problem, and offers next actions right there in the interface

This is what makes it different from bolting a chatbot onto a dashboard. The selected resource is the context. No prompt engineering required - the app already knows what you're looking at.

Architecture

The system has three layers that communicate cleanly:

The Gateway sits in the middle as a controlled bridge. It doesn't give the agent unrestricted access to your cluster. It enforces which tools are available, routes kubeconfig, and keeps a full audit trail of every interaction.

MVP Scope (v1)

The first version is deliberately focused. The must-have capabilities are:

• Auto context: cluster / namespace / selected resource passed automatically with every message
• Read tools: logs, events, describe, rollout status
• UI actions: open logs, jump to deployment, highlight failures
• Action cards: quick-tap shortcuts - "Open logs" · "Show events" · "Explain cause"

The goal for v1 is to make the read side feel completely native. You click a pod, ask a question, and the app responds and navigates itself. No terminal switching. No copying resource names by hand.

Security First: Guardrails by Design

Giving an AI agent access to a Kubernetes cluster isn't something to do carelessly. The security model is intentional and conservative.

Policy:

• Tool allowlist: start read-only and expand deliberately
• RBAC maps to the user, not a god agent with blanket permissions
• All write operations require explicit confirmation before execution

Operations:

• Full audit trail: who asked and what was executed
• Scopes enforced at cluster / namespace / resource level
• Rate limits and safe defaults throughout

For the OpenClaw Gateway, the baseline hardening config looks like this:

gateway:
  bind: loopback
  auth:
    mode: token
    token: ${OPENCLAW_GATEWAY_TOKEN}
    rateLimit:
      maxAttempts: 10
      windowMs: 60000
      lockoutMs: 300000
      exemptLoopback: true

Three non-negotiable rules: always authenticate (token or password, never skip it), bind to loopback unless a proxy is explicitly in front, and enable rate limiting with a lockout window.

Untuk kode yang sudah lengkap bisa dilihat di github: https://github.com/aldidana/hitung

Kita bisa saja mengevaluasi expression yang sudah ada langsung menggunakan Rust tanpa llvm atau kita juga bisa mentranslate expression yang ada tadi menjadi sebuah Bytecode yang akan dijalankan di VM

Namun untuk tutorial kali ini kita akan menjalankannya dengan menggunakan JIT (Just In Time) compiler dari llvm.

LLVM adalah sebuah compiler infrastructure dimana kita dapat membuat sebuah instruksi berupa intermediate representation atau IR, kemudian llvm juga dapat meng-compile IR menjadi binary yang berdiri sendiri (standalone binary) atau melakukan Just In Time compilation pada saat runtime.

Dibawah ini adalah contoh IR dari kode if 1 < 2 then 1 else 0.

define double @@berhitung() {
entry:
  br i64 1, label %entry1, label %entry2

entry1:                                           ; preds = %entry
  br label %entry3

entry2:                                           ; preds = %entry
  br label %entry3

entry3:                                           ; preds = %entry2, %entry1
  %entry4 = phi double [ 1.000000e+00, %entry1 ], [ 0.000000e+00, %entry2 ]
  ret double %entry4
}

Kita akan menggunakan library Inkwell. Inkwell merupakan sebuah high-level wrapper dari library llvm-sys.

LLVM

Untuk mengikutin ini pastikan kia sudah meng-install llvm versi 10.

Untuk mengecek versi llvm yang sudah terinstall bisa menggunakan perintah ini:

llvm-config --version

Struktur

hitung
│   Cargo.toml   
│
└───src
	| main.rs
	| lexer.rs
   	| token.rs
	| expression.rs
	| parser.rs
	| jit.rs //file baru

Cargo.toml

Buka file cargo.toml dan tambahkan library inkwell.

[package]
name = "hitung"
version = "0.1.0"
authors = ["Nama Author"]
edition = "2018"

[dependencies]
inkwell = { git = "https://github.com/TheDan64/inkwell", branch = "master", features = ["llvm10-0"] }

JIT (Just In Time)

Kita akan membutuhkan 3 objek yang ada di llvm.

1. Context: Bagian inti/core dari llvm
2. Module: Tempat dimana fungsi dan IR di simpan
3. Builder: Yang akan melakukan instruksi kemudian memasukannya ke dalam BasicBlock

Buka file jit.rs dan tambahkan barisan kode berikut ini:

use std::collections::HashMap;
use std::path::Path;

use inkwell;
use inkwell::builder::Builder;
use inkwell::context::Context;
use inkwell::module::Module;
use inkwell::values::PointerValue;
use inkwell::FloatPredicate;
use inkwell::OptimizationLevel;

use crate::expression::Expression;
use crate::lexer::Lexer;
use crate::parser::Parser;
use crate::token::Token;

pub type FuncSign = unsafe extern "C" fn() -> f64;

Kita menambahkan beberapa module yang berkaitan dengan inkwell dan membuat tipe data yang dibutuhkan untuk hasil dari fungsi yang dipanggil oleh llvm.

Untuk bagian pub type FuncSign = unsafe extern "C" fn() -> f64; disini adalah kita akan memanggil eksternal kode agar dapat menggunakan suatu fungsi dari bahasa pemrograman lain dalam hal ini bahasa pemrograman C, bagian "C" diatas disebut ABI (Application Binary Interface) sedangkan keyword extern yang memfasilitasi FFI (Foreign Function Interface). Penggunaan keyword extern sendiri tidak membutuhkan keyword unsafe tetapi untuk memanggilnya dibutuhkan keyword unsafe, dikarenakan Rust tidak mengetahui aturan dan jaminan dari bahasa lain tersebut.

Tambahkan kode berikut setelah kode diatas:

pub struct Compiler<'ctx> {
    context: &'ctx Context,
    module: Module<'ctx>,
    builder: Builder<'ctx>,

    variables: HashMap<String, PointerValue<'ctx>>,
    debug: bool,
}

Struct Compiler terdiri dari Context untuk menyimpan konteks llvm selama program berjalan, Module, Builder, Variables untuk menyimpan Global Variable berupa HashMap yang isinya adalah sebuah pointer, Debug untuk menampilkan IR yang telah dibuat.

Kemudian lanjutkan dengan membuat associate function dan method untuk Compiler diatas.

impl<'ctx> Compiler<'ctx> {
    pub fn new(context: &'ctx Context, debug: bool) -> Self {
        let module = context.create_module("hitung");
        let builder = context.create_builder();

        Compiler {
            context,
            module,
            builder,
            variables: HashMap::new(),
            debug,
        }
    }
    pub fn compile_source(&mut self, source: &str) -> Result<f64, String> {
        let lexer = Lexer::new(source);
        let tokens = lexer.lex();
        let mut parser = Parser::new(tokens);
        match parser.expr(0) {
            Ok(expression) => self.jit_compile(expression),
            Err(e) => Err(e),
        }
    }
    .... // fungsi berikutnya
}

Fungsi new diatas menerima sebuah reference Context dari fungsi yang memanggilnya karena kita membutuhkannya selama program berjalan, fungsi ini juga akan membuat sebuah module yang dinamai "hitung".

Fungsi compile_source akan memanggil Lexer dan Parser untuk menghasilkan expression dari kode sumber yang sudah dimasukan, fungsi ini akan memanggil fungsi jit_compile jika dapat menghasilkan expression yang benar.

Tambahkan fungsi jit_compile berikut setelah fungsi compile_source:

... // fungsi sebelumnya
pub fn jit_compile(&mut self, expr: Expression) -> Result<f64, String> {
    let float = self.context.f64_type();
    let fn_type = float.fn_type(&[], false);
    let function = self.module.add_function("berhitung", fn_type, None);
    let basic_block = self.context.append_basic_block(function, "entry");
    self.builder.position_at_end(basic_block);

    let return_val = self.eval(expr)?;
    self.builder.build_return(Some(&return_val));

    let execution_engine = self
        .module
        .create_jit_execution_engine(OptimizationLevel::None)
        .map_err(|e| e.to_string())
        .unwrap();

    let last_func = self.module.get_last_function().unwrap();
    let last_func_name = last_func.get_name().to_str().unwrap();

    let function_calc = unsafe { execution_engine.get_function::<FuncSign>(last_func_name) };

    if self.debug {
        println!("LLVM IR:");
        function.print_to_stderr();
        self.module
            .print_to_file(Path::new("hitung.ll"))
            .expect("Error print to file");
    }

    match execution_engine.remove_module(&self.module) {
        Ok(_ok) => match function_calc {
            Ok(f) => Ok(unsafe { f.call() }),
            Err(err) => {
                println!("!> Error during execution: {:?}", err);
                Err(err.to_string())
            }
        },
        Err(err) => Err(err.to_string()),
    }
}

Fungsi jit_compile akan membuat sebuah fungsi "berhitung" di dalam module "hitung"  dengan tipe data f64 dan fungsi ini tidak mempunyai parameter. Selanjutnya kita membuat sebuah basic block yang dinamai "entry", basic block adalah urutan untuk instruksi, basic block disini mengacu pada fungsi yang sudah dibuat yaitu fungsi "berhitung". Lalu kita menginformasikan builder untuk mulai dari/berpindah ke basic block ini. Basic block dari fungsi ini juga membutuhkan tipe data yang akan dikembalikan, oleh karena itu tipe data yang akan dikembalikan diambil setelah mengevaluasi expression yang ada dari fungsi eval.

Berikut ini contoh fungsi dan basic block llvm:

define double @berhitung() {
entry:
	ret double 1.000000e+00
}

Selanjutnya membuat execution_engine dari module yang sudah kita buat sebelumnya, execution_engine akan menjalankan fungsi yang sudah diisi basic block. Disini juga kita akan mencetak setiap hasil dari module tersebut ke file hitung.ll jika Debug diset menjadi true. Kemudian execution_engine melepas module yang kita buat sebelumnya agar kita bisa membuat kembali execution_engine baru dengan module yang sama dari setiap kode sumber yang dimasukan.

Aritmatika

Sebelum ke tahap selanjutnya, disini akan membahas fungsi aritmatika yang ada di llvm.

Misalnya kita mempunyai sebuah fungsi penjumlahan seperti ini:

fn add(lhs: f64, rhs: f64) -> f64 {
	lhs + rhs
}

Dalam library Inkwell kita bisa memanggilnya dengan fungsi yang mirip seperti fungsi diatas:

builder.build_float_add(lhs, rhs, "add") // nama bisa diisi apa saja

Maka fungsi diatas akan langsung mengembalikan jawaban yang sesuai.

Eval

Kembali ke file jit.rs, setelah fungsi jit_compile tambahkan kode berikut:

fn eval(
    &mut self,
    expression: Expression,
) -> Result<inkwell::values::FloatValue<'ctx>, String> {
    match expression {
        Expression::Variable(name) => match self.variables.get(&name) {
            Some(value) => {
                let val = self.builder.build_load(*value, name.as_str());
                Ok(val.into_float_value())
            }
            None => Err("Variable not declared".to_string()),
        },
        Expression::Num(n) => {
            let float = self.context.f64_type();
            Ok(float.const_float(n as f64))
        }
        Expression::Unary(operator, expr) => match operator {
            Token::Add => {
                let num = self.eval(*expr)?;

                Ok(num)
            }
            Token::Sub => {
                let float = self.context.f64_type();
                let num = self.eval(*expr)?;
                let rhs = float.const_float_from_string("-1");
                let sum = self.builder.build_float_mul(num, rhs, "mul");
                Ok(sum)
            }
            _ => Err("Expression for Unary must be + or -".to_string()),
        },
        ... // berikutnya
	}
}

catatan: fungsi eval dipanggil dengan cara recursive untuk mengevaluasi expression lainnya.

Jika expression itu adalah expression untuk variable maka kita akan mencari apakah variable tersebut ada atau tidak, variable saat ini disimpan di global variable, jika variable tersebut ada maka kita mengambil pointer dari isi variable tersebut.

Jika expression berupa angka atau num maka kita hanya perlu mengembalikan angka tersebut dengan tipe data yang sudah ditentukan (dalam hal ini f64)

Jika expression tersebut berupa Unary operator maka kita perlu menentukan bagian kiri dan bagian kanan yang ada dari expression tersebut, misalnya jika +3 maka akan menjadi 3 tetapi jika -3 tetap menjadi -3, disini kita hanya mengecek unary untuk +angka dan -angka.

Masih didalam fungsi eval, tambahkan kode berikutnya:

... // sebelumnya
Expression::Binary(left, operator, right) => match operator {
    Token::LT | Token::GT => {
        let lhs = self.eval(*left)?;
        let rhs = self.eval(*right)?;

        let predicate = match operator {
            Token::LT => FloatPredicate::OLT,
            Token::GT => FloatPredicate::OGT,
            _ => return Err("Operator not supported".to_string()),
        };

        let conditional = self.builder.build_float_compare(predicate, lhs, rhs, "if");

        Ok(self.builder.build_unsigned_int_to_float(
            conditional,
            self.context.f64_type(),
            "bool",
        ))
    },
    Token::ASSIGN => match *left {
        Expression::Variable(var) => {
            let f64_type = self.context.f64_type();
            let global = self.module.add_global(f64_type, None, var.as_str());
            global.set_initializer(&f64_type.const_float(0 as f64));
            let rhs = self.eval(*right)?;
            global.set_initializer(&rhs);
            self.builder.build_store(global.as_pointer_value(), rhs);

            let value = self
                .builder
                .build_load(global.as_pointer_value(), var.as_str());
            self.variables.insert(var, global.as_pointer_value());

            Ok(value.into_float_value())
        }
        _ => Err("Assignment must be a variable".to_string()),
    },
    _ => {
        let lhs = self.eval(*left)?;
        let rhs = self.eval(*right)?;

        match operator {
            Token::Add => Ok(self.builder.build_float_add(lhs, rhs, "add")),
            Token::Sub => Ok(self.builder.build_float_sub(lhs, rhs, "sub")),
            Token::Mul => Ok(self.builder.build_float_mul(lhs, rhs, "mul")),
            Token::Div => Ok(self.builder.build_float_div(lhs, rhs, "div")),
            _ => Err("Operator not supported".to_string()),
        }
    }
},
Expression::Paren(expr) => {
    let result = &self.eval(*expr)?;
    Ok(*result)
}
... // berikutnya

Untuk binary operator:

• Jika expression berupa sebuah komparasi lebih besar (GT) dari atau lebih kecil dari (LT) llvm memiliki sebuah predicate sesuai dengan dua hal tersebut, komparasi akan mengembalikan angka 1 jika true dan 0 jika false.
• Jika expression berupa Variable Assignment maka kita akan mengambil angka dari variable tersebut lalu menyimpannya di global variable, disini juga kita langsung mengembalikan angka dari variable tersebut.
• Jika Binary operator bukan dari kedua diatas, maka binary operator tersebut adalah sebuah aritmatika.

Kemudian jika expression yang ditemukan berupa tanda kurung maka kita akan mengevaluasi expression yang ada didalamnya.

Terakhir masih dengan fungsi yang sama yaitu fungsi eval, tambahkan kode dibawah ini:

... // sebelumnya
Expression::Conditional(cond, then, els) => {
    let if_cond = self.eval(*cond)?;

    let function = self.module.get_last_function().unwrap();

    let then_block = self.context.append_basic_block(function, "entry");
    let else_block = self.context.append_basic_block(function, "entry");
    let cont_block = self.context.append_basic_block(function, "entry");

    let i64_type = self.context.i64_type();

    self.builder.build_conditional_branch(
        if_cond.const_to_unsigned_int(i64_type),
        then_block,
        else_block,
    );
    self.builder.position_at_end(then_block);

    let then_value = self.eval(*then)?;
    self.builder.build_unconditional_branch(cont_block);
    let then_block = self.builder.get_insert_block().unwrap();

    // build else block
    self.builder.position_at_end(else_block);
    let else_value = self.eval(*els)?;
    self.builder.build_unconditional_branch(cont_block);

    let else_block = self.builder.get_insert_block().unwrap();
    self.builder.position_at_end(cont_block);

    let phi = self.builder.build_phi(self.context.f64_type(), "entry");
    phi.add_incoming(&[(&then_value, then_block), (&else_value, else_block)]);

    Ok(phi.as_basic_value().into_float_value())
}

Untuk expression terakhir adalah branching/conditional atau pencabangan. Kita menambahkan 3 basic block dari fungsi yang sudah dibuat, yaitu basic block untuk then, else dan cont yang dinamai "entry", jika memiliki nama basic block yang sama makan nama tersebut akan ditambahkan angka, misalnya "entry" -> "entry1" -> "entry2". Untuk menentukan cabang mana yang akan dijalankan adalah dengan phi node dengan memberikan daftar instruksi dari sebuah basic block dan nilai dari basic block itu sendiri.

Test JIT

Tambahkan kode ini di bagian paling bawah untuk mengetest fungsi yang ada pada file jit.rs ini:

impl<'ctx> Compiler<'ctx> {
 ....
}

// tambahkan test disini
#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_eval_from_expression() {
        let expression = Expression::Binary(
            Box::new(Expression::Binary(
                Box::new(Expression::from(3)),
                Token::Add,
                Box::new(Expression::from(2)),
            )),
            Token::Sub,
            Box::new(Expression::from(2)),
        );

        let context = Context::create();
        let module = context.create_module("test_hitung");
        let builder = context.create_builder();

        let mut compiler = Compiler {
            context: &context,
            module,
            builder,
            variables: Default::default(),
            debug: false,
        };

        let actual = compiler.jit_compile(expression).unwrap();
        assert_eq!(3.0, actual);
    }

    #[test]
    fn test_eval_from_source() {
        let context = Context::create();
        let mut compiler = Compiler::new(&context, false);

        let actual = compiler.compile_source(r"2 + 2 * 3 / 2").unwrap();

        assert_eq!(5.0, actual);
    }

    #[test]
    fn test_eval_from_source_if_then_else() {
        let context = Context::create();
        let mut compiler = Compiler::new(&context, false);

        let actual = compiler.compile_source(r"if 1 < 2 then 123 else 456").unwrap();

        assert_eq!(123.0, actual);
    }
}

jalankan test dan pastikan semuanya sukses

cargo test

Main

Saatnya kembali ke file main.rs untuk menggunakan jit compiler yang telah dibuat, pastikan file main.rs menjadi seperti dibawah ini:

use std::io;
use std::io::Write;

use inkwell::context::Context;

mod expression;
mod jit;
mod lexer;
mod parser;
mod token;

use jit::Compiler;

fn main() {
    let mut debug = false;

    for arg in std::env::args() {
        match arg.as_str() {
            "debug" => debug = true,
            _ => (),
        }
    }

    let context = Context::create();
    let mut compiler = Compiler::new(&context, debug);

    loop {
        // repl
        println!();
        print!("> ");

        io::stdout().flush().expect("Error when flush stdout.");

        let mut input = String::new();

        io::stdin()
            .read_line(&mut input)
            .expect("Could not read from standard input.");

        match compiler.compile_source(input.as_str()) {
            Ok(result) => println!("{}", result),
            Err(err) => {
                eprintln!("Error {:?}", err);
                break
            },
        }
    }
}

Jalankan program dan aktifkan debug mode

cargo run debug

Silahkan ketikan input yang diinginkan, contoh:

a = 2 // tekan enter
a + 2 * 3 tekan enter

Maka hasilnya adalah 8

contoh menghitung:

2 + ( 4 + 5) * 7 / 2 * 4

Hasilnya 128

contoh if then else:

if 20 > 15 then 100 else 99

Hasilnya 100

Jika debug aktif pastikan anda dapat melihat file hitung.ll

Masih banyak sekali hal yang dapat ditingkatkan di bahasa "hitung" ini, misalnya menambahkan fungsi dan memanggil fungsi tersebut, for loop, if then else yang tidak hanya 1 level.

Sekian.

1. Bagian 1 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-lexer/
2. Bagian 2 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-parser/
3. (Disini) Bagian 3 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-jit-compiler/

Untuk kode yang sudah lengkap bisa dilihat di github: https://github.com/aldidana/hitung

Proses parsing akan memvalidasi token yang sudah ada menjadi sebuah AST (Abstract Syntax Tree), AST yaitu sebuah pohon yang berisikan Expression dari token yang ada seperti pada gambar diatas.

Untuk parser kita akan menggunakan teknik Pratt Parser yang berdasarkan Recursive Descent. Pratt Parser dan Recursive Descent mengambil paradigma dari Top Down Precedence Parsing menerapkan leftmost derivation yaitu akan memproses dari root atau akarnya kemudian dari kiri ke kanan.

Disini kita akan menggunakan nilai left binding power dari sebuah token seperti yang ada di kode token.rs

....
pub fn lbp(&self) -> usize {
	match *self {
        Token::Add => 10,
        Token::Sub => 10,
        Token::Mul => 20,
        Token::Div => 20,
        Token::LParen => 99,
        Token::ASSIGN => 100,
        Token::RParen => 0,
        _ => 0,
    }
}

Struktur

hitung
│   Cargo.toml   
│
└───src
	| main.rs
	| lexer.rs
   	| token.rs
	| expression.rs // file baru
	| parser.rs // file baru

Expression

Pertama kita akan membuat sebuah file expression.rs yaitu representasi dari AST.

Tambahkan kode berikut ini:

use crate::token::Token;

#[derive(Debug, PartialEq)]
pub enum Expression {
    Num(f64),
    Unary(Token, Box<Expression>),
    Binary(Box<Expression>, Token, Box<Expression>),
    Paren(Box<Expression>),
    Variable(String),
    Conditional(Box<Expression>, Box<Expression>, Box<Expression>),
}

impl From<isize> for Expression {
    fn from(n: isize) -> Self {
        Expression::Num(n as f64)
    }
}

Untuk enum Expression terutama dibagian yang menggunakan Box dimana berisikan enum Expression itu sendiri (Recursive structure) kita membutuhkan Box<T>. Untuk Recursive structure dibutuhkan sebanyak apa alokasi ukuran/size yang dibutuhkan di memory, contoh dibawah ini tidak akan bisa dicompile:

pub enum Expression {
	...
    Unary(Token, Expression),
    // disini compiler tidak tahu seberapa banyak alokasi yang dibutuhkan
    // dengan menggunakan Box yang dimana sudah ditentukan ukurannya
    // maka untuk `Unary` kita akan tahu berapa ukuran yang dibutuhkan
}

Box adalah smart pointer yang mengalokasikan data ke dalam heap dengan nilai bertipe data T, Box termasuk smart pointer dikarenakan ketika Box sudah tidak digunakan lagi maka otomatis destructor untuk Box tersebut akan dipanggil dan object yang ada didalamnya akan dihapus serta memory di heap akan dihapus/freed.

Parser

Untuk selanjutnya buat file parser.rs dan tambahkan kode berikut:

use std::iter::Iterator;
use std::iter::Peekable;
use std::vec::IntoIter;

use crate::expression::Expression;
use crate::token::Token;

pub struct Parser {
    tokens: Peekable<IntoIter<Token>>,
}

impl Parser {
    pub fn new(tokens: Vec<Token>) -> Self {
        Parser {
            tokens: tokens.into_iter().peekable(),
        }
    }

    pub fn handle_next(&mut self) -> Result<Token, String> {
        self.tokens.next().ok_or("Error get next token".to_string())
    }
}

Struct Parser berisikan tokens yang akan diproses untuk menjadi sebuah Expression. Disini kita membuat Iterator dari tokens tersebut sama seperti input di bagian 1 Lexer.

Tambahkan kode berikut ini setelah fungsi handle_next()

//Null Denotation
pub fn nud(&mut self, token: Token) -> Result<Expression, String> {
    match token {
        Token::ILLEGAL => Err("Input not supported".to_string()),
        Token::IDENTIFIER(i) => Ok(Expression::Variable(i)),
        Token::Num(n) => Ok(Expression::Num(n)),
        Token::Sub | Token::Add => {
            let tok = self.tokens.next().expect("eee");
            match tok {
                Token::Num(n) => {
                    Ok(Expression::Unary(
                        token.clone(),
                        Box::new(Expression::Num(n)),
                    ))
                }
                _ => Err("Input not supported".to_string()),
            }
        }
        Token::LParen => {
            let mut parenthesis = Vec::new();
            let mut counter: usize = 1;

            while let Some(token) = self.tokens.next() {
                match &token {
                    Token::LParen => counter += 1,
                    Token::RParen => {
                        match counter {
                            1 => {
                                return Parser::new(parenthesis)
                                    .expr(0)
                                    .map(|t| Expression::Paren(Box::new(t)));
                            }
                            0 => return Err("Unmatched closing paren".to_string()),
                            _ => {}
                        };
                        counter -= 1;
                    }
                    _ => {}
                };
                parenthesis.push(token);
            }

            Err("Unmatched closing paren".to_string())
        }
        Token::RParen => Err("Unmatched closing paren".to_string()),
        Token::If => {
            let lhs = self.handle_next()?;
            let cmp = self.handle_next()?;
            let rhs = self.handle_next()?;

            let lhs = self.nud(lhs)?;
            let rhs = self.nud(rhs)?;

            let left = Box::new(
                Expression::Binary(
                    Box::new(lhs),
                    cmp,
                    Box::new(rhs),
                )
            );

            let then = self.handle_next()?;
            let then = self.handle_next()?;
            let then_expression = self.nud(then)?;
            let else_if = self.handle_next()?;
            let else_if = self.handle_next()?;
            let else_expression = self.nud(else_if)?;

            Ok(Expression::Conditional(
                left,
                Box::new(then_expression),
                Box::new(else_expression),
            ))
        }
        _ => Err(format!("Token {:?} error", token.clone())),
    }
}

Nud atau null denotation adalah fungsi yang akan memproses sebuah token prefix disinilah yang hanya memproses sebuah literal dalam contoh ini sebuah number dan variable sedangkan Led atau Left Denotation yang akan memproses sebuah token infix dalam contoh ini adalah operator Binary.

Fungsi nud akan menentukan setiap token akan menjadi Expression yang sudah ditentukan, untuk hal branching atau if saat ini kita akan membatasi hanya 1 level jadi kita tidak akan bisa melakukan if didalam if.

selanjutnya untuk fungsi led tambahkan kode berikut setelah fungsi nud diatas:

...
//Left Denotation
pub fn led(&mut self, bp: usize, left: Expression, token: Token) -> Result<Expression, String> {
    match token {
        Token::Add | Token::Sub | Token::Mul | Token::Div | Token::ASSIGN => {
            let rhs = self.expr(bp)?;
            Ok(Expression::Binary(
                Box::new(left),
                token,
                Box::new(rhs),
            ))
        }
        _ => Err(format!("Token {:?} error", token)),
    }
}

Selanjutnya tambahkan fungsi expr setelah fungsi led, fungsi expr inilah yang akan mengevaluasi setiap token dan memanggil fungsi sebelumnya yaitu fungsi nud dan led. Berikut kodenya:

pub fn expr(&mut self, rbp: usize) -> Result<Expression, String> {
    let first_token = self.handle_next()?;
    let mut left = self.nud(first_token)?;

    while let Some(peeked) = self.tokens.peek() {
        if *peeked == Token::ILLEGAL {
            return Err("Input not supported".to_string());
        }

        if rbp >= peeked.lbp() {
            break;
        }

        let op = self.handle_next()?;
        left = self.led(op.lbp(), left, op)?;
    }

    Ok(left)
}

Test Parser

Jangan lupa untuk meambahkan test untuk parser.rs, tambahkan kode berikut dibagian paling bawah:

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn test_nud() {
		let tokens = vec![
			Token::Sub,
			Token::from(3),
			Token::Mul,
			Token::from(2),
			Token::EOF,
		];
		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Binary(
			Box::new(Expression::Unary(
				Token::Sub,
				Box::new(Expression::from(3))
			)),
			Token::Mul,
			Box::new(Expression::from(2)),
		);

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_error() {
		let tokens = vec![Token::Mul, Token::from(2), Token::EOF];
		let expression = Parser::new(tokens).expr(0).map_err(|e| e);

		let expected = Err(String::from("Token Mul error"));

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_binary() {
		let tokens = vec![Token::from(3), Token::Div, Token::from(2), Token::EOF];
		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Binary(
			Box::new(Expression::from(3)),
			Token::Div,
			Box::new(Expression::from(2)),
		);

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_unary() {
		let tokens = vec![Token::Sub, Token::from(2), Token::EOF];
		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Unary(Token::Sub, Box::new(Expression::from(2)));

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_precedence_add_and_mul() {
		let tokens = vec![
			Token::from(3),
			Token::Add,
			Token::from(2),
			Token::Mul,
			Token::from(2),
			Token::EOF,
		];
		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Binary(
			Box::new(Expression::from(3)),
			Token::Add,
			Box::new(Expression::Binary(
				Box::new(Expression::from(2)),
				Token::Mul,
				Box::new(Expression::from(2)),
			)),
		);

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_precedence_add_and_sub() {
		let tokens = vec![
			Token::from(3),
			Token::Add,
			Token::from(2),
			Token::Sub,
			Token::from(2),
			Token::EOF,
		];
		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Binary(
			Box::new(Expression::Binary(
				Box::new(Expression::from(3)),
				Token::Add,
				Box::new(Expression::from(2)),
			)),
			Token::Sub,
			Box::new(Expression::from(2)),
		);

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_assignment() {
		let tokens = vec![
			Token::IDENTIFIER("a".to_string()),
			Token::ASSIGN,
			Token::from(2),
		];

		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Binary(
			Box::new(Expression::Variable("a".to_string())),
			Token::ASSIGN,
			Box::new(Expression::from(2)),
		);

		assert_eq!(expected, expression);
	}

	#[test]
	fn test_if_then_else() {
		let tokens = vec![
			Token::If,
			Token::from(1),
			Token::LT,
			Token::from(9),
			Token::Then,
			Token::from(1),
			Token::Else,
			Token::from(0),
		];

		let expression = Parser::new(tokens).expr(0).unwrap();

		let expected = Expression::Conditional(
			Box::new(Expression::Binary(
				Box::new(Expression::from(1)),
				Token::LT,
				Box::new(Expression::from(9)),
			)),
			Box::new(Expression::from(1)),
			Box::new(Expression::from(0)),
		);

		assert_eq!(expected, expression);
	}
}

Main

Setelah menambahkan beberapa kode diatas, saatnya untuk mencoba menjalankan program dengan menggunakan parser yang telah kita buat.

Tambahkan kode berikut ini di file main.rs

use std::io;
use std::io::Write;

mod lexer;
mod token;
mod expression;
mod parser;

use lexer::Lexer;
use parser::Parser;

fn main() {
    loop {
        println!();
        print!("> ");

        io::stdout()
            .flush()
            .expect("Error when flush stdout.");

        let mut input = String::new();

        io::stdin()
            .read_line(&mut input)
            .expect("Could not read from standard input.");

        let lexer = Lexer::new(input.as_str());
        let result = lexer.lex();

        let mut parser = Parser::new(result);
        match parser.expr(0) {
            Ok(expression) => println!("Result {:?}", expression),
            Err(err) => eprintln!("Error {:?}", err),
        }
    }
}

Disini kita menambahkan 2 file yaitu expression.rs dan parser.rs

Untuk melihat hasilnya jalankan program dengan perintah sebagai berikut:

cargo run

Input kode berikut ini

a = 1 * 2 + 3 * 4

Maka kode diatas akan menghasilkan AST berupa expression sebagai berikut

Binary(Binary(Binary(Variable("a"), ASSIGN, Num(1.0)), Mul, Num(2.0)), Add, Binary(Num(3.0), Mul, Num(4.0)))

contoh lainnya:

if 1 > 2 then 1 else 0

hasilnya sebagai berikut:

Conditional(Binary(Num(1.0), GT, Num(2.0)), Num(1.0), Num(0.0))

1. Bagian 1 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-lexer/
2. (Disini) Bagian 2 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-parser/
3. Bagian 3 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-jit-compiler/

Untuk kode yang sudah lengkap bisa dilihat di github: https://github.com/aldidana/hitung

Pada gambar diatas setiap character dalam kode sumber akan ditentukan masuk ke bagian token yang sesuai.

Membuat Program Baru

Untuk mengikuti ini pastikan Rust sudah ter-install, kemudian ikuti perintah dibawah ini untuk membuat program Rust baru:

cargo new hitung

Struktur File

Struktur yang akan dibuat untuk saat ini:

hitung
│   Cargo.toml   
│
└───src
	| main.rs
	| lexer.rs
   	| token.rs

Token

Kita akan memulai pada file token.rs, tambahkan kode berikut:

#[derive(Debug, PartialEq, Clone)]
pub enum Token {
	LParen,
	RParen,
	Add,
	Sub,
	Mul,
	Div,
	Num(f64),
	EOF,
	ILLEGAL,
	ASSIGN,
	IDENTIFIER(String),
	If,
	Then,
	Else,
	EQ,
	LT,
	GT,
}

impl From<i32> for Token {
	fn from(n: i32) -> Self {
		Token::Num(n as f64)
	}
}

impl Token {
	//Left Binding Power
	pub fn lbp(&self) -> usize {
		match *self {
			Token::Add => 10,
			Token::Sub => 10,
			Token::Mul => 20,
			Token::Div => 20,
			Token::LParen => 99,
			Token::ASSIGN => 100,
			Token::RParen => 0,
			_ => 0,
		}
	}
}

Dibagian ini kita membuat sebuah enum Token dengan nama yang sudah ditentukan, enum juga dapat diberikan sebuah tipe data didalamnya seperti Token::Num(f64) diatas.

Selanjutnya Token juga dapat melakukan konversi dari tipe data i32 menjadi f64, dengan implementasi trait From, trait From ini memiliki metode atau fungsi from yang mengambil tipe data generic, contoh:

trait From<T> {
  pub fn from(_: T) -> Self
}

// Token mempunyai metode atau fungsi from

Token::from(2) // akan menjadi tipe data f64
Token::Num(2.0)

Pada kode terakhir token disini untuk menentukan seberapa beban atau prioritas sebuah token dibanding token lainnya misalnya perkalian lebih dulu di evaluasi dibandingkan dengan penjumlahan, sehingga 3+2*2 adalah 7 bukan 10, tetapi jika hasilnya ingin 10 bisa menggunakan tanda kurung (3+2)*2.

Test Token

Jangan lupa menambahkan test untuk token.rs, tambahkan kode berikut ini setelah baris terakhir dari kode yang ada di dalam token.rs:

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn test_token_add() {
		let actual = Token::Add.lbp();
		let expected: usize = 10;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_sub() {
		let actual = Token::Sub.lbp();
		let expected: usize = 10;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_mul() {
		let actual = Token::Mul.lbp();
		let expected: usize = 20;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_div() {
		let actual = Token::Div.lbp();
		let expected: usize = 20;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_open_paren() {
		let actual = Token::LParen.lbp();
		let expected: usize = 99;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_close_paren() {
		let actual = Token::RParen.lbp();
		let expected: usize = 0;

		assert_eq!(expected, actual);
	}

	#[test]
	fn test_token_assignment() {
		let actual = Token::ASSIGN.lbp();
		let expected: usize = 100;

		assert_eq!(expected, actual);
	}
}

Disini kita membuat test untuk mengecek left binding power dari sebuah token.

Lexer

Lanjut ke file lexer.rs, pada bagian awal baris tambahkan kode berikut ini:

use std::iter::Peekable;
use std:str:Chars;

use crate::token::Token;

Jangan khawatir akan dijelaskan mengenai barisan kode tersebut. Disini kita akan menggunakan Peekable dan Chars. Peekable yaitu sebuah iterator yang mempunyai metode atau fungsi peek() yang akan mengembalikan sebuah reference dari elemen berikutnya, sehingga posisi sebuah char tidak akan maju ke elemen berikutnya, contohnya seperti ini:

let array = [1, 2, 3]; //sebuah array

let mut iter = array.iter().peekable(); // maka iter akan mempunyai metode atau fungsi peek

iter.peek() // akan mengembalikan tipe optional sehinnga isinya Some(1)
iter.peek() // Some(1)
iter.peek() // Some(1)

// Tidak peduli seberapa banyak kita memanggil fungsi peek() iterator tidak akan maju ke elemen berikutnya

iter.next() // maju ke elemen berikutnya

iter.peek() // Some(2)

Kemudian menggunakan Chars karena akan menyimpan input dari kode sumber menjadi sebuah Peekable yang didalamnya mempunyai tipe Chars. Selanjutnya untuk token adalah meng-import agar dapat mengakses Enum Token yang sudah dibuat sebelumnya.

Tambahkan kode berikut ini setelah kode lexer.rs terakhir:

#[derive(Debug)]
pub struct Lexer<'a> {
	input: Peekable<Chars<'a>>,
}

impl <'a> Lexer<'a> {
	pub fn new(input: &str) -> Self {
    	Lexer {
        	input: input.chars().peekable(),
        }
        
	pub fn lex(mut self) -> Vec<Token> {
		let mut tokens = vec![];
        loop {
            let current_token = self.next_token();
            if current_token == Token::EOF || current_token == Token::ILLEGAL {
                tokens.push(current_token);
                break;
            } else {
                tokens.push(current_token);
            }
        }

        tokens
    }
}

Pada bagian ini kita membuat Struct Lexer dengan reference yang ditandai oleh lifetime 'a, Struct Lexer mempunyai field input berupa Peekable yang mempunyai tipe data Chars, Chars juga membutuhkan lifetime parameter.

Berikut in mengenai penjelasan sederhana mengenai lifetime diatas:

struct DB {
	.....
}

struct App {
	database: &DB, // borrow atau meminjam struct DB diatas
}

// kode diatas tidak akan bisa dicompile
// dikarenakan struct DB tidak diketahui lifetimenya

struct App<'a> {
	database: &'a DB,
}

// Kode diatas berhasil dicompile
// karena field database yang mempunyai tipe DB mempunyai lifetime yang sama seperti App
// Struct App tidak boleh outlive dari reference yaitu struct DB

fungsi new() dari Lexer adalah associated functions untuk membuat sebuah instance dari tipe data itu sendiri.

.... {
	fn new() -> Self // ini adalah associated function karena tidak mengambil self pada parameter pertama

	fn move(&mut self) // methods
    fn attack(self) // methods
}

Sedangkan fungsi lex() adalah sebuah methods dari Lexer, fungsi ini akan melakukan perulangan hingga input berupa kode sumber selesai atau berakhir.

Masih di dalam file lexer.rs, tambahkan kode dibawah ini tepat setelah fungsi lex dan masih di dalam block impl dari Lexer

// masih di dalam impl Lexer
.... {
	pub fn next_token(&mut self) -> Token {
		match self.input.peek() {
			Some(ch) => match ch {
				' ' | '\t' => {
					self.input.next();
					self.next_token()
				}
				'\n' => {
					self.input.next();
					self.next_token()
				}
				ch if ch.is_numeric() => self.read_numeric(),
				'+' => {
					self.input.next();
					Token::Add
				}
				'-' => {
					self.input.next();
					Token::Sub
				}
				'*' => {
					self.input.next();
					Token::Mul
				}
				'/' => {
					self.input.next();
					Token::Div
				}
				'(' => {
					self.input.next();
					Token::LParen
				}
				')' => {
					self.input.next();
					Token::RParen
				}
				ch if ch.is_alphabetic() => {
					self.read_identifier()
				}
				'=' => {
					self.input.next();
					match self.input.peek() {
						Some(c) => {
							if *c == '=' {
								self.input.next();
								Token::EQ
							} else {
								self.input.next();
								Token::ASSIGN
							}
						}
						_ => {
							self.next_token()
						}
					}
				}
				'<' => {
					self.input.next();
					Token::LT
				}
				'>' => {
					self.input.next();
					Token::GT
				}
				_ => {
					self.input.next();
					Token::ILLEGAL
				}
			},
			None => Token::EOF,
		}
	}

	fn read_numeric(&mut self) -> Token {
		let mut literal = String::new();

		loop {
			match self.input.peek() {
				Some(&ch) => {
					if ch.is_numeric() || ch == '.' {
						literal.push(ch);
						self.input.next();
					} else {
						break;
					}
				}
				_ => break,
			}
		}

		match literal.parse() {
			Ok(l) => Token::Num(l),
			Err(_e) => Token::ILLEGAL,
		}
	}

	fn read_identifier(&mut self) -> Token {
		let mut literal = String::new();

		loop {
			match self.input.peek() {
				Some(&ch) => {
					if !ch.is_alphabetic() {
						break;
					}
					if ch.is_ascii_whitespace() {
						// self.input.next();
						break;
					};
					literal.push(ch);
					self.input.next();
				},
				_ => break
			}
		};

		match literal.as_str() {
			"if" => Token::If,
			"then" => Token::Then,
			"else" => Token::Else,
			_ => Token::IDENTIFIER(literal),
		}
	}
}

fungsi berikutnya ini cukup sederhana, megecek input dari kode sumber  yang akan menjadi token yang sudah kita tentukan.

&mut self pada fungsi adalah agar kita dapat mengubah data dari object itu sendiri, tanpa mengambil atau memindahkan ownership.

&mut self: mutable reference tanpa mengambil/memindahkan ownership

• &mut self: mutable reference tanpa mengambil/memindahkan ownership
• mut self: mutable dengan mengambil/memindahkan ownership
• self: immutable dengan mengambil/memindahkan ownership
• &self: immutable tanpa mengambil/memindahkan ownership

Test Lexer

Terakhir kita tambahkan test untuk lexer.rs pada baris terakhir

impl<'a> Lexer<'a> {
	......
}

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn test_num() {
		let lexer = Lexer::new(r#"32"#);
		let tokens = lexer.lex();

		let expected = vec![Token::from(32), Token::EOF];
		assert_eq!(expected, tokens);
	}

	#[test]
	fn test_num_float() {
		let lexer = Lexer::new(r#"32.5"#);
		let tokens = lexer.lex();

		let expected = vec![Token::Num(32.5), Token::EOF];
		assert_eq!(expected, tokens);
	}

	#[test]
	fn test_num_whitespace() {
		let lexer = Lexer::new(r#"32 2"#);
		let tokens = lexer.lex();

		let expected = vec![Token::from(32), Token::from(2), Token::EOF];

		assert_eq!(expected, tokens);
	}

	#[test]
	fn test_num_operator() {
		let lexer = Lexer::new(r#"-+/*"#);
		let tokens = lexer.lex();

		let expected = vec![
			Token::Sub,
			Token::Add,
			Token::Div,
			Token::Mul,
			Token::EOF,
		];

		assert_eq!(expected, tokens);
	}

	#[test]
	fn test_assignment() {
		let lexer = Lexer::new(r#"a = 123"#);
		let tokens = lexer.lex();

		let expected = vec![
			Token::IDENTIFIER("a".to_string()),
			Token::ASSIGN,
			Token::from(123),
			Token::EOF,
		];

		assert_eq!(expected, tokens);
	}

	#[test]
	fn test_conditional() {
		let lexer = Lexer::new(r#"if 1 < 2 then 1 else 0"#);
		let tokens = lexer.lex();

		let expected = vec![
			Token::If,
			Token::from(1),
			Token::LT,
			Token::from(2),
			Token::Then,
			Token::from(1),
			Token::Else,
			Token::from(0),
			Token::EOF,
		];

		assert_eq!(expected, tokens);
	}
}

Main

Kembali ke fungsi utama untuk menjalankan program ini yaitu main.rs, tambahkan kode berikut:

use std::io;
use std::io::Write;

mod lexer;
mod token;

use lexer::Lexer;

fn main() {
    loop {
        println!();
        print!("> ");

        io::stdout()
            .flush()
            .expect("Could not read from standard input.");

        let mut input = String::new();

        io::stdin()
            .read_line(&mut input)
            .expect("Could not read from standard input.");

        let lexer = Lexer::new(input.as_str());
        let result = lexer.lex();

        println!("{:?}", result);
    }
}

Pada bagian ini kita menggunakan standard library untuk io (input/output) dan juga Trait Write agar io::stdout() dapat menjalankan fungsi flush(). Kemudian kita membaca setiap input yang masuk ke dalam program dan memanggil fungsi yang ada pada Lexer untuk menghasilkan sebuah token.

Jalankan program dengan perintah berikut pada terminal:

cargo run

Kemudian ketik input yang diinginkan lalu tekan enter pada keyboard, misalnya:

if 1 > 2 then 1 else 0

maka akan menghasilkan token sebagai berikut:

[If, Num(1.0), GT, Num(2.0), Then, Num(1.0), Else, Num(0.0), EOF]

contoh lain:

a = 123

maka hasilnya:

[IDENTIFIER("a"), ASSIGN, Num(123), EOF]

Sekian untuk bagian pertama dari Membuat Bahasa Pemrograman Sederhana dengan Rust dan LLVM.

1. (Disini) Bagian 1 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-lexer/
2. Bagian 2 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-parser/
3. Bagian 3 - https://aldidana.com/membuat-bahasa-pemrograman-rust-llvm-jit-compiler/

Contoh pattern matching di Rust adalah sebagai berikut:

let angka = 1;

match angka {
	1 => println!("Satu"),
    2..=5 => println!("Dua sampai Lima"),
    _ => println!("Berapa saja selain diatas")
}

Sedangkan berikut ini salah satu contoh pattern matching untuk bahasa pemrograman elixir:

angka = 7

case angka do
  1 -> IO.puts("Satu")
  x when x < 6 -> IO.puts("Dua sampai Lima")
  _x -> IO.puts("Berapa saja selain diatas")
end

Untuk membuat pattern matching seperti contoh diatas kita dapat menerapkannya dengan fungsi berikut ini.

function matcher(pattern) {
  return (input) => {
    const patternFound = pattern[input];
    if (!patternFound) {
      return pattern['x'](input)
    };
    return patternFound(input);
  };
}

const match = matcher({
  1: () => console.log('Satu'),
  2: () => console.log('Dua sampai Lima'),
  3: () => console.log('Dua sampai Lima'),
  4: () => console.log('Dua sampai Lima'),
  5: () => console.log('Dua sampai Lima'),
  x: (n) => {
    console.log('x', n);
  }
})

match(12);

Tentu saja fungsi yang dibuat tersebut masih banyak memiliki kekurangan seperti memilih range tertentu untuk angka.

Jika menginginkan feature yang lebih banyak untuk pattern matching di Javascript kita bisa menggunakan https://github.com/z-pattern-matching/z atau menunggu proposal berikut https://github.com/tc39/proposal-pattern-matching

Buat file vm.rs dan tambahkan code berikut:

use crate::bytecode;

pub struct VM {
  code: Vec<isize>,
  stack: Vec<isize>,
  
  pc: usize, //program counter or ip (instruction pointer)
  sp: isize, //stack pointer
  
  debug: bool,
}

pada bagian use crate::bytecode; kita akan menggunakan module bytecode.rs yang telah kita buat dan gunakan di main.rs, kegunaan mod bytecode; pada file main.rs di bagian 1 adalah agar kita dapat menggunakannya di file lain.

Biasanya sebuah VM terdiri dari frame, call stack, globals, locals dan lainnya, dikarenakan kita hanya membuat VM yang sangat sederhana maka kita membuat struct VM yang berisikan:

• code berupa instructions yang telah kita generate menjadi code.
• stack dimana kita akan menyimpan data kita.
• pc (program counter) atau biasanya disebut ip (instruction pointer), adalah petunjuk sebuah instruksi yang menyimpan sebuah alamat (memory address) untuk di eksekusi berikutnya.
• sp (stack pointer) fungsinya mirip sepeti pc/ip tetapi menunjukkan lokasi dimana alamat (memory address) pada sebuah stack.
• debug hanya digunakan untuk men-debug.

untuk lebih jelasnya mengenai Rust numeric type, seperti isize dan usize dapat dilihat disini https://doc.rust-lang.org/reference/types/numeric.html.

tambahkan code berikut di vm.rs setelah code diatas

impl VM {
  pub fn new(code: Vec<isize>, capacity: usize, debug: bool) -> Self {
    VM {
      code: code,
      stack: Vec::with_capacity(capacity),
      pc: 0,
      sp: -1,
      debug: debug,
    }
  }
}

Kita menambahkan associated functions new pada VM. Disini stack merupakan Vector dengan kapasitas yang telah kita berikan pada parameter capacity serta stack pointer yang dimulai dari -1.

Mengenai Array dan Vector lebih jelasnya bisa dilihat disini https://www.cs.brandeis.edu/~cs146a/rust/doc-02-21-2015/book/arrays-vectors-and-slices.html

Sebelum melanjutkan dibagian vm.rs ini, kembali ke file bytecode.rs dan tambahkan code berikut di bagian paling bawah (bukan didalam Impl Instruction):

.....

pub fn disassemble(code: isize, pc: usize) -> (Opcode, isize) {
  match code {
    code if code == Opcode::CONST(code).code() => (Opcode::CONST(pc as isize), 1),
    code if code == Opcode::ADD.code() => (Opcode::ADD, 0),
    code if code == Opcode::SUB.code() => (Opcode::SUB, 0),
    code if code == Opcode::PRINT.code() => (Opcode::PRINT, 0),
    code if code == Opcode::HALT.code() => (Opcode::HALT, 0),
    _ => (Opcode::HALT, 0),
  }
}

fungsi disassemble untuk mengembalikan tuple berupa nama Opcode dan jumlah Operand pada Opcode tersebut.

Kembali ke file vm.rs tambahkan code berikut setelah new

impl VM {
  pub fn new ...
  
  // tambahkan disini
  pub fn run(mut self, pc: usize) {
    self.pc = pc;
  
    while self.pc < self.code.len()  {
      let opcode = self.code[self.pc];
      if self.debug {
        let instructions = bytecode::disassemble(opcode, self.pc);
        if instructions.1 < 1 {
          println!("[{:04X}] {:?}", self.pc, instructions.0);
        }
        if instructions.1 == 1 {
          println!("[{:04X}] {:?} {:?}", self.pc, instructions.0, self.code[self.pc+1]);
        }
      }
      
      self.pc += 1;
      match opcode {
        opcode if opcode == bytecode::Opcode::CONST(opcode).code() => {
          let value = self.code[self.pc];
          self.pc += 1;
          self.sp += 1;
          let current_sp = self.sp as usize;
          self.stack.insert(current_sp, value as isize);
        },
        opcode if opcode == bytecode::Opcode::ADD.code() => {
          let rhs = self.stack.pop().expect("invalid value");
          let lhs = self.stack.pop().expect("invalid value");		
          let value = lhs + rhs;
          self.stack.push(value);
          
          self.sp -= 1;
        },
        opcode if opcode == bytecode::Opcode::SUB.code() => {
          let rhs = self.stack.pop().expect("invalid value");
          let lhs = self.stack.pop().expect("invalid value");
          let value = lhs - rhs;
          self.stack.push(value);
          
          self.sp -= 1;
        },
        opcode if opcode == bytecode::Opcode::PRINT.code() => {
          let current_sp = self.sp as usize;
          let value = self.stack[current_sp];
          self.sp -= 1;
          println!("{}", value)
        },
        opcode if opcode == bytecode::Opcode::HALT.code() => {
          break
        },
        _ => panic!("Opcode {} is not supported", opcode),
      }
    }
  }
}

Fungsi run adalah untuk mengeksekusi sebuah code yang telah kita masukan. opcode disini diambil melalui pc/ip pada code, kemudian kita mengecek apakah kita akan melakukan debug pada program, jika kita melakukan debug pada program maka akan memanggil fungsi disassemble yang telah kita buat di file bytecode.rs, debug akan mencetak instruction yang diberikan.

selama program berjalan maka pc (program counter) akan berubah sesuai dengan instruksi yang diberikan.

Ketika melakukan perintah CONST, sp (stack poiner) akan bergerak (dengan menambahkan) dan mengisi data ke stack sesuai dengan alamat stack pointer tersebut. Untuk perintah ADD dan SUB sama-sama mengambil nilai (pop) dari stack (isi stack berkurang) yang kemudian akan dilakukan operasi ADD (penjumlahan) atau SUB (pengurangan) dimana hasil tersebut akan dimasukan ke dalam stack. Kemudian perintah PRINT akan mengambil data dari stack.

Setelah itu kembali ke file main.rs dan tambahkan code berikut:

mod bytecode;
mod vm;

fn main() {
  //code sebelumnya di bagian-1
  ...
  let pc_start = 0;
  let stack_size = 100;
  let debug = true;
  
  let vm = vm::VM::new(code, stack_size, debug);
  vm.run(pc_start)
}

jalankan program yang telah dibuat

cargo run

hasilnya berupa nilai dari penjumlahan dan penguran:

[0000] CONST(0) 10
[0002] CONST(2) 20
[0004] ADD
[0005] CONST(5) 9
[0007] SUB
[0008] PRINT
21

VM (Virtual Machine) adalah sebuah program yang menyerupai sebuah komputer dengan mensimulasikan CPU untuk melakukan berbagai macam perintah layaknya sebuah komputer fisik berdasarkan tujuan VM tersebut dibuat.

VM terdiri dari 2 arsitektur:

1. Stack based
2. Register based

Pada post kali ini kita akan membuat Stack based VM. Salah satu contoh dari Stack based VM adalah JVM (Java Virtual Machine), stack based VM juga lebih mudah diimplementasikan dibandingkan Register based.

Cara Kerja VM

Cara kerja VM ini cukup sederhana:

1. Mengambil instruksi pada daftar instruksi atau code.
2. Decode instruksi tersebut.
3. Eksekusi hasil dari decode.

Instructions

Instructions adalah serangkaian perintah untuk melakukan suatu tugas/task, seperti mendeklarasikan suatu variabel dan menambahkannya dengan variabel lainnya jika kedua variabel tersebut bertipe data numeric. Instructions ini terdiri dari Operation Code (opcode) dan Operands.

Untuk mencetak 8 + 10, berikut ini adalah contoh perintahnya:

CONST 8 // mendeklarasikan sebuah variabel dengan nilai 8
CONST 10 // mendeklarasikan sebuah variabel dengan nilai 10
ADD // menambahkan kedua variabel diatas
PRINT // mencetak

Stack

Sesuai dengan VM yang akan diimplementasikan yaitu Stack based, sama seperti tumpukan ketika mencuci piring, piring yang telah dicuci disimpan di paling atas maka stack ini LIFO (Last In First Out) untuk menambahkan (push) maupun mengurangi (pop) hanya melalui posisi paling atas.

Struktur Code

Untuk mengikuti ini pastikan download dan install Rust pada link berikut ini https://www.rust-lang.org/learn/get-started

setelah menginstall Rust, jalankan perintah berikut:

cargo new simple-vm

Kemudian kita akan membuat struktur seperti dibawah ini:

simple-vm
│   Cargo.toml   
│
└───src
	| main.rs
	| vm.rs
	| bytecode.rs

tambahkan code berikut ini pada file bytecode.rs

#[derive(Debug)]
pub enum Opcode {
  CONST(isize), // 0
  ADD, // 1
  SUB, // 2
  PRINT, // 3 
  HALT, // 4
}

impl Opcode {
  pub fn code(&self) -> isize {
    match *self {
      Opcode::CONST(_v) => 0,
      Opcode::ADD => 1,
      Opcode::SUB => 2,
      Opcode::PRINT => 3,
      Opcode::HALT => 4,
	}
  }
}

#[derive(Debug)] adalah attribute dengan mengimplementasikan Debug pada enum Opcode sehingga dengan otomatis kita bisa memformatnya menggunakan {:?}

pub enum Opcode {
  CONST(isize), // 0
  ADD, // 1
  SUB, // 2
  PRINT, // 3 
  HALT, // 4
}

disini kita membuat enum Opcode dengan data diatas yang merepresentasikan nomor/code sesuai dengan urutannya, misalnya untuk CONST(isize) adalah enum constructor yang berisikan tipe data isize yang merepresentasikan code 0. Tanda // hanyalah sebuah comment untuk menjelaskan urutannya.

impl Opcode {
  pub fn code(&self) -> isize {
    match *self {
      Opcode::CONST(_v) => 0,
      Opcode::ADD => 1,
      Opcode::SUB => 2,
      Opcode::PRINT => 3,
      Opcode::HALT => 4,
	}
  }
}

kemudian disini Opcode mempunyai fungsi code untuk mengembalikan nomor/code yang sudah kita sesuaikan.

masih pada bagian file bytecode.rs tambahkan code berikut ini setelahnya.

#[derive(Debug)]
pub struct Instruction {
  insructions: Vec<Opcode>,
}

kita membuat struct Instruction yang berisikan instructions dengan tipe data Vector dari Opcode

impl Instruction {
  pub fn new(opcodes: Vec<Opcode>) -> Self {
    Instruction {
      insructions: opcodes,
    }
  }

  pub fn generate_code(&self) -> Vec<isize> {
    let mut code: Vec<isize> = Vec::new();

    for insruction in self.insructions.iter() {
      match insruction {
        Opcode::CONST(value) => {
          code.push(insruction.code());
          code.push(*value);
        },
        Opcode::ADD => code.push(insruction.code()),
        Opcode::SUB => code.push(insruction.code()),
        Opcode::PRINT => code.push(insruction.code()),
        Opcode::HALT => code.push(insruction.code()),
      };
    }

    code
  }
}

dari struct Instruction diatas kita akan mengimplementasikan beberapa fungsi. Fungsi new adalah associated functions yang tidak mengambil self untuk parameter pertamanya, fungsi ini akan membuat Instruction baru yang berisikan instructions dari opcode. fungsi generate_code adalah fungsi yang mengambil Instruction sendiri, kemudian kita mendeklarasikan variabel code dengan tipe data Vector dari isize, lalu kita akan melakukan pengecekan (match) sesuai enum pada instructions tersebut.

pada file main.rs, tambahkan code berikut:

mod bytecode;

fn main() {
  let instructions: Vec<bytecode::Opcode> = vec!(
        bytecode::Opcode::CONST(10),
        bytecode::Opcode::CONST(20),
        bytecode::Opcode::ADD,
        bytecode::Opcode::CONST(9),
        bytecode::Opcode::SUB,
        bytecode::Opcode::PRINT,
    );

    let instruction = bytecode::Instruction::new(instructions);
    let code = instruction.generate_code();

    println!("{:?}", code);
}

disini kita menggunakan module bytecode.rs yang telah kita buat sebelumnya. Untuk jelasnya mengenai module bisa dilihat disini https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html. Lalu kita memasukan beberapa Opcode pada instructions yang kemudian digunakan untuk men-generate sebuah code untuk di eksekusi oleh VM. Kemudian jalankan program yang telah kita buat dengan perintah berikut

cargo run

maka akan keluar hasil sebagai berikut

[0, 10, 0, 20, 1, 0, 9, 2, 3]

angka tersebut berupa opcode dan operands dari instructions yang telah kita masukan.

bagian 2