pipeline_script/core/

builtin.rs

use std::collections::HashMap;
use std::ffi::{c_char, c_void, CStr, CString};
use std::io;
use std::process::{Command, Stdio};
use std::sync::Mutex;
use std::thread::{self, JoinHandle};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use lazy_static::lazy_static;

#[repr(C)]
#[derive(Clone, Copy)]
pub struct Array {
    len: i64,
    ptr: *mut Any,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Any {
    id: i32,
    ptr: *mut i8,
}
#[allow(unused)]
pub extern "C" fn len(target: Array) -> i64 {
    target.len
}

/// 创建一个新的HashMap<String,String>并返回其指针
///
/// # 返回值
/// 返回指向新创建的HashMap的指针，需要调用方负责内存管理
///
/// # 说明
/// 该函数会在堆上分配一个新的HashMap<String,String>
/// 调用方需要使用相应的释放函数来避免内存泄漏
pub extern "C" fn hashmap() -> *mut c_void {
    let map = Box::new(HashMap::<String, String>::new());
    Box::into_raw(map) as *mut c_void
}

/// 向HashMap中插入键值对
///
/// # 参数
/// * `map_ptr` - HashMap的指针
/// * `key` - 键的C字符串指针
/// * `value` - 值的C字符串指针
///
/// # 说明
/// 如果键已存在，会更新对应的值
pub(crate) extern "C" fn hashmap_insert(
    map_ptr: *mut c_void,
    key: *const c_char,
    value: *const c_char,
) {
    if map_ptr.is_null() || key.is_null() || value.is_null() {
        return;
    }

    let map = unsafe { &mut *(map_ptr as *mut HashMap<String, String>) };
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap_or("").to_string() };
    let value_str = unsafe { CStr::from_ptr(value).to_str().unwrap_or("").to_string() };

    map.insert(key_str, value_str);
}

/// 从HashMap中获取指定键的值
///
/// # 参数
/// * `map_ptr` - HashMap的指针
/// * `key` - 键的C字符串指针
///
/// # 返回值
/// 返回对应值的C字符串指针，如果键不存在返回null指针
///
/// # 说明
/// 返回的字符串需要调用方释放内存
pub(crate) extern "C" fn hashmap_get(map_ptr: *mut c_void, key: *const c_char) -> *mut c_char {
    if map_ptr.is_null() || key.is_null() {
        return std::ptr::null_mut();
    }

    let map = unsafe { &*(map_ptr as *const HashMap<String, String>) };
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap_or("") };

    match map.get(key_str) {
        Some(value) => match CString::new(value.clone()) {
            Ok(c_string) => c_string.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// 从HashMap中移除指定键的键值对
///
/// # 参数
/// * `map_ptr` - HashMap的指针
/// * `key` - 要移除的键的C字符串指针
///
/// # 返回值
/// 如果键存在并被移除返回true，否则返回false
pub(crate) extern "C" fn hashmap_remove(map_ptr: *mut c_void, key: *const c_char) -> bool {
    if map_ptr.is_null() || key.is_null() {
        return false;
    }

    let map = unsafe { &mut *(map_ptr as *mut HashMap<String, String>) };
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap_or("") };

    map.remove(key_str).is_some()
}

/// 检查HashMap中是否包含指定的键
///
/// # 参数
/// * `map_ptr` - HashMap的指针
/// * `key` - 要检查的键的C字符串指针
///
/// # 返回值
/// 如果键存在返回true，否则返回false
pub(crate) extern "C" fn hashmap_contains_key(map_ptr: *mut c_void, key: *const c_char) -> bool {
    if map_ptr.is_null() || key.is_null() {
        return false;
    }

    let map = unsafe { &*(map_ptr as *const HashMap<String, String>) };
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap_or("") };

    map.contains_key(key_str)
}

/// 获取HashMap中键值对的数量
///
/// # 参数
/// * `map_ptr` - HashMap的指针
///
/// # 返回值
/// 返回HashMap中键值对的数量，如果指针无效返回0
pub extern "C" fn hashmap_len(map_ptr: *mut c_void) -> i64 {
    if map_ptr.is_null() {
        return 0;
    }

    let map = unsafe { &*(map_ptr as *const HashMap<String, String>) };
    map.len() as i64
}

/// 清空HashMap中的所有键值对
///
/// # 参数
/// * `map_ptr` - HashMap的指针
pub extern "C" fn hashmap_clear(map_ptr: *mut c_void) {
    if map_ptr.is_null() {
        return;
    }

    let map = unsafe { &mut *(map_ptr as *mut HashMap<String, String>) };
    map.clear();
}

