bytecode.rs: added CAR/CDR opcode constants and constructors

vm.rs: added VM handlers for Car/Cdr with optimized unsafe access
compiler.rs: detect car/cdr calls and emit specialized opcodes

Author: 0xhenrique

src/bytecode.rs

@@ -54,6 +54,8 @@ impl std::fmt::Debug for Op {
             Self::NEW_LIST => write!(f, "NewList({}, {})", self.a(), self.b()),
             Self::GET_LIST => write!(f, "GetList({}, {}, {})", self.a(), self.b(), self.c()),
             Self::SET_LIST => write!(f, "SetList({}, {}, {})", self.a(), self.b(), self.c()),
+            Self::CAR => write!(f, "Car({}, {})", self.a(), self.b()),
+            Self::CDR => write!(f, "Cdr({}, {})", self.a(), self.b()),
             _ => write!(f, "Unknown(0x{:08x})", self.0),
         }
     }
@@ -95,6 +97,8 @@ impl Op {
     pub const NEW_LIST: u8 = 31;       // AB: dest, nargs
     pub const GET_LIST: u8 = 32;       // ABC: dest, list, index
     pub const SET_LIST: u8 = 33;       // ABC: list, index, value
+    pub const CAR: u8 = 34;            // AB: dest, src - get head of cons/list
+    pub const CDR: u8 = 35;            // AB: dest, src - get tail of cons/list
 
     // ========== Constructors ==========
 
@@ -328,6 +332,16 @@ impl Op {
         Self::abc(Self::SET_LIST, list, index, value)
     }
 
+    #[inline(always)]
+    pub const fn car(dest: Reg, src: Reg) -> Self {
+        Self::abc(Self::CAR, dest, src, 0)
+    }
+
+    #[inline(always)]
+    pub const fn cdr(dest: Reg, src: Reg) -> Self {
+        Self::abc(Self::CDR, dest, src, 0)
+    }
+
     // ========== Jump patching helpers ==========
 
     /// Check if this is a jump instruction (for patching)

src/compiler.rs

@@ -800,6 +800,26 @@ impl Compiler {
                     return Ok(());
                 }
             }
+
+            // Try specialized car/cdr opcodes (single argument)
+            let args = &items[1..];
+            if args.len() == 1 {
+                match op {
+                    "car" => {
+                        // Compile arg into dest, then emit Car
+                        self.compile_expr(&args[0], dest, false)?;
+                        self.emit(Op::car(dest, dest));
+                        return Ok(());
+                    }
+                    "cdr" => {
+                        // Compile arg into dest, then emit Cdr
+                        self.compile_expr(&args[0], dest, false)?;
+                        self.emit(Op::cdr(dest, dest));
+                        return Ok(());
+                    }
+                    _ => {}
+                }
+            }
         }
 
         // Check if calling a global symbol (optimization: use CallGlobal/TailCallGlobal)

src/vm.rs

@@ -680,6 +680,41 @@ impl VM {
                     return Err("SetList not implemented (immutable lists)".to_string());
                 }
 
+                Op::CAR => {
+                    let dest = instr.a();
+                    let src = instr.b();
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    // Fast path: cons cell (most common in list processing)
+                    let result = if let Some(cons) = v.as_cons() {
+                        cons.car.clone()
+                    } else if let Some(list) = v.as_list() {
+                        // Array list
+                        list.first().cloned().ok_or_else(|| "car on empty list".to_string())?
+                    } else {
+                        return Err("car expects a list or cons cell".to_string());
+                    };
+                    unsafe { *self.registers.get_unchecked_mut(base + dest as usize) = result };
+                }
+
+                Op::CDR => {
+                    let dest = instr.a();
+                    let src = instr.b();
+                    let v = unsafe { self.registers.get_unchecked(base + src as usize) };
+                    // Fast path: cons cell (most common in list processing)
+                    let result = if let Some(cons) = v.as_cons() {
+                        cons.cdr.clone()
+                    } else if let Some(list) = v.as_list() {
+                        // Array list - O(n) but rare with cons cells
+                        if list.is_empty() {
+                            return Err("cdr on empty list".to_string());
+                        }
+                        Value::list(list[1..].to_vec())
+                    } else {
+                        return Err("cdr expects a list or cons cell".to_string());
+                    };
+                    unsafe { *self.registers.get_unchecked_mut(base + dest as usize) = result };
+                }
+
                 _ => {
                     return Err(format!("Unknown opcode: {}", instr.opcode()));
                 }
@@ -1215,4 +1250,17 @@ mod tests {
         let result = vm_eval("(do (def sum (fn (n acc) (if (<= n 0) acc (sum (- n 1) (+ acc n))))) (sum 10000 0))").unwrap();
         assert_eq!(result, Value::Int(50005000));
     }
+
+    #[test]
+    fn test_specialized_car_cdr() {
+        // Test specialized car/cdr opcodes with cons cells
+        assert_eq!(vm_eval("(car (cons 1 (cons 2 nil)))").unwrap(), Value::Int(1));
+        assert_eq!(vm_eval("(car (cdr (cons 1 (cons 2 nil))))").unwrap(), Value::Int(2));
+
+        // Test with nested list operations
+        let result = vm_eval("(do (def reverse-acc (fn (lst acc) (if (empty? lst) acc (reverse-acc (cdr lst) (cons (car lst) acc))))) (reverse-acc (cons 1 (cons 2 (cons 3 nil))) nil))").unwrap();
+        // reversed (1 2 3) -> (3 2 1)
+        let cons = result.as_cons().expect("expected cons cell");
+        assert_eq!(cons.car.as_int(), Some(3));
+    }
 }