pipeline_script/core/

builtin.rs

use std::collections::HashMap;
use std::ffi::{c_char, 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
}
pub 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);
                    print!("{}", s.to_str().unwrap());
                }
                t => todo!("{t}"),
            }
            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")
                }
                3 => {
                    let value = (*obj).ptr as i32;
                    print!("{}", value);
                }
                4 => {
                    let v = (*obj).ptr as i64;
                    print!("{}", v);
                }
                7 => {
                    let s = CStr::from_ptr((*obj).ptr as *const c_char);
                    print!("{}", s.to_str().unwrap());
                }
                t => todo!("{t}"),
            }
        }
    }
}
pub 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!("{}", if b == 1 { true } else { false }));
                }
                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);
                    s.push_str(s0.to_str().unwrap());
                }
                t => todo!("{t}"),
            }
        }
    }
    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 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);

    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 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 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 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 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();

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

    // 将线程句柄存储到全局变量中
    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 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() };
    return 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
        }
    }
}