kov repl (interactive compile+eval), kov import-c (C header to extern decls)

Author: visualstudioblyat

src/codegen/cheader.rs

@@ -0,0 +1,150 @@
+// minimal C header parser — extracts function declarations
+// generates extern "C" fn declarations in Kov syntax
+
+pub fn parse_header(content: &str) -> Vec<String> {
+    let mut decls = Vec::new();
+
+    for line in content.lines() {
+        let line = line.trim();
+        // skip preprocessor, comments, empty
+        if line.starts_with('#') || line.starts_with("//") || line.is_empty() {
+            continue;
+        }
+        // skip typedefs, structs for now
+        if line.starts_with("typedef") || line.starts_with("struct") {
+            continue;
+        }
+        // try to parse: return_type name(params);
+        if let Some(decl) = try_parse_fn_decl(line) {
+            decls.push(decl);
+        }
+    }
+
+    decls
+}
+
+fn try_parse_fn_decl(line: &str) -> Option<String> {
+    let line = line.trim_end_matches(';').trim();
+    let paren = line.find('(')?;
+    let before_paren = &line[..paren].trim();
+    let params_str = &line[paren + 1..line.rfind(')')?];
+
+    // split "void HAL_GPIO_Write" into return type + name
+    let last_space = before_paren.rfind(' ')?;
+    let ret_type = before_paren[..last_space].trim();
+    let name = before_paren[last_space + 1..].trim();
+
+    // skip if name starts with _ (internal)
+    if name.starts_with("__") {
+        return None;
+    }
+
+    // convert C types to Kov types
+    let kov_ret = c_type_to_kov(ret_type);
+    let kov_params = parse_c_params(params_str);
+
+    let params_kov: Vec<String> = kov_params
+        .iter()
+        .enumerate()
+        .map(|(i, ty)| format!("arg{}: {}", i, ty))
+        .collect();
+
+    let ret_str = if kov_ret == "void" {
+        String::new()
+    } else {
+        format!(" {}", kov_ret)
+    };
+
+    Some(format!(
+        "extern \"C\" fn {}({}){};",
+        name,
+        params_kov.join(", "),
+        ret_str
+    ))
+}
+
+fn parse_c_params(params: &str) -> Vec<String> {
+    if params.trim() == "void" || params.trim().is_empty() {
+        return Vec::new();
+    }
+    params
+        .split(',')
+        .map(|p| {
+            let p = p.trim();
+            // extract type (everything before the last word which is the param name)
+            let parts: Vec<&str> = p.split_whitespace().collect();
+            if parts.len() >= 2 {
+                c_type_to_kov(&parts[..parts.len() - 1].join(" "))
+            } else if parts.len() == 1 {
+                c_type_to_kov(parts[0])
+            } else {
+                "u32".into()
+            }
+        })
+        .collect()
+}
+
+fn c_type_to_kov(c_type: &str) -> String {
+    let t = c_type
+        .trim()
+        .replace("const ", "")
+        .replace("volatile ", "")
+        .replace("unsigned ", "u")
+        .replace("signed ", "i");
+    match t.trim() {
+        "void" => "void".into(),
+        "int" | "iint" => "i32".into(),
+        "uint" | "uint32_t" | "ulong" => "u32".into(),
+        "uint8_t" | "uchar" => "u8".into(),
+        "uint16_t" | "ushort" => "u16".into(),
+        "uint64_t" => "u64".into(),
+        "int8_t" | "ichar" | "char" => "i8".into(),
+        "int16_t" | "ishort" | "short" => "i16".into(),
+        "int32_t" | "ilong" | "long" => "i32".into(),
+        "int64_t" => "i64".into(),
+        "bool" | "_Bool" => "bool".into(),
+        "float" | "double" => "u32".into(), // no float support yet
+        s if s.contains('*') => "u32".into(), // pointers → u32 on rv32
+        _ => "u32".into(),
+    }
+}
+
+pub fn generate_kov(decls: &[String]) -> String {
+    let mut out = String::from("// generated from C header\n\n");
+    for d in decls {
+        out.push_str(d);
+        out.push('\n');
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_simple_header() {
+        let header = r#"
+#include <stdint.h>
+
+void HAL_GPIO_WritePin(uint32_t port, uint32_t pin, uint32_t state);
+uint32_t HAL_GPIO_ReadPin(uint32_t port, uint32_t pin);
+void HAL_Delay(uint32_t ms);
+"#;
+        let decls = parse_header(header);
+        assert_eq!(decls.len(), 3);
+        assert!(decls[0].contains("HAL_GPIO_WritePin"));
+        assert!(decls[1].contains("HAL_GPIO_ReadPin"));
+        assert!(decls[1].contains("u32")); // return type
+        assert!(decls[2].contains("HAL_Delay"));
+    }
+
+    #[test]
+    fn c_types_converted() {
+        assert_eq!(c_type_to_kov("uint32_t"), "u32");
+        assert_eq!(c_type_to_kov("int"), "i32");
+        assert_eq!(c_type_to_kov("void"), "void");
+        assert_eq!(c_type_to_kov("uint8_t"), "u8");
+        assert_eq!(c_type_to_kov("char*"), "u32");
+    }
+}

src/codegen/mod.rs

@@ -1,6 +1,7 @@
 pub mod alloc;
 pub mod arm;
 pub mod builtins;
+pub mod cheader;
 pub mod compress;
 pub mod defmt;
 pub mod disasm;

src/main.rs

@@ -39,6 +39,7 @@ fn main() {
         eprintln!("  boards                        list supported boards");
         eprintln!("  svd <file.svd> [--name X]     generate board def from SVD");
         eprintln!("  check <file.kov>               type check only");
+        eprintln!("  repl                          interactive compile + run");
         eprintln!("  lsp                           start language server");
         eprintln!("  lex <file.kov>                 dump tokens");
         eprintln!();
@@ -240,6 +241,15 @@ fn main() {
                 funcs.len()
             );
         }
+        "import-c" => {
+            if args.len() < 3 {
+                eprintln!("usage: kov import-c <header.h>");
+                process::exit(1);
+            }
+            let content = read_file(&args[2]);
+            let decls = codegen::cheader::parse_header(&content);
+            println!("{}", codegen::cheader::generate_kov(&decls));
+        }
         "svd" => {
             if args.len() < 3 {
                 eprintln!("usage: kov svd <file.svd> [--name <board>]");
@@ -250,6 +260,7 @@ fn main() {
             let peripherals = codegen::svd::parse_svd(&xml);
             println!("{}", codegen::svd::generate_kov(&peripherals, &name));
         }
+        "repl" => cmd_repl(),
         "lsp" => lsp::run_lsp(),
         "check" => cmd_check(&args),
         _ => {
@@ -758,6 +769,115 @@ fn cmd_flash(args: &[String]) {
     let _ = std::fs::remove_file(&elf_path);
 }
 
+fn cmd_repl() {
+    use std::io::{self, BufRead, Write};
+
+    eprintln!("kov repl v0.1.0 — type expressions, see results");
+    eprintln!("  expressions are wrapped in fn main() {{ return <expr>; }}");
+    eprintln!("  type :q to quit, :asm to show assembly");
+    eprintln!();
+
+    let stdin = io::stdin();
+    let stdout = io::stdout();
+    let mut show_asm = false;
+
+    loop {
+        print!("kov> ");
+        let _ = stdout.lock().flush();
+
+        let mut line = String::new();
+        if stdin.lock().read_line(&mut line).is_err() || line.is_empty() {
+            break;
+        }
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        if line == ":q" || line == ":quit" {
+            break;
+        }
+        if line == ":asm" {
+            show_asm = !show_asm;
+            eprintln!("  asm mode: {}", if show_asm { "on" } else { "off" });
+            continue;
+        }
+
+        // wrap as a function that returns the expression
+        let source = if line.contains("fn ") || line.contains("let ") || line.contains("board ") {
+            line.to_string()
+        } else {
+            format!("fn __repl__() u32 {{ return {}; }}", line)
+        };
+
+        // compile
+        let tokens = match lexer::Lexer::tokenize(&source) {
+            Ok(t) => t,
+            Err(e) => {
+                eprintln!("  error: {e}");
+                continue;
+            }
+        };
+        let mut program = match parser::Parser::new(tokens).parse() {
+            Ok(p) => p,
+            Err(errors) => {
+                for e in &errors {
+                    eprintln!("  error: {}", e.message);
+                }
+                continue;
+            }
+        };
+        parser::monomorph::monomorphize(&mut program);
+
+        let mut ir_result = ir::lower::Lowering::lower(&program);
+        ir::opt::inline_functions(&mut ir_result.functions);
+        for func in &mut ir_result.functions {
+            ir::opt::optimize(func);
+        }
+
+        // try const eval first
+        if let Some(func) = ir_result.functions.iter().find(|f| f.name == "__repl__") {
+            if let Some(val) = ir::consteval::eval(func, &[]) {
+                eprintln!("  = {} (0x{:X})", val, val as u32);
+                if show_asm {
+                    let mut cg = codegen::CodeGen::new();
+                    cg.gen_function(func);
+                    if let Ok(code) = cg.finish() {
+                        let labels = cg.emitter.labels.clone();
+                        eprintln!("{}", codegen::disasm::disassemble(&code, 0, &labels));
+                    }
+                }
+                continue;
+            }
+        }
+
+        // fall back to emulator
+        let mut cg = codegen::CodeGen::new_with_globals(0x2000_0000, &ir_result.globals);
+        for func in &ir_result.functions {
+            cg.gen_function(func);
+        }
+        let labels = cg.emitter.labels.clone();
+        match cg.finish() {
+            Ok(code) => {
+                if show_asm {
+                    eprintln!(
+                        "{}",
+                        codegen::disasm::disassemble(&code, 0x0800_0000, &labels)
+                    );
+                }
+                let mut cpu = emu::Cpu::with_memory(0x0800_0000, 0x0800_0000, 0x2000_0000);
+                cpu.mem.load_flash(&code);
+                cpu.regs[2] = 0x2000_8000;
+                cpu.run(10_000);
+                eprintln!(
+                    "  = {} (0x{:X}) [{} cycles]",
+                    cpu.regs[10] as i32, cpu.regs[10], cpu.cycles
+                );
+            }
+            Err(e) => eprintln!("  codegen error: {e}"),
+        }
+    }
+}
+
 fn cmd_check(args: &[String]) {
     if args.len() < 3 {
         eprintln!("usage: kov check <file.kov>");