/// 释放HashMap的内存
///
/// # 参数
/// * `map_ptr` - 要释放的HashMap指针
///
/// # 说明
/// 调用此函数后，指针将变为无效，不应再使用
pub extern "C" fn hashmap_free(map_ptr: *mut c_void) {
    if map_ptr.is_null() {
        return;
    }

    unsafe {
        let _map = Box::from_raw(map_ptr as *mut HashMap<String, String>);
        // Box会在这里自动释放内存
    }
}
pub(crate) extern "C" fn println(l: i64, ptr: *mut Any) {
    for i in 0..l {
        let obj = unsafe { (ptr).offset(i as isize) };
        unsafe {
            match (*obj).id {
                0 => {
                    print!("Unit")
                }
                1 => {
                    let b = (*obj).ptr as *mut bool;
                    print!("{}", *b);
                }
                3 => {
                    let value = (*obj).ptr as i8;
                    print!("{}", value);
                }
                5 => {
                    let value = (*obj).ptr as i16;
                    print!("{}", value);
                }
                7 => {
                    let v = (*obj).ptr as i32;
                    print!("{}", v);
                }
                9 => {
                    let v = (*obj).ptr as i64;
                    print!("{}", v);
                }
                11 => {
                    let v = (*obj).ptr as *mut f32;
                    print!("{}", *v);
                }
                13 => {
                    let v = (*obj).ptr as *mut f64;
                    print!("{}", *v);
                }
                15 => {
                    let s = CStr::from_ptr((*obj).ptr as *const c_char);
                    match s.to_str() {
                        Ok(s) => print!("{}", s),
                        Err(_) => print!("InvalidUTF8String"),
                    }
                }
                17 => {
                    print!("Any")
                }
                _ => {
                    // 对于未知类型，输出类型ID和地址以便调试
                    print!("Unknown(id:{}, ptr:{:p})", (*obj).id, (*obj).ptr);
                }
            }
            if i < l - 1 {
                print!("\t")
            }
        }
    }
    println!()
}
#[allow(unused)]
pub extern "C" fn print(obj: Array) {
    for i in 0..obj.len {
        let obj = unsafe { (obj.ptr).offset(i as isize) };
        unsafe {
            match (*obj).id {
                0 => {
                    print!("Unit")
                }
                1 => {
                    let b = (*obj).ptr as *mut bool;
                    print!("{}", *b);
                }
                3 => {
                    let value = (*obj).ptr as i8;
                    print!("{}", value);
                }
                5 => {
                    let value = (*obj).ptr as i16;
                    print!("{}", value);
                }
                7 => {
                    let v = (*obj).ptr as i32;
                    print!("{}", v);
                }
                9 => {
                    let v = (*obj).ptr as i64;
                    print!("{}", v);
                }
                11 => {
                    let v = (*obj).ptr as *mut f32;
                    print!("{}", *v);
                }
                13 => {
                    let v = (*obj).ptr as *mut f64;
                    print!("{}", *v);
                }
                15 => {
                    let s = CStr::from_ptr((*obj).ptr as *const c_char);
                    match s.to_str() {
                        Ok(s) => print!("{}", s),
                        Err(_) => print!("InvalidUTF8String"),
                    }
                }
                17 => {
                    print!("Any")
                }
                _ => {
                    print!("Unknown(id:{})", (*obj).id);
                }
            }
        }
    }
}
pub(crate) extern "C" fn append(l: i64, ptr: *mut Any) -> *mut c_char {
    let mut s = String::new();
    for i in 0..l {
        let obj = unsafe { (ptr).offset(i as isize) };
        unsafe {
            match (*obj).id {
                0 => {
                    s.push_str("Unit");
                }
                1 => {
                    let b = (*obj).ptr as i8;
                    s.push_str(&format!("{}", b == 1));
                }
                3 => {
                    let value = (*obj).ptr as i8;
                    s.push_str(&format!("{}", value));
                }
                5 => {
                    let value = (*obj).ptr as i16;
                    s.push_str(&format!("{}", value));
                }
                7 => {
                    let value = (*obj).ptr as i32;
                    s.push_str(&format!("{}", value));
                }
                9 => {
                    let v = (*obj).ptr as i64;
                    s.push_str(&format!("{}", v));
                }
                11 => {
                    let v = (*obj).ptr as *const f32;
                    s.push_str(&format!("{}", *v));
                }
                13 => {
                    let v = (*obj).ptr as *mut f64;
                    s.push_str(&format!("{}", *v));
                }
                15 => {
                    let s0 = CStr::from_ptr((*obj).ptr as *const c_char);
                    match s0.to_str() {
                        Ok(str_val) => s.push_str(str_val),
                        Err(_) => s.push_str("InvalidUTF8String"),
                    }
                }
                17 => {
                    s.push_str("Any");
                }
                _ => {
                    s.push_str(&format!("Unknown(id:{})", (*obj).id));
                }
            }
        }
    }
    s.push('\0');
    let s = s.leak();
    s.as_ptr() as *mut c_char
}
lazy_static! {
    /// 多环境工作目录映射表，用于管理不同执行环境的工作目录
    /// key: 环境标识符，value: 对应的工作目录路径
    /// 支持并发场景下多个线程使用不同的工作目录
    static ref WORKSPACES: Mutex<HashMap<String, String>> = Mutex::new(HashMap::new());

    /// 全局线程句柄存储，用于管理所有通过spawn创建的线程
    /// 可以通过wait函数等待所有线程完成
    static ref THREAD_HANDLES: Mutex<Vec<JoinHandle<()>>> = Mutex::new(Vec::new());
}
/// 在指定环境的工作目录中执行PowerShell命令
///
/// # 参数
/// * `key` - 环境标识符，用于区分不同的执行环境
/// * `command` - 要执行的命令字符串
///
/// # 说明
/// 该函数会在指定环境key对应的工作目录中执行命令
/// 如果环境key不存在，则使用当前目录"./"作为默认工作目录
/// 命令输出会直接继承到父进程的标准输出和标准错误流
/// 支持并发场景下不同线程使用不同的工作目录
pub(crate) extern "C" fn cmd(key: *mut c_char, command: *mut c_char) {
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap() };
    let cmd = unsafe { CStr::from_ptr(command).to_str().unwrap() };

    let workspaces = WORKSPACES.lock().unwrap();
    let binding = "./".to_string();
    let workspace = workspaces.get(key_str).unwrap_or(&binding);
    #[allow(clippy::zombie_processes)]
    Command::new("powershell")
        .current_dir(workspace)
        .arg("/C")
        .arg(cmd)
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit())
        .spawn()
        .expect("Failed to execute command");
}
/// 为指定环境设置工作目录
///
/// # 参数
/// * `key` - 环境标识符，用于区分不同的执行环境
/// * `dir` - 新的工作目录路径
///
/// # 说明
/// 该函数会为指定的环境key设置工作目录，不会影响其他环境的工作目录
/// 支持并发场景下不同线程使用独立的工作目录
/// 如果传入的目录路径无效，函数会panic
pub(crate) extern "C" fn workspace(key: *mut c_char, dir: *mut c_char) {
    let key_str = unsafe { CStr::from_ptr(key).to_str().unwrap() };
    let dir_str = unsafe { CStr::from_ptr(dir).to_str().unwrap() };

    // 验证目录是否存在
    if !std::path::Path::new(dir_str).exists() {
        panic!("Directory does not exist: {}", dir_str);
    }

    // 为指定环境设置工作目录
    let mut workspaces = WORKSPACES.lock().unwrap();
    workspaces.insert(key_str.to_string(), dir_str.to_string());
}
#[allow(unused)]
pub extern "C" fn exit() {
    std::process::exit(0);
}
#[allow(unused)]
pub(crate) extern "C" fn get_env(key: *mut c_char) -> *mut c_char {
    let key = unsafe { CStr::from_ptr(key).to_str().unwrap() };
    let mut value = std::env::var(key).unwrap();
    value.push('\0');
    let value = value.leak();
    value.as_ptr() as *mut c_char
}
#[allow(unused)]
pub(crate) extern "C" fn set_env(key: *mut c_char, value: *mut c_char) {
    let key = unsafe { CStr::from_ptr(key).to_str().unwrap() };
    let value = unsafe { CStr::from_ptr(value).to_str().unwrap() };
    std::env::set_var(key, value);
}

