重构解析器和解释器以支持命名空间导入，增强了对库和代码命名空间的处理能力。更新了AST结构，添加了命名空间类型字段，并优化了相关函数的实现，提升了代码的可读性和可维护性。同时，修复了命名空间函数调用的解析逻辑，确保能够正确处理嵌套命名空间。

Author: HelloAIXIAOJI

examples/kaizaojiy.cn

@@ -0,0 +1,20 @@
+using lib <os>;
+using lib <io>;
+using lib <time>;
+using ns std;
+
+fn main() : int {
+    while (true) {
+        exec("powershell", "-Command", "Clear-Host");
+        println("  🎃");
+        println("██░░██");
+        println("  ░░");
+        sleep_seconds(0.2);
+        exec("powershell", "-Command", "Clear-Host");
+        println("  🎃");
+        println("░░██░░");
+        println("  ██");
+        sleep_seconds(0.2);
+    };
+    return 0;
+};

library_io/src/lib.rs

@@ -145,13 +145,13 @@ pub extern "C" fn cn_init() -> *mut HashMap<String, LibraryFunction> {
          .add_function("println", std::cn_println)
          .add_function("read_line", std::cn_read_line)
          .add_function("printf", std::cn_printf);
-    
+    /*
     // 同时注册为直接函数，不需要命名空间前缀
     registry.add_direct_function("print", std::cn_print)
             .add_direct_function("println", std::cn_println)
             .add_direct_function("read_line", std::cn_read_line)
             .add_direct_function("printf", std::cn_printf);
-    
+    */
     // 构建并返回库指针
     registry.build_library_pointer()
 } 

namespace_mixed_test.cn

@@ -0,0 +1,50 @@
+// 测试混合使用库命名空间和代码命名空间
+
+// 导入多个库
+using lib <io>;
+using lib <time>;
+using ns std;
+
+// 创建自定义命名空间，其函数可能与库函数同名
+ns my_std {
+    fn println(message : string) : void {
+        // 调用真正的io库函数，但添加时间戳
+        current_time : string = time::std::format_now("[%H:%M:%S] ");
+        io::std::println(current_time + message);
+    };
+    
+    fn get_timestamp() : string {
+        return time::std::now();
+    };
+};
+
+// 创建另一个命名空间
+ns app {
+    fn version() : string {
+        return "应用版本 2.0.0";
+    };
+};
+
+fn main() : int {
+    // 直接使用库命名空间函数
+    println("测试混合使用库命名空间和代码命名空间");
+    
+    // 导入自定义命名空间
+    using ns my_std;
+    
+    // 现在使用自定义命名空间的函数，它会调用真正的库函数
+    my_std::println("这条消息将带有时间戳");
+    
+    // 获取并显示时间戳
+    timestamp : string = my_std::get_timestamp();
+    println("当前时间戳: " + timestamp);
+    
+    // 导入并使用另一个命名空间
+    using ns app;
+    println(version());
+    
+    // 直接使用完整路径，避免命名空间冲突
+    io::std::println("这条消息直接使用io库，没有时间戳");
+    
+    return 0;
+}; 

namespace_nested_test.cn

@@ -0,0 +1,56 @@
+// 测试嵌套命名空间
+
+// 导入库命名空间
+using lib <io>;
+using ns std;
+
+// 创建父命名空间
+ns parent {
+    // 创建子命名空间
+    ns child {
+        fn hello() : string {
+            return "来自嵌套命名空间的问候！";
+        };
+        
+        fn add(a : int, b : int) : int {
+            return a + b;
+        };
+    };
+    
+    // 父命名空间中的函数
+    fn say_hello() : string {
+        return "来自父命名空间的问候！";
+    };
+};
+
+// 定义另一个命名空间，与父命名空间同级
+ns utils {
+    fn get_version() : string {
+        return "1.0.0";
+    };
+};
+
+fn main() : int {
+    // 使用库命名空间
+    println("测试嵌套命名空间");
+    
+    // 导入并使用嵌套命名空间
+    using ns parent::child;
+    greeting : string = hello();
+    println(greeting);
+    
+    // 导入父命名空间
+    using ns parent;
+    parent_greeting : string = say_hello();
+    println(parent_greeting);
+    
+    // 使用完整路径访问嵌套命名空间函数
+    sum : int = parent::child::add(30, 40);
+    println("30 + 40 = " + sum);
+    
+    // 导入并使用另一个命名空间
+    using ns utils;
+    println("版本: " + get_version());
+    
+    return 0;
+}; 

namespace_simple_test.cn

@@ -0,0 +1,10 @@
+// 测试简单的库函数调用
+
+// 导入IO库
+using lib <io>;
+
+fn main() : int {
+    // 直接使用库函数
+    io::std::println("测试简单的库函数调用");
+    return 0;
+}; 

namespace_unified_test.cn

