cemc 0.1.2

Cem language compiler - A concatenative language with green threads and linear types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

/**
Primitive Operations for Cem Runtime

This module handles compilation of built-in operations:
- Stack operations: dup, drop, swap, over, rot
- Arithmetic: +, -, *, /
- Comparisons: <, >, =, <=, >=, !=
- Boolean: and, or, not
- Control flow: if, call

Each primitive is implemented as a runtime function call.
*/

use super::{CodeGen, CodegenResult};
use inkwell::values::PointerValue;

impl<'ctx> CodeGen<'ctx> {
    /// Compile a built-in primitive operation
    pub fn compile_builtin(
        &mut self,
        name: &str,
        stack: PointerValue<'ctx>,
    ) -> CodegenResult<Option<PointerValue<'ctx>>> {
        match name {
            // Stack operations
            "dup" => self.compile_runtime_call("dup", stack),
            "drop" => self.compile_runtime_call("drop", stack),
            "swap" => self.compile_runtime_call("swap", stack),
            "over" => self.compile_runtime_call("over", stack),
            "rot" => self.compile_runtime_call("rot", stack),

            // Arithmetic operations
            "+" => self.compile_runtime_call("add", stack),
            "-" => self.compile_runtime_call("subtract", stack),
            "*" => self.compile_runtime_call("multiply", stack),
            "/" => self.compile_runtime_call("divide", stack),

            // Comparison operations
            "<" => self.compile_runtime_call("less_than", stack),
            ">" => self.compile_runtime_call("greater_than", stack),
            "=" => self.compile_runtime_call("equal", stack),

            // Control flow
            "call" => self.compile_runtime_call("call_quotation", stack),
            "if" => self.compile_runtime_call("if_then_else", stack),

            // Not a built-in
            _ => Ok(None),
        }
    }

    /// Compile a call to a runtime function
    fn compile_runtime_call(
        &mut self,
        fn_name: &str,
        stack: PointerValue<'ctx>,
    ) -> CodegenResult<Option<PointerValue<'ctx>>> {
        // Use the call_runtime helper from the parent module
        let result = self.call_runtime(fn_name, &[stack.into()])?;
        Ok(Some(result))
    }
}

/// List of all built-in primitive operations
pub const PRIMITIVES: &[&str] = &[
    // Stack operations
    "dup", "drop", "swap", "over", "rot",
    // Arithmetic
    "+", "-", "*", "/",
    // Comparisons
    "<", ">", "=",
    // Control flow
    "call", "if",
];

/// Check if a word name is a built-in primitive
pub fn is_primitive(name: &str) -> bool {
    PRIMITIVES.contains(&name)
}

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

    #[test]
    fn test_is_primitive() {
        assert!(is_primitive("dup"));
        assert!(is_primitive("+"));
        assert!(is_primitive("<"));
        assert!(!is_primitive("custom_word"));
    }
}