#[allow(unused)]
pub(crate) extern "C" fn panic(ptr: *mut c_char) {
    let s = unsafe { CStr::from_ptr(ptr).to_str().unwrap() };
    eprintln!("\x1b[31mpanic: {}\x1b[0m", s);
    std::process::exit(1);
}

#[no_mangle]
pub extern "C" fn now() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default() // 错误时返回0（例如系统时间早于Unix纪元）
        .as_millis() as u64 // 转换为u64（C兼容）
}

// 定义一个类型安全的函数指针类型，用于C FFI
pub type ExternFn = extern "C" fn(*const u8);

/// 创建新线程并执行指定函数
///
/// # 参数
/// * `func` - 要在新线程中执行的函数指针
///
/// # 说明
/// 该函数会创建一个新线程来异步执行指定的函数，
/// 线程句柄会被存储在全局变量中，可通过wait函数等待所有线程完成
pub extern "C" fn spawn0(func: ExternFn, _env: *const c_char, name: *const c_char) {
    let name = unsafe { CStr::from_ptr(name).to_str().unwrap() };
    // 在新线程中异步执行函数
    let handle = thread::spawn(move || {
        func(name.as_ptr());
    });

    // 将线程句柄存储到全局变量中
    let mut handles = THREAD_HANDLES.lock().unwrap();
    handles.push(handle);
}