@@ -0,0 +1,59 @@
+// 测试统一的命名空间机制
+
+// 导入库命名空间
+using lib <io>;
+
+// 创建并使用代码命名空间
+ns math {
+    fn add(a : int, b : int) : int {
+        return a + b;
+    };
+    
+    fn multiply(a : int, b : int) : int {
+        return a * b;
+    };
+};
+
+// 创建另一个命名空间
+ns string_utils {
+    fn concat(a : string, b : string) : string {
+        return a + b;
+    };
+    
+    fn repeat(text : string, count : int) : string {
+        result : string = "";
+        for (i : 0..count-1) {
+            result = result + text;
+        };
+        return result;
+    };
+};
+
+fn main() : int {
+    // 使用库命名空间函数
+    io::std::println("测试统一的命名空间机制");
+    
+    // 从代码命名空间导入函数
+    using ns math;
+    using ns string_utils;
+    
+    // 直接使用已导入的命名空间函数
+    sum : int = add(10, 20);
+    io::std::println("10 + 20 = " + sum);
+    
+    product : int = multiply(5, 6);
+    io::std::println("5 * 6 = " + product);
+    
+    // 使用string_utils命名空间函数
+    message : string = concat("Hello, ", "World!");
+    io::std::println(message);
+    
+    repeated : string = repeat("-=", 10);
+    io::std::println(repeated);
+    
+    // 使用完整的命名空间路径
+    full_sum : int = math::add(100, 200);
+    io::std::println("使用完整路径: 100 + 200 = " + full_sum);
+    
+    return 0;
+}; 

src/ast.rs

@@ -35,6 +35,13 @@ pub enum Expression {
     // 未来可以扩展更多表达式类型
 }
 
+// 命名空间类型
+#[derive(Debug, Clone, PartialEq)]
+pub enum NamespaceType {
+    Code,    // 代码命名空间 (ns xxx)
+    Library, // 库命名空间 (lib xxx)
+}
+
 #[derive(Debug, Clone)]
 pub enum BinaryOperator {
     Add,
@@ -71,8 +78,7 @@ pub enum Statement {
     PreIncrement(String), // 前置自增语句 (++var)
     PreDecrement(String), // 前置自减语句 (--var)
     CompoundAssignment(String, BinaryOperator, Expression), // 复合赋值 (+=, -=, *=, /=, %=)
-    UsingNamespace(Vec<String>), // 导入命名空间 (using ns xxx;)
-    LibraryImport(String), // 导入动态库 (using lib_once <xxx>;)
+    ImportNamespace(NamespaceType, Vec<String>), // 统一的命名空间导入，第一个参数表示类型，第二个参数是路径
     FileImport(String),    // 导入文件 (using file "xxx.cn";)
     FunctionCallStatement(Expression), // 函数调用语句
     NamespacedFunctionCallStatement(Vec<String>, Vec<Expression>), // 命名空间函数调用语句 (ns::func())
@@ -102,6 +108,7 @@ pub struct Function {
 #[derive(Debug, Clone)]
 pub struct Namespace {
     pub name: String,
+    pub ns_type: NamespaceType, // 添加命名空间类型字段
     pub functions: Vec<Function>,
     pub namespaces: Vec<Namespace>, // 嵌套命名空间
 }
@@ -110,6 +117,6 @@ pub struct Namespace {
 pub struct Program {
     pub functions: Vec<Function>,
     pub namespaces: Vec<Namespace>, // 顶层命名空间
-    pub library_imports: Vec<String>, // 顶层库导入
+    pub imported_namespaces: Vec<(NamespaceType, Vec<String>)>, // 统一的导入记录
     pub file_imports: Vec<String>,   // 顶层文件导入
 } 

src/interpreter/library_loader.rs

@@ -5,6 +5,7 @@ use std::env;
 use libloading::{Library, Symbol};
 use once_cell::sync::Lazy;
 use crate::interpreter::debug_println;
+use crate::interpreter::value::Value;
 
 // 已加载库的缓存，使用Lazy静态变量确保线程安全的初始化
 static LOADED_LIBRARIES: Lazy<Arc<Mutex<HashMap<String, Arc<Library>>>>> = 
@@ -46,6 +47,18 @@ fn get_library_path(lib_name: &str) -> PathBuf {
     path
 }
 
+// 添加一个函数来打印库中的所有函数
+pub fn debug_library_functions(lib_name: &str) -> Result<(), String> {
+    let functions = load_library(lib_name)?;
+    
+    debug_println(&format!("库 '{}' 中的所有函数:", lib_name));
+    for (func_name, _) in functions.iter() {
+        debug_println(&format!("  - {}", func_name));
+    }
+    
+    Ok(())
+}
+
 // 加载库并返回其函数映射
 pub fn load_library(lib_name: &str) -> Result<Arc<HashMap<String, LibraryFunction>>, String> {
     debug_println(&format!("开始加载库: {}", lib_name));
@@ -206,4 +219,33 @@ pub fn call_library_function(lib_name: &str, func_name: &str, args: Vec<String>)
         },
         None => Err(format!("库 '{}' 中未找到函数 '{}'", lib_name, func_name)),
     }
+} 
+
+// 新增函数，将Value类型转换为字符串参数
+pub fn convert_value_to_string_arg(value: &Value) -> String {
+    match value {
+        Value::Int(i) => i.to_string(),
+        Value::Float(f) => f.to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::String(s) => s.clone(),
+        Value::Long(l) => l.to_string(),
+        Value::Array(arr) => {
+            let elements: Vec<String> = arr.iter()
+                .map(|v| convert_value_to_string_arg(v))
+                .collect();
+            format!("[{}]", elements.join(", "))
+        },
+        Value::Map(map) => {
+            let entries: Vec<String> = map.iter()
+                .map(|(k, v)| format!("{}:{}", k, convert_value_to_string_arg(v)))
+                .collect();
+            format!("{{{}}}", entries.join(", "))
+        },
+        Value::None => "null".to_string(),
+    }
+}
+
+// 从Vector<Value>转换为Vector<String>，用于库函数调用
+pub fn convert_values_to_string_args(values: &[Value]) -> Vec<String> {
+    values.iter().map(|v| convert_value_to_string_arg(v)).collect()
 }