/// 等待所有通过spawn创建的线程完成
///
/// # 说明
/// 该函数会阻塞当前线程，直到所有通过spawn函数创建的线程都执行完成
/// 调用后会清空线程句柄列表
pub extern "C" fn wait() {
    let mut handles = THREAD_HANDLES.lock().unwrap();

    // 等待所有线程完成
    while let Some(handle) = handles.pop() {
        if let Err(e) = handle.join() {
            eprintln!("线程执行失败: {:?}", e);
        }
    }
}

pub extern "C" fn sleep(ms: u64) {
    thread::sleep(Duration::from_millis(ms));
}

pub(crate) extern "C" fn string_equal(l: *const c_char, r: *const c_char) -> bool {
    let l = unsafe { CStr::from_ptr(l).to_str().unwrap() };
    let r = unsafe { CStr::from_ptr(r).to_str().unwrap() };
    l.eq(r)
}

/// 从控制台读取一行输入（包括换行符）
///
/// # 返回值
/// 返回读取到的字符串指针，包含换行符
///
/// # 说明
/// 该函数会阻塞等待用户输入，直到用户按下回车键
/// 返回的字符串包含换行符，需要调用方自行处理
pub extern "C" fn read_line() -> *mut c_char {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(_) => {
            // 转换为C字符串并返回指针
            match CString::new(input) {
                Ok(c_string) => c_string.into_raw(),
                Err(_) => {
                    // 如果转换失败，返回空字符串
                    CString::new("").unwrap().into_raw()
                }
            }
        }
        Err(_) => {
            // 读取失败时返回空字符串
            CString::new("").unwrap().into_raw()
        }
    }
}

/// 从控制台读取字符串输入（去除换行符）
///
/// # 返回值
/// 返回读取到的字符串指针，已去除末尾换行符
///
/// # 说明
/// 该函数会阻塞等待用户输入，直到用户按下回车键
/// 返回的字符串已自动去除末尾的换行符
pub extern "C" fn read_string() -> *mut c_char {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(_) => {
            // 去除末尾的换行符
            let trimmed = input.trim_end().to_string();
            match CString::new(trimmed) {
                Ok(c_string) => c_string.into_raw(),
                Err(_) => {
                    // 如果转换失败，返回空字符串
                    CString::new("").unwrap().into_raw()
                }
            }
        }
        Err(_) => {
            // 读取失败时返回空字符串
            CString::new("").unwrap().into_raw()
        }
    }
}

/// 从控制台读取64位整数输入
///
/// # 返回值
/// 返回读取到的64位整数，如果解析失败返回0
///
/// # 说明
/// 该函数会阻塞等待用户输入，直到用户按下回车键
/// 会尝试将输入解析为64位整数，如果解析失败返回0
pub extern "C" fn read_int64() -> i64 {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(_) => {
            // 去除换行符并尝试解析为i64
            match input.trim().parse::<i64>() {
                Ok(num) => num,
                Err(_) => {
                    eprintln!("警告: 输入的不是有效的整数，返回默认值 0");
                    0
                }
            }
        }
        Err(_) => {
            eprintln!("错误: 读取输入失败，返回默认值 0");
            0
        }
    }
}

/// 从控制台读取双精度浮点数输入
///
/// # 返回值
/// 返回读取到的双精度浮点数，如果解析失败返回0.0
///
/// # 说明
/// 该函数会阻塞等待用户输入，直到用户按下回车键
/// 会尝试将输入解析为双精度浮点数，如果解析失败返回0.0
pub extern "C" fn read_double() -> f64 {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(_) => {
            // 去除换行符并尝试解析为f64
            match input.trim().parse::<f64>() {
                Ok(num) => num,
                Err(_) => {
                    eprintln!("警告: 输入的不是有效的浮点数，返回默认值 0.0");
                    0.0
                }
            }
        }
        Err(_) => {
            eprintln!("错误: 读取输入失败，返回默认值 0.0");
            0.0
        }
    }
}
/// 从控制台读取单精度浮点数输入
///
/// # 返回值
/// 返回读取到的单精度浮点数，如果解析失败返回0.0
///
/// # 说明
/// 该函数会阻塞等待用户输入，直到用户按下回车键
/// 会尝试将输入解析为双精度浮点数，如果解析失败返回0.0
pub extern "C" fn read_float() -> f32 {
    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(_) => {
            // 去除换行符并尝试解析为f64
            match input.trim().parse::<f32>() {
                Ok(num) => num,
                Err(_) => {
                    eprintln!("警告: 输入的不是有效的浮点数，返回默认值 0.0");
                    0.0
                }
            }
        }
        Err(_) => {
            eprintln!("错误: 读取输入失败，返回默认值 0.0");
            0.0
        }
    }
}