From 3940a2dd82f380d33bd9444d32dbb9dae9e313c8 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Tue, 29 Jul 2025 21:11:58 +0800
Subject: [PATCH 01/11] =?UTF-8?q?=E5=AE=9E=E7=8E=B0Linux=E5=B9=B3=E5=8F=B0?=
 =?UTF-8?q?=E4=B8=8B=E5=8A=A8=E6=80=81=E5=BA=93=E5=8A=A0=E8=BD=BD=E7=BC=96?=
 =?UTF-8?q?=E8=AF=91=EF=BC=8C=E4=BD=86=E6=98=AF=E7=9B=AE=E5=89=8D=E4=BB=8D?=
 =?UTF-8?q?=E6=9C=89=E8=B7=AF=E5=BE=84=E6=90=9C=E7=B4=A2=E7=9A=84=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt              |   5 +-
 interpreter/interpreter.cpp | 130 +++++++-----------------------------
 interpreter/module.cpp      |  90 +++++++++++++++++++++++++
 interpreter/module.hpp      |  26 ++++++++
 interpreter/value.hpp       |  12 ++--
 5 files changed, 151 insertions(+), 112 deletions(-)
 create mode 100644 interpreter/module.cpp
 create mode 100644 interpreter/module.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index db01964e..7799ba5f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -50,12 +50,15 @@ add_executable(Lamina
         interpreter/trackback.hpp
         interpreter/value.hpp
         interpreter/lamina.hpp
+        interpreter/module.cpp
+        interpreter/module.hpp
         extensions/standard/math.cpp
         extensions/standard/stdio.cpp
         extensions/standard/random.cpp
         extensions/standard/random.hpp
         extensions/standard/times.cpp
-        extensions/standard/times.hpp)
+        extensions/standard/times.hpp
+)
 
 target_include_directories(lamina_core PUBLIC
         ${CMAKE_CURRENT_SOURCE_DIR}/interpreter
diff --git a/interpreter/interpreter.cpp b/interpreter/interpreter.cpp
index 8fc8d89f..c487d17c 100644
--- a/interpreter/interpreter.cpp
+++ b/interpreter/interpreter.cpp
@@ -1,5 +1,6 @@
 #include "interpreter.hpp"
 #include "lexer.hpp"
+#include "module.hpp"
 #include "lamina.hpp"
 #include "parser.hpp"
 #include "bigint.hpp"
@@ -16,9 +17,7 @@
 #include <windows.h>
 #include <io.h>
 #include <direct.h>
-#ifndef PATH_MAX
-#define PATH_MAX MAX_PATH
-#endif
+
 #else
 #include <limits.h>
 #include <unistd.h>
@@ -27,6 +26,7 @@
 #include <unistd.h> // For isatty
 #include <cstdlib>  // For getenv
 #include <dlfcn.h>
+#include <link.h>
 #endif
 
 
@@ -757,17 +757,31 @@ bool Interpreter::load_module(const std::string& module_name) {
             full_path = path + filename;
           //  std::cout << "Current Full Path: " << full_path << std::endl;
             file.open(full_path);
+
             if (file) {
+                file.close();
+#ifdef __linux__
+                ModuleLoader loader(full_path);
+                if (loader.isLoaded()) {
+                    std::vector<ModuleLoader::EntryFunction> entryFunctions = loader.findEntryFunctions();
+                    for (auto& entryFunc : entryFunctions) {
+                        entryFunc(*this);
+                    }
+                    loaded_modules.insert(module_name);
+                    return true;
+                } else {
+                    std::cerr << "Failed to load shared library: " << full_path << std::endl;
+                }
+#endif
                 break;
-            } else {
-                std::cerr << "Error: Cannot load module '" << module_name << "'" << std::endl;
+            }
+            if (!file) {
+                std::cerr << "Error: Cannot load module '" << module_name << "'\n";
                 std::cerr << "  Searched in: ";
-                for (size_t i = 0; i < search_paths.size(); ++i) {
-                    std::cerr << search_paths[i] + filename;
-                    if (i < search_paths.size() - 1) std::cerr << ", ";
+                for (const auto& path : search_paths) {
+                    std::cerr << path + filename << " ";
                 }
-
-                std::cerr << std::endl;
+                std::cerr << "\n";
                 return false;
             }
         }
@@ -779,102 +793,6 @@ bool Interpreter::load_module(const std::string& module_name) {
     std::string source = buffer.str();
     file.close();
 
-    // Record module as loaded
-    if (is_shared_lib && file) {
-        char abs_path[PATH_MAX];
-#ifdef _WIN32
-        if (_fullpath(abs_path, full_path.c_str(), PATH_MAX) == nullptr) {
-            std::cerr << "Error resolving path: " << full_path << std::endl;
-            return false;
-        }
-#else
-        if (realpath(full_path.c_str(), abs_path) == nullptr) {
-            std::cerr << "Error resolving path: " << full_path << std::endl;
-            return false;
-        }
-#endif
-        const char* func_symbol;
-#ifdef _WIN32
-    HMODULE handle = LoadLibraryA(full_path.c_str());
-    if (!handle) {
-        DWORD err_code = GetLastError();
-        char err_msg[256] = {0};
-        FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err_code,
-                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                      err_msg, sizeof(err_msg)-1, NULL);
-        std::cerr << "Failed to load DLL (" << full_path << "): "
-                  << err_msg << " (Code: " << err_code << ")" << std::endl;
-        return false;
-    }
-    func_symbol = ""; // I Don't Know Windows Platform's symbol
-#else
-    void* handle = dlopen(full_path.c_str(), RTLD_LAZY | RTLD_LOCAL);
-    if (!handle) {
-        std::cerr << "Failed to load SO (" << full_path << "): " << dlerror() << std::endl;
-        return false;
-    }
-    func_symbol = "_ZN11Interpreter14register_entryEPFvRS_E";
-#endif
-
-#ifdef _WIN32
-#else
-    dlerror();
-#endif
-
-    using RegisterFunc = Interpreter::EntryFunction;
-    auto register_entry = reinterpret_cast<RegisterFunc>(
-#ifdef _WIN32
-        GetProcAddress(handle, func_symbol)
-#else
-        dlsym(handle, func_symbol)
-#endif
-    );
-
-    if (!register_entry) {
-#ifdef _WIN32
-        DWORD err_code = GetLastError();
-        std::cerr << "Failed to find function " << func_symbol << " in "
-                  << full_path << " (Code: " << err_code << ")" << std::endl;
-#else
-        std::cerr << "Failed to find function " << func_symbol << " in "
-                  << full_path << ": " << dlerror() << std::endl;
-#endif
-#ifdef _WIN32
-        FreeLibrary(handle);
-#else
-        dlclose(handle);
-#endif
-        return false;
-    }
-
-    try {
-        register_entry(*this);
-
-        for (const auto& entry_func : Interpreter::entry_functions) {
-            if (entry_func) {
-                try {
-                    entry_func(*this);
-                } catch (const std::exception& e) {
-                    std::cerr << "Failed to register an entry function: " << e.what() << std::endl;
-                }
-            } else {
-                std::cerr << "Skipped a null entry function" << std::endl;
-            }
-        }
-
-        loaded_modules.insert(module_name);
-        return true;
-    } catch (const std::exception& e) {
-        std::cerr << "Error when calling register_entry for "
-                  << module_name << ": " << e.what() << std::endl;
-#ifdef _WIN32
-            FreeLibrary(handle);
-#else
-            dlclose(handle);
-#endif
-            return false;
-        }
-    }
 
     // Lexical and syntax analysis
     auto tokens = Lexer::tokenize(source);
diff --git a/interpreter/module.cpp b/interpreter/module.cpp
new file mode 100644
index 00000000..b25ca591
--- /dev/null
+++ b/interpreter/module.cpp
@@ -0,0 +1,90 @@
+/*
+     @Dev Ange1PlsGreet
+*/
+#include "module.hpp"
+
+ModuleLoader::ModuleLoader(const std::string& soPath) {
+#ifdef  __linux__
+    m_handle = dlopen(soPath.c_str(), RTLD_LAZY);
+    if (!m_handle) {
+        std::cerr << "Failed to load library: " << dlerror() << std::endl;
+    }
+#endif
+}
+
+ModuleLoader::~ModuleLoader() {
+#ifdef  __linux__
+    if (m_handle) {
+        dlclose(m_handle);
+        m_handle = nullptr;
+    }
+#endif
+}
+
+void* ModuleLoader::findSymbol(const std::string& symbolName) {
+#ifdef __linux__
+    if (!m_handle) {
+        return nullptr;
+    }
+    dlerror();
+    void* symbol = dlsym(m_handle, symbolName.c_str());
+    const char* dlsym_error = dlerror();
+    if (dlsym_error) {
+        std::cerr << "Error looking up symbol '" << symbolName << "': " << dlsym_error << std::endl;
+        return nullptr;
+    }
+    return symbol;
+#endif
+}
+
+bool ModuleLoader::isLoaded() const {
+    return m_handle != nullptr;
+}
+
+std::vector<ModuleLoader::EntryFunction> ModuleLoader::findEntryFunctions() {
+#ifdef __linux__
+    std::vector<EntryFunction> entryFunctions;
+    if (!m_handle) {
+        return entryFunctions;
+    }
+
+    struct link_map* lmap;
+    dlinfo(m_handle, RTLD_DI_LINKMAP, &lmap);
+
+    const ElfW(Sym)* symtab = nullptr;
+    const char* strtab = nullptr;
+    size_t symtabsz = 0;
+
+    for (ElfW(Dyn)* d = lmap->l_ld; d->d_tag != DT_NULL; ++d) {
+        if (d->d_tag == DT_SYMTAB) {
+            symtab = reinterpret_cast<const ElfW(Sym)*>(d->d_un.d_ptr);
+        } else if (d->d_tag == DT_STRTAB) {
+            strtab = reinterpret_cast<const char*>(d->d_un.d_ptr);
+        } else if (d->d_tag == DT_SYMENT) {
+            symtabsz = d->d_un.d_val;
+        }
+    }
+
+    if (symtab && strtab && symtabsz > 0) {
+        size_t symcount = (reinterpret_cast<const char*>(strtab) - reinterpret_cast<const char*>(symtab)) / symtabsz;
+
+        for (size_t j = 0; j < symcount; ++j) {
+            const ElfW(Sym)* sym = &symtab[j];
+            if (sym->st_name && strtab + sym->st_name) {
+                std::string symbolName = strtab + sym->st_name;
+                if (symbolName.find("_entry") != std::string::npos) {
+                    void* symbolAddr = findSymbol(symbolName.c_str());
+                    if (symbolAddr) {
+                        auto entryFunc = reinterpret_cast<void (*)(Interpreter&)>(symbolAddr);
+                        entryFunctions.emplace_back([entryFunc](Interpreter& interpreter) {
+                            entryFunc(interpreter);
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    return entryFunctions;
+#endif
+}
\ No newline at end of file
diff --git a/interpreter/module.hpp b/interpreter/module.hpp
new file mode 100644
index 00000000..29046767
--- /dev/null
+++ b/interpreter/module.hpp
@@ -0,0 +1,26 @@
+/* 
+     专门用于动态库加载的模块类
+*/
+#pragma once
+#include <iostream>
+#ifdef  __linux__
+#include <dlfcn.h>
+#include <link.h>
+#endif
+#include <vector>
+#include <functional>
+#include "interpreter.hpp"
+
+class ModuleLoader {
+public:
+     using EntryFunction = std::function<void(Interpreter&)>;
+     ModuleLoader(const std::string& soPath);
+     ~ModuleLoader();
+     void* findSymbol(const std::string& symbolName);
+     bool isLoaded() const;
+     void* m_handle;
+     std::vector<EntryFunction> findEntryFunctions();
+};
+
+
+
diff --git a/interpreter/value.hpp b/interpreter/value.hpp
index e5295fa9..c27d393d 100644
--- a/interpreter/value.hpp
+++ b/interpreter/value.hpp
@@ -16,12 +16,14 @@ public:    enum class Type { Null, Bool, Int, Float, String, Array, Matrix, BigI
     virtual ~Value() = default;
 
     // Constructors
-    Value() : type(Type::Null), data(nullptr) {}
+    Value() : type(Type::Null), data(std::in_place_index<0>, nullptr) {}  // 0对应std::nullptr_t类型
 
-    Value(std::nullptr_t) : type(Type::Null), data(nullptr) {}
-    Value(bool b) : type(Type::Bool), data(b) {}
-    Value(int i) : type(Type::Int), data(i) {}
-    Value(double f) : type(Type::Float), data(f) {}    Value(const std::string& s) : type(Type::String), data(s) {}
+    // 其他构造函数需要同步修改初始化方式
+    Value(std::nullptr_t) : type(Type::Null), data(std::in_place_index<0>, nullptr) {}
+    Value(bool b) : type(Type::Bool), data(std::in_place_index<1>, b) {}
+    Value(int i) : type(Type::Int), data(std::in_place_index<2>, i) {}
+    Value(double f) : type(Type::Float), data(std::in_place_index<3>, f) {}
+    Value(const std::string& s) : type(Type::String), data(s) {}
     Value(const char* s) : type(Type::String), data(std::string(s)) {}
     Value(const ::BigInt& bi) : type(Type::BigInt), data(bi) {}
     Value(const ::Rational& r) : type(Type::Rational), data(r) {}

From 3812ba285ba4360b7737776c0de530e40f935e53 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Tue, 29 Jul 2025 23:13:44 +0800
Subject: [PATCH 02/11] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=BA=86=E6=A8=A1?=
 =?UTF-8?q?=E5=9D=97=E5=8A=A0=E8=BD=BD=E7=9A=84BUG?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 interpreter/interpreter.cpp | 37 +++++++++++++++++++++++--------------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/interpreter/interpreter.cpp b/interpreter/interpreter.cpp
index c487d17c..151340cd 100644
--- a/interpreter/interpreter.cpp
+++ b/interpreter/interpreter.cpp
@@ -749,13 +749,12 @@ bool Interpreter::load_module(const std::string& module_name) {
     }
 
     if (!file) {
-        std::string filename = "lib" + clean_name + ".so";
+        std::string lib_filename = "lib" + clean_name + ".so";
         is_shared_lib = true;
+        bool found = false;
 
-        // 重新搜索文件路径
         for (const auto& path : search_paths) {
-            full_path = path + filename;
-          //  std::cout << "Current Full Path: " << full_path << std::endl;
+            full_path = path + lib_filename;
             file.open(full_path);
 
             if (file) {
@@ -768,25 +767,35 @@ bool Interpreter::load_module(const std::string& module_name) {
                         entryFunc(*this);
                     }
                     loaded_modules.insert(module_name);
-                    return true;
+                    found = true;
+                    break;
                 } else {
                     std::cerr << "Failed to load shared library: " << full_path << std::endl;
+                    file.clear();
                 }
-#endif
+#else
+                // Windows TODO!
+                found = true;
                 break;
+#endif
+            } else {
+                file.clear();
             }
-            if (!file) {
-                std::cerr << "Error: Cannot load module '" << module_name << "'\n";
-                std::cerr << "  Searched in: ";
-                for (const auto& path : search_paths) {
-                    std::cerr << path + filename << " ";
-                }
-                std::cerr << "\n";
-                return false;
+        }
+
+            if (!found) {
+            std::cerr << "Error: Cannot load module '" << module_name << "'\n";
+            std::cerr << "  Searched in: ";
+            for (const auto& path : search_paths) {
+                std::cerr << path + lib_filename << " ";
             }
+            std::cerr << "\n";
+            return false;
         }
+        return true;
     }
 
+
     // Read file into string
     std::stringstream buffer;
     buffer << file.rdbuf();

From eaf598fa3e06e245d4ed64b7f6a0482a63337ddc Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Tue, 29 Jul 2025 23:14:12 +0800
Subject: [PATCH 03/11] =?UTF-8?q?=E5=AE=9E=E7=8E=B0=E4=BA=86LINUX=E5=B9=B3?=
 =?UTF-8?q?=E5=8F=B0=E4=B8=8B=E9=83=A8=E5=88=86sockets=E5=BA=93=E7=9A=84?=
 =?UTF-8?q?=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 extensions/standard/sockets.cpp | 72 +++++++++++++++++++++++++++++++++
 extensions/standard/sockets.hpp | 22 ++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 extensions/standard/sockets.cpp
 create mode 100644 extensions/standard/sockets.hpp

diff --git a/extensions/standard/sockets.cpp b/extensions/standard/sockets.cpp
new file mode 100644
index 00000000..d3bca6ef
--- /dev/null
+++ b/extensions/standard/sockets.cpp
@@ -0,0 +1,72 @@
+/* 
+     CopyRight Shizuku Technologies
+     2025.07.24 22:39
+     @Dev Ange1PlsGreet
+*/
+#include "sockets.hpp"
+
+SOCKETS_HPP int create_socket(uv_stream_t *server, int status) {
+#ifdef __linux__
+     if (status < 0) {
+          return -1;
+     }
+
+     uv_tcp_t *client = new uv_tcp_t;
+     uv_tcp_init(loop, client);
+     if (uv_accept(server, (uv_stream_t*) client) == 0) {
+          return 1;
+     } else {
+          uv_close((uv_handle_t*) client, [](uv_handle_t* handle) {
+           delete (uv_tcp_t*) handle;
+       });
+     }
+#endif
+}
+
+SOCKETS_HPP Value runnable(const std::vector<Value> &args) {
+     std::string address = args[0].to_string();
+     if (!args[1].is_numeric()) {
+          L_ERR("Second Arg Must Be Number!");
+     }
+     int port = args[1].as_number();
+     // protocol(IPV4/IPV6)
+     if (!args[2].is_numeric()) {
+          L_ERR("Third Arg Must Be Number!");
+     }
+     int protocol = args[2].as_number();
+     if (protocol != 4 && protocol != 6) {
+          L_ERR("Third Arg Must Be 4 Or 6!");
+     }
+     // TCP/UDP
+     if (!args[3].is_numeric()) {
+          L_ERR("Fourth Arg Must Be Number!");
+     }
+     int type = args[3].as_number();
+     if (type != 0 && type != 1) {
+          L_ERR("Fourth Arg Must Be 0 Or 1!");
+     }
+#ifdef __linux__
+     if (protocol == 4 && type == 0) {
+          loop = uv_default_loop();
+          uv_tcp_init(loop, &server);
+
+          uv_tcp_nodelay(&server, 1);
+
+          struct sockaddr_in addr;
+          uv_ip4_addr(address.c_str(), port, &addr);
+          uv_tcp_bind(&server, (const sockaddr*)&addr, 0);
+
+          int r = uv_listen((uv_stream_t*) &server, DEFAULT_BACKLOG,
+              [](uv_stream_t* server, int status) {
+                  create_socket(server, status);
+              });
+
+          if (r) {
+               L_ERR("Listen error: " + std::string(uv_strerror(r)));
+          }
+
+          uv_run(loop, UV_RUN_DEFAULT);
+          return Value(0);
+     }
+#endif
+}
diff --git a/extensions/standard/sockets.hpp b/extensions/standard/sockets.hpp
new file mode 100644
index 00000000..b71e2676
--- /dev/null
+++ b/extensions/standard/sockets.hpp
@@ -0,0 +1,22 @@
+/* 
+     TODO： WINDOWS SOCKET
+*/
+#ifndef SOCKETS_HPP
+#define SOCKETS_HPP
+
+#include <iostream>
+#include "lamina.hpp"
+#ifdef __linux__
+#include <uv.h>
+uv_loop_t *loop;
+uv_tcp_t server;
+#endif
+#define DEFAULT_BACKLOG 128
+
+static int create_socket(uv_stream_t *server, int status);
+Value runnable(const std::vector<Value>& args);
+
+namespace lamina{
+     LAMINA_FUNC("socket_create", runnable, 4);
+}
+#endif //SOCKETS_HPP

From 652f13b8e8701ff68bb0ac9880474760889e0129 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 01:58:06 +0800
Subject: [PATCH 04/11] =?UTF-8?q?=E5=A4=A7=E6=9B=B4=E6=96=B0=EF=BC=81?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E8=B4=A1=E7=8C=AE=E6=96=87=E6=A1=A3=EF=BC=8C?=
 =?UTF-8?q?=E7=BC=96=E8=AF=91=E6=96=87=E6=A1=A3=EF=BC=8C=E9=87=8D=E6=96=B0?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=EF=BC=8C=E5=8E=BB?=
 =?UTF-8?q?=E9=99=A4lamina.hpp=E7=9A=84=E6=97=A0=E7=94=A8=E5=AE=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CONTRIBUTING-CN.md              | 743 +++++++++++++++++++++++++++++
 CONTRIBUTING-EN.md              | 807 ++++++++++++++++++++++++++++++++
 compile-cn.md                   |  17 +
 compile-en.md                   |  17 +
 extensions/standard/random.cpp  |   1 +
 extensions/standard/sockets.cpp |   9 +-
 interpreter/lamina.hpp          |  18 -
 7 files changed, 1587 insertions(+), 25 deletions(-)
 create mode 100644 CONTRIBUTING-CN.md
 create mode 100644 CONTRIBUTING-EN.md
 create mode 100644 compile-cn.md
 create mode 100644 compile-en.md

diff --git a/CONTRIBUTING-CN.md b/CONTRIBUTING-CN.md
new file mode 100644
index 00000000..724aecb4
--- /dev/null
+++ b/CONTRIBUTING-CN.md
@@ -0,0 +1,743 @@
+## 代码提交规范 -- 中文
+
+- 请先阅读 <https://bgithub.xyz/Ziyang-Bai/Lamina/blob/main/README.md> 了解项目的基本情况，在继续进行开发！
+- 本项目使用GPL-3.0协议，请严格遵守本协议！
+
+## 项目结构：
+```angular2html
+Lamina
+├── assets
+│   ├── logo-icon.svg
+│   └── logo.svg
+├── extensions
+│   └── standard
+│       ├── math.cpp
+│       ├── random.cpp
+│       ├── random.hpp
+│       ├── sockets.cpp
+│       ├── sockets.hpp
+│       ├── stdio.cpp
+│       ├── times.cpp
+│       └── times.hpp
+├── interpreter
+│   ├── ast.hpp
+│   ├── bigint.hpp
+│   ├── examples
+│   │   ├── calculator.lm
+│   │   ├── defin.lm
+│   │   ├── hello.lm
+│   │   ├── onestop.lm
+│   │   └── quadratic.lm
+│   ├── interpreter.cpp
+│   ├── interpreter.hpp
+│   ├── interpreter.md
+│   ├── irrational.hpp
+│   ├── lamina.hpp
+│   ├── lexer.cpp
+│   ├── lexer.hpp
+│   ├── main.cpp
+│   ├── module.cpp
+│   ├── module.hpp
+│   ├── parser.cpp
+│   ├── parser.hpp
+│   ├── rational.hpp
+│   ├── trackback.hpp
+│   └── value.hpp
+├── LICENSE
+└── README.md
+├── CMakeLists.txt
+├── compile-cn.md
+├── compile-en.md
+├── CONTRIUTING-CN.md
+```
+总计： 5 文件夹, 38 文件。
+
+## 创建拉取请求:
+
+```angular2html
+1. Fork代码到你的仓库。
+2. 克隆代码到本地。
+3. 提交代码到你的仓库。
+4. 创建拉取请求。
+```
+
+创建拉取请求时，你必须要确保你的PR内容符合以下要求：
+
+- 目的明确
+- 语言流畅
+- 代码规范
+
+在编写拉取请求标题时，必须携带如以下标识， 主要分为这几种：
+```angular2html
+1. [Feature]
+2. [Bug Fix]
+```
+如果是针对某一个模块，请在创建拉取请求时，在标题中携带类型以及你的模块名称，例如：
+```angular2html
+[Feature][stdio] 新增print函数对于文件流操作的支持
+```
+
+## 有关库/标准库:
+
+标准库的代码存放在`extensions/standard`目录下，每个文件对应一个模块，模块的名称就是文件的名称，且每个模块都要有对应的头文件，头文件内注册Lamina函数。
+
+在拓展层注册的Lamina变量均为全局变量。
+
+### 注册Lamina函数的方式： 
+
+调用LAMINA_FUNC宏，例如：
+```c++
+namespace lamina{
+     LAMINA_FUNC("lamina_func_name", cpp_func_name, arg_counts);
+}
+```
+其实，您也可以不用将函数注册到lamina命名空间下，而是直接注册，例如：
+```c++
+LAMINA_FUNC("lamina_func_name", cpp_func_name, arg_counts);
+```
+
+但是，这是一种更为规范的方式，我们更推荐这样做！
+
+若你需要声明Lamina函数，它在C++层的返回值必须声明为```Value```，并携带```const std::vector<Value> &args```参数，并且我们更推荐使用lamina.hpp中对于数据类型操作的宏，如```LAMINA_BOOL```，这对于你的Lamina库项目会更直观！
+
+但是，由于部分历史遗留问题，一些Lamina标准库的内容没有使用这些宏作为返回值。
+
+在编写标准库的代码时，必须要遵循以下规范：
+
+- 代码必须要确保一定的安全性。
+- 代码必须要符合Lamina拓展的风格。
+
+## !! 当你为Lamina编写其他库的时候，也亦是如此。
+
+## 模块解析：
+
+Lamina主要的核心模块有
+
+- bigint.hpp 大整数模块
+- interpreter.cpp 解释器模块
+- irrational.hpp 无理数模块
+- lamina.hpp 访问Lamina部分核心资源的模块
+- module.cpp 加载Lamina动态库的模块
+- rational.hpp 有理数模块
+- value.hpp 数值模块
+- parser.cpp 解析器模块
+- lexer.cpp 词法分析器模块
+
+让我们从0开始，讲解这些模块内的函数，以便于让你进入Lamina的库开发！
+
+在编写Lamina库中，最重要的便是```lamina.hpp```模块，此模块提供了Lamina库开发的一些基本的宏。
+```c++
+// Source Code:
+#pragma once
+/*
+    对LAMINA核心资源操作的头文件
+ */
+
+template<class> constexpr bool always_false = false;
+
+
+#define LAMINA_BOOL(value) Value((bool) value)
+#define LAMINA_INT(value) Value((int) value)
+#define LAMINA_DOUBLE(value) Value((double) value)
+#define LAMINA_STRING(value) Value((const char*) value)
+#define LAMINA_BIGINT(value) Value((const ::BigInt&)value)
+#define LAMINA_RATIONAL(value) Value((const ::Rational&)value)
+#define LAMINA_IRRATIONAL(value) Value((const ::Irrational&)value)
+#define LAMINA_ARR(value) Value(value)
+#define LAMINA_MATRIX(value) Value(value)
+#define LAMINA_NULL Value()
+
+#define LAMINA_FUNC_WIT_ANY_ARGS(func_name, func) \
+void func##_any_args_entry(Interpreter& interpreter); \
+namespace { \
+struct func##_any_args_registrar { \
+    func##_any_args_registrar() { \
+        Interpreter::register_entry(&func##_any_args_entry); \
+    } \
+} func##_any_args_instance; \
+} \
+void func##_any_args_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_FUNC(func_name, func, arg_count) \
+void func##_entry(Interpreter& interpreter) LAMINA_EXPORT; \
+namespace { \
+struct func##_registrar { \
+    func##_registrar() { \
+        Interpreter::register_entry(&func##_entry); \
+    } \
+} func##_instance; \
+} \
+void func##_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        if (args.size() != arg_count) { \
+            std::cerr << "Error: " << func_name << "() requires " << arg_count <<" arguments\n"; \
+            return Value(); \
+        } \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_FUNC_MULTI_ARGS(func_name, func, arg_count) \
+void func##_entry(Interpreter& interpreter); \
+namespace { \
+struct func##_registrar { \
+    func##_registrar() { \
+        Interpreter::register_entry(&func##_entry); \
+    } \
+} func##_instance; \
+} \
+void func##_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        if (args.size() > arg_count) { \
+            std::cerr << "Error: " << func_name << "() takes 0 to " << arg_count << " arguments\n"; \
+            return Value(); \
+        } \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_GET_VAR(interpreter, var) \
+   interpreter.get_variable(#var)
+
+#define L_ERR(msg)\
+    error_and_exit(msg); \
+
+#define LAMINA_GLOBAL_VAR(name, value) \
+void global_var_##name##_entry(Interpreter& interpreter) { \
+    interpreter.set_global_variable(#name, Value(value)); \
+} \
+namespace { \
+struct global_var_##name##_registrar { \
+    global_var_##name##_registrar() { \
+        Interpreter::register_entry(&global_var_##name##_entry); \
+    } \
+} global_var_##name##_instance; \
+}
+
+```
+
+- ``` LAMINA_FUNC_WIT_ANY_ARGS ```宏用于注册一个可以接受任意参数数量的Lamina函数。
+- ``` LAMINA_FUNC ```宏用于注册一个可以接受固定参数数量的Lamina函数。
+- ``` LAMINA_FUNC_MULTI_ARGS ```宏用于注册一个可以接受0到固定参数数量的Lamina函数。
+
+他们的宏的内部实现其实都大同小异，只不过对于参数数量的判断略有不同
+
+最终编译成动态库之后，他们的符号表像是这样：
+```
+0000000000020edc T _Z10test_entryR11Interpreter
+```
+
+原函数将会带有```_entry```后缀，后续将注册到```builtin_functions```这个vector容器中。
+
+```LAMINA_BOOL```宏用于操作Lamina中的布尔数据类型
+```LAMINA_INT```宏用于操作Lamina中的整数数据类型
+```LAMINA_STRING```宏用于操作Lamina中的字符串数据类型
+```LAMINA_BIGINT```宏用于操作Lamina中的大整数数据类型
+```LAMINA_RATIONAL```宏用于操作Lamina中的有理数数据类型
+```LAMINA_IRRATIONAL```宏用于操作Lamina中的无理数数据类型
+```LAMINA_ARR```宏用于操作Lamina中的数组数据类型
+```LAMINA_MATRIX```宏用于操作Lamina中的矩阵数据类型
+```LAMINA_NULL```宏用于操作Lamina中的空值数据类型
+
+可以使用```LAMINA_BOOL```等宏来直观操作Lamina函数的返回值，例如随机库当中的：
+```c++
+Value randstr(const std::vector<Value> &args) {
+     if (args.size() != 1 || !args[0].is_numeric()) {
+          L_ERR("randstr() requires exactly one numeric argument");
+          return LAMINA_NULL;
+     }
+
+     int length = std::stoi(args[0].to_string());
+     if (length < 0) {
+          L_ERR("randstr() length argument must be non-negative");
+          return LAMINA_NULL;
+     }
+
+     static const std::string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+     static std::random_device rd;
+     static std::mt19937 gen(rd());
+     std::uniform_int_distribution<> dis(0, charset.size() - 1);
+
+     std::string result;
+     result.reserve(length);
+     for (int i = 0; i < length; ++i) {
+          result += charset[dis(gen)];
+     }
+
+     return LAMINA_STRING(result.c_str());
+}
+
+```
+
+这段Lamina库代码展示了根据用户输入的字符来随机生成一串字符串，并通过```LAMINA_STRING```宏来返回值，若失败，则使用```LAMINA_NULL```宏来返回空值。
+
+- ```LAMINA_GET_VAR```宏用于在解释器运行时，在已经注册的函数内部，获取Lamina中的变量值。
+- ```LAMINA_GLOBAL_VAR```宏用于定义Lamina中的全局变量。
+
+这两个目前在标准库中还未使用，但是我们仍旧给出一个例子，便于开发：
+```c++
+#include "lamina.hpp"
+
+LAMINA_GLOBAL_VAR(a, 1);
+Interpreter interpreter;
+
+Value func_a(const std::vector<Value> &args){
+     Value a = LAMINA_GET_VAR(interpreter, a);
+}
+
+namespace lamina{
+    LAMINA_FUNC(func_a, func_a, 0);
+}
+```
+该例子主要展示了Lamina全局变量的注册方法和使用方法，在获取变量时需要传入一个解释器实例，和一个变量名，在注册全局变量的时候，需要传入一个变量名参数和值。
+
+```L_ERR```宏用于在Lamina内部执行过程中抛出一个错误，此函数不做过多讲解，仅给使用示例：
+```c++
+#include "lamina.hpp"
+
+Value a(const std::vector<Value> &args){
+     L_ERR("a is not defined");
+     return LAMINA_NULL;
+}
+```
+
+关于库的部分，我们已经讲解完毕，跳出Lamina扩展层，我们来到更为底层解释器模块！
+
+Lamina的解释器主要有这几个模块构成，他们共同支撑了Lamina在数学计算方面的优秀。
+
+- 大整数模块
+- 无理数模块
+- 有理数模块
+
+其次，还有更为底层的解析器模块和词法分析器模块，下文统称为语法处理模块。
+
+让我们先从```interpreter.cpp```的源文件进行分析。
+
+用于源码过长，这里只展示函数原型和头文件内容。
+```c++
+#pragma once
+#include "lamina.hpp"
+
+
+#include "ast.hpp"
+#include "value.hpp"
+#include <unordered_map>
+#include <string>
+#include <memory>
+#include <vector>
+#include <set>
+#include <functional>
+#include <stack>
+
+// Forward declaration for error handling
+void error_and_exit(const std::string& msg);
+
+// Stack frame for function call tracking
+struct StackFrame {
+    std::string function_name;
+    std::string file_name;
+    int line_number;
+    
+    StackFrame(const std::string& func, const std::string& file, int line)
+        : function_name(func), file_name(file), line_number(line) {}
+};
+
+// Enhanced runtime error class with stack trace support
+class RuntimeError : public std::exception {
+public:
+    std::string message;
+    std::vector<StackFrame> stack_trace;
+    
+    RuntimeError(const std::string& msg) : message(msg) {}
+    RuntimeError(const std::string& msg, const std::vector<StackFrame>& trace) 
+        : message(msg), stack_trace(trace) {}
+    
+    const char* what() const noexcept override {
+        return message.c_str();
+    }
+};
+
+// Exception for return statements
+class ReturnException : public std::exception {
+public:
+    Value value;
+    explicit ReturnException(const Value& v) : value(v) {}
+};
+
+
+// Exception for break statements
+class BreakException : public std::exception {
+public:
+    BreakException() = default;
+};
+
+
+// Exception for continue statements
+class ContinueException : public std::exception {
+public:
+    ContinueException() = default;
+};
+
+class LAMINA_EXPORT Interpreter {
+    // 禁止拷贝，允许移动
+    Interpreter(const Interpreter&) = delete;
+    Interpreter& operator=(const Interpreter&) = delete;
+    Interpreter(Interpreter&&) = default;
+    Interpreter& operator=(Interpreter&&) = default;
+public:
+    Interpreter() {
+        register_builtin_functions();
+    }
+    void execute(const std::unique_ptr<Statement>& node);
+    Value eval(const ASTNode* node);
+    // Print all variables in current scope
+    void printVariables() const;
+    void add_function(const std::string& name, FuncDefStmt* func);
+    // Stack trace management
+    void push_frame(const std::string& function_name, const std::string& file_name = "<script>", int line_number = 0);
+    void pop_frame();
+    std::vector<StackFrame> get_stack_trace() const;
+    void print_stack_trace(const RuntimeError& error, bool use_colors = true) const;
+    
+    // Utility functions for error display
+    static bool supports_colors();
+    static void print_error(const std::string& message, bool use_colors = true);
+    static void print_warning(const std::string& message, bool use_colors = true);
+    // Builtin function type
+    using BuiltinFunction = std::function<Value(const std::vector<Value>&)>;
+    // Store builtin functions
+    std::unordered_map<std::string, BuiltinFunction> builtin_functions;
+    using EntryFunction = void(*)(Interpreter&);
+    static void register_entry(EntryFunction func);
+    // Variable assignment
+    void set_variable(const std::string& name, const Value& val);
+    // built global variable in interpreter
+    void set_global_variable(const std::string& name, const Value& val);
+    // Variable lookup
+    Value get_variable(const std::string& name) const;
+    // Variable scope stack, top is the current scope
+    std::vector<std::unordered_map<std::string, Value>> variable_stack{ { } };
+private:
+    // Store function definitions
+    std::unordered_map<std::string, FuncDefStmt*> functions;
+    // List of loaded modules to prevent circular imports
+    std::set<std::string> loaded_modules;
+    // Store loaded module ASTs to keep function pointers valid
+    std::vector<std::unique_ptr<ASTNode>> loaded_module_asts;
+
+    // Stack trace for function calls
+    std::vector<StackFrame> call_stack;
+    // Recursion depth tracking
+    int recursion_depth = 0;
+    int max_recursion_depth = 100;  // 可变的递归深度限制
+    // Enter/exit scope
+    void push_scope();
+    void pop_scope();
+    // Load and execute module
+    bool load_module(const std::string& module_name);
+    // Register builtin functions
+    void register_builtin_functions();
+    static std::vector<EntryFunction> entry_functions;
+
+};
+```
+
+```error_and_exit```此函数会打印错误信息并退出程序，他的具体实现如下：
+```c++
+void error_and_exit(const std::string& msg) {
+    std::cerr << "Error: " << msg << std::endl;
+    exit(1);
+}
+```
+该函数使用时需要传入一个错误信息字符串，该字符串会被打印出来，并且程序会退出。
+
+```StackFrame```结构体存储了关于函数调用的追踪信息，他有这么几个成员变量：
+- ```function_name```：函数名
+- ```file_name```：文件名
+- ```line_number```：行号
+
+这些信息会在程序运行调用函数错误时被打印出来，用于帮助开发者定位错误的位置。
+
+在Lamina中，还有一些异常类，例如
+```RuntimeError```类继承自```std::exception```，用于表示运行时错误。
+```ReturnException```类继承自```std::exception```，用于表示返回语句错误。
+```BreakException```类继承自```std::exception```，用于表示跳出循环语句错误。
+```ContinueException```类继承自```std::exception```，用于表示继续循环语句错误。
+
+解释器类定义了一些方法，用于计算表达式值和处理控制台内容以及扩展函数和变量。
+
+下面关于类内方法的讲解顺序，均为公开方法到私有方法，公有成员变量到私有成员变量。
+
+```Interpreter```此构造函数用于调用```register_builtin_functions()```方法，用于注册内置/扩展函数。
+
+```execute```此方法用于执行AST树，他的参数是一个```Statement```指针，返回值为空。
+
+```eval```此方法用于计算表达式值，他的参数是一个```ASTNode```指针，返回值是一个```Value```对象。
+
+```printVariables```此方法用于打印栈内的所有变量，它的参数为空，返回值为空。
+
+```add_function```此方法用于添加函数，他的参数是一个函数名和一个```FuncDefStmt```指针，返回值为空。
+
+```push_frame```此方法用于添加函数调用信息，他的参数是一个函数名、文件名和行号，返回值为空。
+
+```pop_frame```此方法用于弹出函数调用信息，他的参数为空，返回值为空。
+
+```register_entry```此方法用于注册入口函数，他的参数是一个```EntryFunction```指针，返回值为空。
+
+```set_variable```此方法用于设置变量，他的参数是一个变量名和一个```Value```对象，返回值为空。
+
+```get_variable```此方法用于获取变量，他的参数是一个变量名，返回值是一个```Value```对象。
+
+```set_global_variable```此方法用于设置全局变量，他的参数是一个变量名和一个```Value```对象，返回值为空。
+
+此为对于控制台的操作：
+
+```get_stack_trace```此方法用于获取栈调用信息，他的参数为空，返回值是一个```std::vector<StackFrame>```对象。
+
+```print_stack_trace```此方法用于打印栈调用信息，他的参数是一个```RuntimeError```对象和一个```bool```值，返回值为空。
+
+```supports_colors```此方法用于判断当前终端是否支持颜色输出，他的参数为空，返回值是一个```bool```值。
+
+```print_error```此方法用于打印错误信息，他的参数是一个```std::string```对象和一个```bool```值，返回值为空。
+
+```print_warning```此方法用于打印警告信息，他的参数是一个```std::string```对象和一个```bool```值，返回值为空。
+
+成员变量：
+
+```builtin_functions```此方法存储了所有的内置/扩展函数，他的键是函数名，值是函数指针。
+
+```functions```此方法存储函数定义。
+
+```variable_stack```此方法存储了所有的变量，以及作用域，他的键是变量名，值是```Value```对象。
+
+```loaded_module_asts```此方法存储了所有的已加载模块的抽象语法树，他的键是模块名，值是抽象语法树指针。
+
+接下来，我们从解释器继续讲解，引入到Lamina对于数字处理的部分。
+
+首先，我们讲解大整数模块:
+```c++
+#pragma once
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <climits>
+
+class BigInt {
+private:
+    std::vector<int> digits;  // 存储数字，低位在前
+    bool negative;
+
+public:
+    // 构造函数
+    BigInt() : negative(false) { digits.push_back(0); }
+    
+    BigInt(int n) : negative(n < 0) {
+        if (n == 0) {
+            digits.push_back(0);
+            return;
+        }
+        
+        // 处理 INT_MIN 的特殊情况
+        if (n == INT_MIN) {
+            // INT_MIN 的绝对值超出 int 范围，直接处理
+            long long ln = static_cast<long long>(n);
+            ln = -ln;  // 现在安全了
+            while (ln > 0) {
+                digits.push_back(ln % 10);
+                ln /= 10;
+            }
+        } else {
+            n = std::abs(n);
+            while (n > 0) {
+                digits.push_back(n % 10);
+                n /= 10;
+            }
+        }
+    }
+    
+    BigInt(const std::string& str) : negative(false) {
+        if (str.empty() || str == "0") {
+            digits.push_back(0);
+            return;
+        }
+        
+        int start = 0;
+        if (str[0] == '-') {
+            negative = true;
+            start = 1;
+        } else if (str[0] == '+') {
+            start = 1;
+        }
+        
+        for (int i = str.length() - 1; i >= start; i--) {
+            if (str[i] >= '0' && str[i] <= '9') {
+                digits.push_back(str[i] - '0');
+            }
+        }
+        
+        if (digits.empty()) {
+            digits.push_back(0);
+        }
+        
+        remove_leading_zeros();
+    }
+    
+    // 移除前导零
+    void remove_leading_zeros() {
+        while (digits.size() > 1 && digits.back() == 0) {
+            digits.pop_back();
+        }
+        if (digits.size() == 1 && digits[0] == 0) {
+            negative = false;
+        }
+    }
+    
+    // 转换为字符串
+    std::string to_string() const {
+        if (digits.size() == 1 && digits[0] == 0) {
+            return "0";
+        }
+        
+        std::string result;
+        if (negative) result += "-";
+        
+        for (int i = digits.size() - 1; i >= 0; i--) {
+            result += char('0' + digits[i]);
+        }
+        
+        return result;
+    }
+    
+    // 乘法
+    BigInt operator*(const BigInt& other) const {
+        BigInt result;
+        result.digits.assign(digits.size() + other.digits.size(), 0);
+        result.negative = (negative != other.negative);
+        
+        for (size_t i = 0; i < digits.size(); i++) {
+            for (size_t j = 0; j < other.digits.size(); j++) {
+                result.digits[i + j] += digits[i] * other.digits[j];
+                if (result.digits[i + j] >= 10) {
+                    result.digits[i + j + 1] += result.digits[i + j] / 10;
+                    result.digits[i + j] %= 10;
+                }
+            }
+        }
+        
+        result.remove_leading_zeros();
+        return result;
+    }
+    
+    // 转换为int（如果可能）
+    int to_int() const {
+        if (digits.size() > 10) {  // 太大了
+            return negative ? INT_MIN : INT_MAX;
+        }
+        
+        long long result = 0;
+        long long multiplier = 1;
+        
+        for (int digit : digits) {
+            result += digit * multiplier;
+            multiplier *= 10;
+            if (result > INT_MAX) {
+                return negative ? INT_MIN : INT_MAX;
+            }
+        }
+        
+        return negative ? -static_cast<int>(result) : static_cast<int>(result);
+    }
+    
+    // 检查是否为零
+    bool is_zero() const {
+        return digits.size() == 1 && digits[0] == 0;
+    }
+    
+    // 比较运算符
+    bool operator==(const BigInt& other) const {
+        return negative == other.negative && digits == other.digits;
+    }
+    
+    bool operator!=(const BigInt& other) const {
+        return !(*this == other);
+    }
+};
+```
+
+
+`BigInt`提供了对于整形处理的更加安全的形式，避免了整形溢出的问题。
+
+在`BigInt`的内部，我们定义了两个成员变量：
+- `std::vector<int> digits` 用于存储大整数的每一位数字，低位在前。
+- `bool negative` 用于表示大整数的正负性，`true`表示负数，`false`表示正数。
+
+`BigInt`的构造函数有多个重载，允许从不同的类型构造大整数，例如从`int`、`long long`、`std::string`等。
+
+`BigInt`还提供了一些基本的运算符重载，如加法、减法、乘法、除法等，以及比较运算符。
+
+接下来，我们继续讲解无理数/有理数模块
+
+由于代码过长，这里暂时不做任何展示
+
+无理数模块支持常见的无理数的精确表示，例如π、e等。
+
+在无理数模块当中，我们定义了一个enum类，用于表示无理数的类型，这里一共有四个类型，我们这边直接展示enum类的代码。
+```c++
+   enum class Type {
+        SQRT,      // √n 形式
+        PI,        // π 的倍数
+        E,         // e 的倍数  
+        LOG,       // log(n) 形式
+        COMPLEX    // 复合形式 (a*√b + c*π + d*e + ...)
+    };
+```
+在私有成员变量里，我们定义了两个变量，用于表达根号下n的形式。
+```c++
+    // 对于 √n 形式：coefficient * √radicand
+    double coefficient;  // 系数
+    long long radicand;  // 根号内的数
+```
+
+对于不同形式，无理数模块也做了针对性处理，比如根号下n的形式，使用coefficient * √radicand，对于复合形式，我们采用了系数映射的方式：
+```c++
+    std::map<std::string, double> coefficients;
+    double constant_term;  // 常数项
+```
+
+在有理数模块中，可以表达基本的a/b形式，以及不常见的分数，并且支持化简分数。
+
+在化简分数的过程中，不用过于考虑分母值的安全性，因为在 rational 模块中，我们已经对分母进行了检查，确保分母不为零。
+
+我们跳出有关于数字处理的部分，接下来讲解语法分析模块。
+
+在语法分析模块中的解析器模块，我们在头文件中定义了一些函数原型。
+
+解析器模块用于解析不同的表达式类型，在ast模块中定义了表达式的节点。
+
+词法分析模块用于将输入的字符串转换为词法单元序列，每个词法单元对应一个标记（token）。
+
+在词法分析模块中，我们定义了一个`Token`结构体，用于表示词法单元。
+
+`Token`结构体包含了词法单元的类型、值以及位置信息。
+
+词法分析模块的主要功能是将输入的字符串转换为词法单元序列，同时处理注释、空白字符等。
+
+在词法分析模块中，我们使用了一个简单的状态机来实现词法分析。
+
+接下来，我们可以进入库加载的模块。
+
+目前库加载仅支持Linux平台下的加载，库加载主要有这几个部分构成:
+
+1. 动态链接库的加载
+2. 符号的查找和绑定
+3. 函数的调用
+
+在库加载模块中，我们使用了`dlopen`函数来加载动态链接库，使用`dlsym`函数来查找符号，使用`dlclose`函数来关闭动态链接库。
+
+`findSymbol`函数接受一个符号名作为参数，返回该符号的地址。
+
diff --git a/CONTRIBUTING-EN.md b/CONTRIBUTING-EN.md
new file mode 100644
index 00000000..65b1375f
--- /dev/null
+++ b/CONTRIBUTING-EN.md
@@ -0,0 +1,807 @@
+# Code Submission Guidelines -- English
+
+*   Please read [https://bgithub.xyz/Ziyang-Bai/Lamina/blob/main/README.md](https://bgithub.xyz/Ziyang-Bai/Lamina/blob/main/README.md) first to understand the basic information of the project before proceeding with development!
+
+*   This project uses the GPL-3.0 license; please strictly abide by this license!
+
+## Project Structure:
+
+```
+Lamina
+├── assets
+│   ├── logo-icon.svg
+│   └── logo.svg
+├── extensions
+│   └── standard
+│       ├── math.cpp
+│       ├── random.cpp
+│       ├── random.hpp
+│       ├── sockets.cpp
+│       ├── sockets.hpp
+│       ├── stdio.cpp
+│       ├── times.cpp
+│       └── times.hpp
+├── interpreter
+│   ├── ast.hpp
+│   ├── bigint.hpp
+│   ├── examples
+│   │   ├── calculator.lm
+│   │   ├── defin.lm
+│   │   ├── hello.lm
+│   │   ├── onestop.lm
+│   │   └── quadratic.lm
+│   ├── interpreter.cpp
+│   ├── interpreter.hpp
+│   ├── interpreter.md
+│   ├── irrational.hpp
+│   ├── lamina.hpp
+│   ├── lexer.cpp
+│   ├── lexer.hpp
+│   ├── main.cpp
+│   ├── module.cpp
+│   ├── module.hpp
+│   ├── parser.cpp
+│   ├── parser.hpp
+│   ├── rational.hpp
+│   ├── trackback.hpp
+│   └── value.hpp
+├── LICENSE
+└── README.md
+├── CMakeLists.txt
+├── compile-cn.md
+├── compile-en.md
+├── CONTRIUTING-CN.md
+├── CONTRIUTING-EN.md
+```
+
+Total: 5 folders, 39 files.
+
+## Creating a Pull Request:
+
+```
+1. Fork the code to your repository.
+
+2. Clone the code to your local machine.
+
+3. Commit the code to your repository.
+
+4. Create a pull request.
+```
+
+When creating a pull request, you must ensure that your PR content meets the following requirements:
+
+*   Clear purpose
+
+*   Fluent language
+
+*   Code compliance with standards
+
+When writing the pull request title, it must carry one of the ranks, mainly divided into these types:
+```
+1. [Feature]
+
+2. [Bug Fix]
+```
+
+If it is for a specific module, please include the type and your module name in the title when creating the pull request. For example:
+
+```
+[Feature][stdio] Add support for file stream operations in the print function
+```
+
+## About Libraries/Standard Libraries:
+
+The standard library code is stored in the `extensions/standard` directory. Each file corresponds to a module, where the module name is the same as the file name, and each module must have a corresponding header file that registers Lamina functions.
+
+All Lamina variables registered in the extension layer are global variables.
+
+### How to Register Lamina Functions:
+
+Call the ```LAMINA_FUNC``` macro, for example:
+
+```c++
+namespace lamina{
+    LAMINA_FUNC("lamina_func_name", cpp_func_name, arg_counts);
+}
+```
+
+But, in fact, you can also register functions directly without placing them in the lamina namespace, for example:
+```c++
+LAMINA_FUNC("lamina_func_name", cpp_func_name, arg_counts);
+```
+
+However, the former is a more standardized approach, and we recommend it!
+
+If you need to declare a Lamina function, its return value at the C++ layer must be declared as `Value`, with the parameter `const std::vector<Value> &args`. We also recommend using the macros for data type operations in lamina.hpp, such as `LAMINA_BOOL`, which will make your Lamina library project more intuitive!
+
+However, due to some historical issues, some content in the Lamina standard library does not use these macros for return values.
+
+When writing standard library code, you must follow these guidelines:
+
+*   The code must ensure a certain level of security.
+
+*   The code must conform to the style of Lamina extensions.
+
+## !! The same applies when you write other libraries for Lamina.
+
+## Module Analysis:
+
+The main core modules of Lamina include:
+
+*  bigint.hpp: Big integer module
+
+*   interpreter.cpp: Interpreter module
+
+*   irrational.hpp: Irrational number module
+
+*   lamina.hpp: Module for accessing some core resources of Lamina
+
+*   module.cpp: Module for loading Lamina dynamic libraries
+
+*   rational.hpp: Rational number module
+
+*   value.hpp: Value module
+
+*   parser.cpp: Parser module
+
+*   lexer.cpp: Lexer module
+
+Let's start from scratch and explain the functions within these modules to help you get started with Lamina library development!
+
+In Lamina library development, the most important module is `lamina.hpp`, which provides some basic macros for Lamina library development.
+
+```c++
+// Source Code:
+#pragma once
+/*
+    对LAMINA核心资源操作的头文件
+ */
+
+template<class> constexpr bool always_false = false;
+
+
+#define LAMINA_BOOL(value) Value((bool) value)
+#define LAMINA_INT(value) Value((int) value)
+#define LAMINA_DOUBLE(value) Value((double) value)
+#define LAMINA_STRING(value) Value((const char*) value)
+#define LAMINA_BIGINT(value) Value((const ::BigInt&)value)
+#define LAMINA_RATIONAL(value) Value((const ::Rational&)value)
+#define LAMINA_IRRATIONAL(value) Value((const ::Irrational&)value)
+#define LAMINA_ARR(value) Value(value)
+#define LAMINA_MATRIX(value) Value(value)
+#define LAMINA_NULL Value()
+
+#define LAMINA_FUNC_WIT_ANY_ARGS(func_name, func) \
+void func##_any_args_entry(Interpreter& interpreter); \
+namespace { \
+struct func##_any_args_registrar { \
+    func##_any_args_registrar() { \
+        Interpreter::register_entry(&func##_any_args_entry); \
+    } \
+} func##_any_args_instance; \
+} \
+void func##_any_args_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_FUNC(func_name, func, arg_count) \
+void func##_entry(Interpreter& interpreter) LAMINA_EXPORT; \
+namespace { \
+struct func##_registrar { \
+    func##_registrar() { \
+        Interpreter::register_entry(&func##_entry); \
+    } \
+} func##_instance; \
+} \
+void func##_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        if (args.size() != arg_count) { \
+            std::cerr << "Error: " << func_name << "() requires " << arg_count <<" arguments\n"; \
+            return Value(); \
+        } \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_FUNC_MULTI_ARGS(func_name, func, arg_count) \
+void func##_entry(Interpreter& interpreter); \
+namespace { \
+struct func##_registrar { \
+    func##_registrar() { \
+        Interpreter::register_entry(&func##_entry); \
+    } \
+} func##_instance; \
+} \
+void func##_entry(Interpreter& interpreter) { \
+    interpreter.builtin_functions[func_name] = [](const std::vector<Value>& args) -> Value { \
+        if (args.size() > arg_count) { \
+            std::cerr << "Error: " << func_name << "() takes 0 to " << arg_count << " arguments\n"; \
+            return Value(); \
+        } \
+        return func(args); \
+    }; \
+}
+
+#define LAMINA_GET_VAR(interpreter, var) \
+   interpreter.get_variable(#var)
+
+#define L_ERR(msg)\
+    error_and_exit(msg); \
+
+#define LAMINA_GLOBAL_VAR(name, value) \
+void global_var_##name##_entry(Interpreter& interpreter) { \
+    interpreter.set_global_variable(#name, Value(value)); \
+} \
+namespace { \
+struct global_var_##name##_registrar { \
+    global_var_##name##_registrar() { \
+        Interpreter::register_entry(&global_var_##name##_entry); \
+    } \
+} global_var_##name##_instance; \
+}
+```
+
+*   The `LAMINA_FUNC_WIT_ANY_ARGS` macro is used to register a Lamina function that can accept any number of arguments.
+
+*   The `LAMINA_FUNC` macro is used to register a Lamina function that accepts a fixed number of arguments.
+
+*   The `LAMINA_FUNC_MULTI_ARGS` macro is used to register a Lamina function that accepts 0 to a fixed number of arguments.
+
+The internal implementation of these macros is quite similar, with only slight differences in the judgment of the number of arguments.
+
+After being compiled into a dynamic library, their symbol tables look like this:
+
+
+
+```
+0000000000020edc T \_Z10test\_entryR11Interpreter
+```
+
+The original function will have an `_entry` suffix and will later be registered in the `builtin_functions` vector container.
+
+The `LAMINA_BOOL` macro is used to manipulate boolean data types in Lamina.
+
+The `LAMINA_INT` macro is used to manipulate integer data types in Lamina.
+
+The `LAMINA_STRING` macro is used to manipulate string data types in Lamina.
+
+The `LAMINA_BIGINT` macro is used to manipulate big integer data types in Lamina.
+
+The `LAMINA_RATIONAL` macro is used to manipulate rational number data types in Lamina.
+
+The `LAMINA_IRRATIONAL` macro is used to manipulate irrational number data types in Lamina.
+
+The `LAMINA_ARR` macro is used to manipulate array data types in Lamina.
+
+The `LAMINA_MATRIX` macro is used to manipulate matrix data types in Lamina.
+
+The `LAMINA_NULL` macro is used to manipulate null values in Lamina.
+
+You can use macros like `LAMINA_BOOL` to intuitively manipulate the return values of Lamina functions. For example, in the random library:
+
+
+```c++
+Value randstr(const std::vector<Value> &args) {
+     if (args.size() != 1 || !args[0].is_numeric()) {
+          L_ERR("randstr() requires exactly one numeric argument");
+          return LAMINA_NULL;
+     }
+
+     int length = std::stoi(args[0].to_string());
+     if (length < 0) {
+          L_ERR("randstr() length argument must be non-negative");
+          return LAMINA_NULL;
+     }
+
+     static const std::string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+     static std::random_device rd;
+     static std::mt19937 gen(rd());
+     std::uniform_int_distribution<> dis(0, charset.size() - 1);
+
+     std::string result;
+     result.reserve(length);
+     for (int i = 0; i < length; ++i) {
+          result += charset[dis(gen)];
+     }
+
+     return LAMINA_STRING(result.c_str());
+}
+
+```
+
+This Lamina library code demonstrates generating a random string based on the user-input length, returning the value via the `LAMINA_STRING` macro, or returning a null value via the `LAMINA_NULL` macro if it fails.
+
+*   The `LAMINA_GET_VAR` macro is used to retrieve the value of a variable in Lamina within a registered function during interpreter runtime.
+
+*   The `LAMINA_GLOBAL_VAR` macro is used to define global variables in Lamina.
+
+These two are not yet used in the standard library, but we still provide an example for development:
+
+```c++
+#include "lamina.hpp"
+
+LAMINA_GLOBAL_VAR(a, 1);
+Interpreter interpreter;
+
+Value func_a(const std::vector<Value> &args){
+     Value a = LAMINA_GET_VAR(interpreter, a);
+}
+
+namespace lamina{
+    LAMINA_FUNC(func_a, func_a, 0);
+}
+```
+
+This example demonstrates the registration and usage of Lamina global variables. To retrieve a variable, you need to pass an interpreter instance and a variable name. When registering a global variable, you need to pass a variable name parameter and a value.
+
+The `L_ERR` macro is used to throw an error during Lamina's internal execution. Here's a usage example without further explanation:
+
+```c++
+#include "lamina.hpp"
+
+Value a(const std::vector<Value> &args){
+     L_ERR("a is not defined");
+     return LAMINA_NULL;
+}
+```
+
+We've covered the library section. Now, let's move beyond the Lamina extension layer to the more underlying interpreter module!
+
+Lamina's interpreter mainly consists of these modules, which collectively support Lamina's excellence in mathematical calculations:
+
+
+*   Big integer module
+
+*   Irrational number module
+
+*   Rational number module
+
+Additionally, there are more underlying parser and lexer modules, collectively referred to as syntax processing modules below.
+
+Let's start with the source file analysis of `interpreter.cpp`.
+
+Due to the lengthy source code, only function prototypes and header file content are shown here.
+
+```c++
+#pragma once
+#include "lamina.hpp"
+
+
+#include "ast.hpp"
+#include "value.hpp"
+#include <unordered_map>
+#include <string>
+#include <memory>
+#include <vector>
+#include <set>
+#include <functional>
+#include <stack>
+
+// Forward declaration for error handling
+void error_and_exit(const std::string& msg);
+
+// Stack frame for function call tracking
+struct StackFrame {
+    std::string function_name;
+    std::string file_name;
+    int line_number;
+    
+    StackFrame(const std::string& func, const std::string& file, int line)
+        : function_name(func), file_name(file), line_number(line) {}
+};
+
+// Enhanced runtime error class with stack trace support
+class RuntimeError : public std::exception {
+public:
+    std::string message;
+    std::vector<StackFrame> stack_trace;
+    
+    RuntimeError(const std::string& msg) : message(msg) {}
+    RuntimeError(const std::string& msg, const std::vector<StackFrame>& trace) 
+        : message(msg), stack_trace(trace) {}
+    
+    const char* what() const noexcept override {
+        return message.c_str();
+    }
+};
+
+// Exception for return statements
+class ReturnException : public std::exception {
+public:
+    Value value;
+    explicit ReturnException(const Value& v) : value(v) {}
+};
+
+
+// Exception for break statements
+class BreakException : public std::exception {
+public:
+    BreakException() = default;
+};
+
+
+// Exception for continue statements
+class ContinueException : public std::exception {
+public:
+    ContinueException() = default;
+};
+
+class LAMINA_EXPORT Interpreter {
+    // 禁止拷贝，允许移动
+    Interpreter(const Interpreter&) = delete;
+    Interpreter& operator=(const Interpreter&) = delete;
+    Interpreter(Interpreter&&) = default;
+    Interpreter& operator=(Interpreter&&) = default;
+public:
+    Interpreter() {
+        register_builtin_functions();
+    }
+    void execute(const std::unique_ptr<Statement>& node);
+    Value eval(const ASTNode* node);
+    // Print all variables in current scope
+    void printVariables() const;
+    void add_function(const std::string& name, FuncDefStmt* func);
+    // Stack trace management
+    void push_frame(const std::string& function_name, const std::string& file_name = "<script>", int line_number = 0);
+    void pop_frame();
+    std::vector<StackFrame> get_stack_trace() const;
+    void print_stack_trace(const RuntimeError& error, bool use_colors = true) const;
+    
+    // Utility functions for error display
+    static bool supports_colors();
+    static void print_error(const std::string& message, bool use_colors = true);
+    static void print_warning(const std::string& message, bool use_colors = true);
+    // Builtin function type
+    using BuiltinFunction = std::function<Value(const std::vector<Value>&)>;
+    // Store builtin functions
+    std::unordered_map<std::string, BuiltinFunction> builtin_functions;
+    using EntryFunction = void(*)(Interpreter&);
+    static void register_entry(EntryFunction func);
+    // Variable assignment
+    void set_variable(const std::string& name, const Value& val);
+    // built global variable in interpreter
+    void set_global_variable(const std::string& name, const Value& val);
+    // Variable lookup
+    Value get_variable(const std::string& name) const;
+    // Variable scope stack, top is the current scope
+    std::vector<std::unordered_map<std::string, Value>> variable_stack{ { } };
+private:
+    // Store function definitions
+    std::unordered_map<std::string, FuncDefStmt*> functions;
+    // List of loaded modules to prevent circular imports
+    std::set<std::string> loaded_modules;
+    // Store loaded module ASTs to keep function pointers valid
+    std::vector<std::unique_ptr<ASTNode>> loaded_module_asts;
+
+    // Stack trace for function calls
+    std::vector<StackFrame> call_stack;
+    // Recursion depth tracking
+    int recursion_depth = 0;
+    int max_recursion_depth = 100;  // 可变的递归深度限制
+    // Enter/exit scope
+    void push_scope();
+    void pop_scope();
+    // Load and execute module
+    bool load_module(const std::string& module_name);
+    // Register builtin functions
+    void register_builtin_functions();
+    static std::vector<EntryFunction> entry_functions;
+
+};
+```
+
+The `error_and_exit` function prints an error message and exits the program. Its specific implementation is as follows:
+
+```c++
+void error_and_exit(const std::string& msg) {
+    std::cerr << "Error: " << msg << std::endl;
+    exit(1);
+}
+```
+
+This function requires passing an error message string, which will be printed, and the program will exit.
+
+The `StackFrame` struct stores tracking information about function calls, with these member variables:
+
+*   `function_name`: Function name
+
+*   `file_name`: File name
+
+*   `line_number`: Line number
+
+This information will be printed when an error occurs during function calls at runtime to help developers locate the error.
+
+In Lamina, there are several exception classes, such as:
+
+The `RuntimeError` class inherits from `std::exception` and is used to represent runtime errors.
+
+The `ReturnException` class inherits from `std::exception` and is used to represent return statement errors.
+
+The `BreakException` class inherits from `std::exception` and is used to represent loop break statement errors.
+
+The `ContinueException` class inherits from `std::exception` and is used to represent loop continue statement errors.
+
+The interpreter class defines methods for evaluating expression values, handling console content, and extending functions and variables.
+
+The following explanation of class methods follows the order from public to private methods, and public member variables to private member variables.
+
+The `Interpreter` constructor calls the `register_builtin_functions()` method to register built-in/extended functions.
+
+The `execute` method is used to execute the AST tree, taking a `Statement` pointer as a parameter and returning nothing.
+
+The `eval` method is used to evaluate expression values, taking an `ASTNode` pointer as a parameter and returning a `Value` object.
+
+The `printVariables` method is used to print all variables in the stack, taking no parameters and returning nothing.
+
+The `add_function` method is used to add functions, taking a function name and a `FuncDefStmt` pointer as parameters and returning nothing.
+
+The `push_frame` method is used to add function call information, taking a function name, file name, and line number as parameters and returning nothing.
+
+The `pop_frame` method is used to pop function call information, taking no parameters and returning nothing.
+
+The `register_entry` method is used to register entry functions, taking an `EntryFunction` pointer as a parameter and returning nothing.
+
+The `set_variable` method is used to set variables, taking a variable name and a `Value` object as parameters and returning nothing.
+
+The `get_variable` method is used to retrieve variables, taking a variable name as a parameter and returning a `Value` object.
+
+The `set_global_variable` method is used to set global variables, taking a variable name and a `Value` object as parameters and returning nothing.
+
+Console operations:
+
+The `get_stack_trace` method is used to retrieve stack call information, taking no parameters and returning a `std::vector<StackFrame>` object.
+
+The `print_stack_trace` method is used to print stack call information, taking a `RuntimeError` object and a `bool` value as parameters and returning nothing.
+
+The `supports_colors` method is used to determine whether the current terminal supports color output, taking no parameters and returning a `bool` value.
+
+The `print_error` method is used to print error messages, taking a `std::string` object and a `bool` value as parameters and returning nothing.
+
+The `print_warning` method is used to print warning messages, taking a `std::string` object and a `bool` value as parameters and returning nothing.
+
+Member variables:
+
+`builtin_functions` stores all built-in/extended functions, with keys as function names and values as function pointers.
+
+`functions` stores function definitions.
+
+`variable_stack` stores all variables and scopes, with keys as variable names and values as `Value` objects.
+
+`loaded_module_asts` stores the abstract syntax trees of all loaded modules, with keys as module names and values as abstract syntax tree pointers.
+
+Next, we continue from the interpreter to Lamina's number processing section.
+
+First, let's explain the big integer module:
+
+
+```c++
+#pragma once
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <climits>
+
+class BigInt {
+private:
+    std::vector<int> digits;  // 存储数字，低位在前
+    bool negative;
+
+public:
+    // 构造函数
+    BigInt() : negative(false) { digits.push_back(0); }
+    
+    BigInt(int n) : negative(n < 0) {
+        if (n == 0) {
+            digits.push_back(0);
+            return;
+        }
+        
+        // 处理 INT_MIN 的特殊情况
+        if (n == INT_MIN) {
+            // INT_MIN 的绝对值超出 int 范围，直接处理
+            long long ln = static_cast<long long>(n);
+            ln = -ln;  // 现在安全了
+            while (ln > 0) {
+                digits.push_back(ln % 10);
+                ln /= 10;
+            }
+        } else {
+            n = std::abs(n);
+            while (n > 0) {
+                digits.push_back(n % 10);
+                n /= 10;
+            }
+        }
+    }
+    
+    BigInt(const std::string& str) : negative(false) {
+        if (str.empty() || str == "0") {
+            digits.push_back(0);
+            return;
+        }
+        
+        int start = 0;
+        if (str[0] == '-') {
+            negative = true;
+            start = 1;
+        } else if (str[0] == '+') {
+            start = 1;
+        }
+        
+        for (int i = str.length() - 1; i >= start; i--) {
+            if (str[i] >= '0' && str[i] <= '9') {
+                digits.push_back(str[i] - '0');
+            }
+        }
+        
+        if (digits.empty()) {
+            digits.push_back(0);
+        }
+        
+        remove_leading_zeros();
+    }
+    
+    // 移除前导零
+    void remove_leading_zeros() {
+        while (digits.size() > 1 && digits.back() == 0) {
+            digits.pop_back();
+        }
+        if (digits.size() == 1 && digits[0] == 0) {
+            negative = false;
+        }
+    }
+    
+    // 转换为字符串
+    std::string to_string() const {
+        if (digits.size() == 1 && digits[0] == 0) {
+            return "0";
+        }
+        
+        std::string result;
+        if (negative) result += "-";
+        
+        for (int i = digits.size() - 1; i >= 0; i--) {
+            result += char('0' + digits[i]);
+        }
+        
+        return result;
+    }
+    
+    // 乘法
+    BigInt operator*(const BigInt& other) const {
+        BigInt result;
+        result.digits.assign(digits.size() + other.digits.size(), 0);
+        result.negative = (negative != other.negative);
+        
+        for (size_t i = 0; i < digits.size(); i++) {
+            for (size_t j = 0; j < other.digits.size(); j++) {
+                result.digits[i + j] += digits[i] * other.digits[j];
+                if (result.digits[i + j] >= 10) {
+                    result.digits[i + j + 1] += result.digits[i + j] / 10;
+                    result.digits[i + j] %= 10;
+                }
+            }
+        }
+        
+        result.remove_leading_zeros();
+        return result;
+    }
+    
+    // 转换为int（如果可能）
+    int to_int() const {
+        if (digits.size() > 10) {  // 太大了
+            return negative ? INT_MIN : INT_MAX;
+        }
+        
+        long long result = 0;
+        long long multiplier = 1;
+        
+        for (int digit : digits) {
+            result += digit * multiplier;
+            multiplier *= 10;
+            if (result > INT_MAX) {
+                return negative ? INT_MIN : INT_MAX;
+            }
+        }
+        
+        return negative ? -static_cast<int>(result) : static_cast<int>(result);
+    }
+    
+    // 检查是否为零
+    bool is_zero() const {
+        return digits.size() == 1 && digits[0] == 0;
+    }
+    
+    // 比较运算符
+    bool operator==(const BigInt& other) const {
+        return negative == other.negative && digits == other.digits;
+    }
+    
+    bool operator!=(const BigInt& other) const {
+        return !(*this == other);
+    }
+};
+```
+
+`BigInt` provides a safer form of integer processing, avoiding integer overflow issues.
+
+Internally, `BigInt` defines two member variables:
+
+*   `std::vector<int> digits`: Stores each digit of the big integer, with the least significant digit first.
+
+*   `bool negative`: Indicates the sign of the big integer; `true` for negative, `false` for positive.
+
+`BigInt` has multiple overloaded constructors, allowing big integers to be constructed from different types such as `int`, `long long`, `std::string`, etc.
+
+`BigInt` also provides some basic operator overloads, such as addition, subtraction, multiplication, division, and comparison operators.
+
+Next, we continue with the irrational/rational number modules.
+
+Due to the length of the code, no examples are shown here.
+
+The irrational number module supports precise representation of common irrational numbers such as π, e, etc.
+
+In the irrational number module, we define an enum class to represent the type of irrational number. There are four types, and we directly show the enum class code here:
+
+
+```c++
+   enum class Type {
+        SQRT,      // √n 形式
+        PI,        // π 的倍数
+        E,         // e 的倍数  
+        LOG,       // log(n) 形式
+        COMPLEX    // 复合形式 (a*√b + c*π + d*e + ...)
+    };
+```
+In the private member variables, we define two variables to express the form of √n:
+
+
+```c++
+    // 对于 √n 形式：coefficient * √radicand
+    double coefficient;  // 系数
+    long long radicand;  // 根号内的数
+```
+The irrational number module handles different forms specifically. For example, the √n form uses coefficient \* √radicand, and for composite forms, we use a coefficient mapping approach:
+
+
+```c++
+    std::map<std::string, double> coefficients;
+    double constant_term;  // 常数项
+```
+
+The rational number module can express basic a/b forms and uncommon fractions, and supports fraction simplification.
+
+During fraction simplification, there's no need to overly consider the safety of the denominator value, because the rational module already checks the denominator to ensure it is not zero.
+
+Moving beyond number processing, let's explain the syntax analysis module.
+
+In the parser module of the syntax analysis module, we define some function prototypes in the header file.
+
+The parser module is used to parse different expression types, and the ast module defines expression nodes.
+
+The lexer module is used to convert input strings into a sequence of lexical units, where each lexical unit corresponds to a token.
+
+In the lexer module, we define a `Token` struct to represent lexical units.
+
+The `Token` struct contains the type, value, and position information of the lexical unit.
+
+The main function of the lexer module is to convert input strings into a sequence of lexical units, while handling comments, whitespace characters, etc.
+
+In the lexer module, we use a simple state machine to implement lexical analysis.
+
+Next, we can move to the library loading module.
+
+Currently, library loading only supports loading on Linux platforms. Library loading mainly consists of these parts:
+
+1.  Loading of dynamic link libraries
+
+2.  Symbol lookup and binding
+
+3.  Function calling
+
+In the library loading module, we use the `dlopen` function to load dynamic link libraries, `dlsym` to find symbols, and `dlclose` to close dynamic link libraries.
+
+The `findSymbol` function accepts a symbol name as a parameter and returns the address of that symbol.
\ No newline at end of file
diff --git a/compile-cn.md b/compile-cn.md
new file mode 100644
index 00000000..07957e32
--- /dev/null
+++ b/compile-cn.md
@@ -0,0 +1,17 @@
+## 编译方法 
+
+Linux平台:
+```shell
+mkdir build
+cd build
+cmake ..
+make
+```
+
+Windows平台:
+```shell
+mkdir build
+cd build
+cmake .. -G "MinGW Makefiles"
+mingw32-make
+```
\ No newline at end of file
diff --git a/compile-en.md b/compile-en.md
new file mode 100644
index 00000000..14b04a71
--- /dev/null
+++ b/compile-en.md
@@ -0,0 +1,17 @@
+## Compile
+
+Linux PlatForm:
+```shell
+mkdir build
+cd build
+cmake ..
+make
+```
+
+Windows PlatForm:
+```shell
+mkdir build
+cd build
+cmake .. -G "MinGW Makefiles"
+mingw32-make
+```
\ No newline at end of file
diff --git a/extensions/standard/random.cpp b/extensions/standard/random.cpp
index 66030546..a8630614 100644
--- a/extensions/standard/random.cpp
+++ b/extensions/standard/random.cpp
@@ -21,6 +21,7 @@ Value randint(const std::vector<Value> &args) {
 }
 
 Value randstr(const std::vector<Value> &args) {
+
      if (args.size() != 1 || !args[0].is_numeric()) {
           L_ERR("randstr() requires exactly one numeric argument");
           return LAMINA_NULL;
diff --git a/extensions/standard/sockets.cpp b/extensions/standard/sockets.cpp
index d3bca6ef..039f8a9b 100644
--- a/extensions/standard/sockets.cpp
+++ b/extensions/standard/sockets.cpp
@@ -1,11 +1,6 @@
-/* 
-     CopyRight Shizuku Technologies
-     2025.07.24 22:39
-     @Dev Ange1PlsGreet
-*/
 #include "sockets.hpp"
 
-SOCKETS_HPP int create_socket(uv_stream_t *server, int status) {
+int create_socket(uv_stream_t *server, int status) {
 #ifdef __linux__
      if (status < 0) {
           return -1;
@@ -23,7 +18,7 @@ SOCKETS_HPP int create_socket(uv_stream_t *server, int status) {
 #endif
 }
 
-SOCKETS_HPP Value runnable(const std::vector<Value> &args) {
+Value runnable(const std::vector<Value> &args) {
      std::string address = args[0].to_string();
      if (!args[1].is_numeric()) {
           L_ERR("Second Arg Must Be Number!");
diff --git a/interpreter/lamina.hpp b/interpreter/lamina.hpp
index 0cf37b5e..019121de 100644
--- a/interpreter/lamina.hpp
+++ b/interpreter/lamina.hpp
@@ -88,24 +88,6 @@ void func##_entry(Interpreter& interpreter) { \
 #define L_ERR(msg)\
     error_and_exit(msg); \
 
-#define LAMINA_VAR(interpreter, name, value) \
-do { \
-    auto&& _v = (value); \
-    Value name##_value; \
-    if constexpr (std::is_same_v<std::decay_t<decltype(_v)>, bool>) { \
-        name##_value = Value(static_cast<bool>(_v)); \
-    } else if constexpr (std::is_integral_v<std::decay_t<decltype(_v)>>) { \
-        name##_value = Value(static_cast<int>(_v)); \
-    } else if constexpr (std::is_floating_point_v<std::decay_t<decltype(_v)>>) { \
-        name##_value = Value(static_cast<double>(_v)); \
-    } else if constexpr (std::is_convertible_v<decltype(_v), std::string>) { \
-        name##_value = Value(std::to_string(_v)); \
-    } else { \
-        name##_value = Value(std::to_string(_v)); \
-    } \
-    (interpreter).set_variable(#name, value); \
-} while(0)
-
 #define LAMINA_GLOBAL_VAR(name, value) \
 void global_var_##name##_entry(Interpreter& interpreter) { \
     interpreter.set_global_variable(#name, Value(value)); \

From 9c03bcfb717466cbb4dc90b9b307b6090dd596f1 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:11:34 +0800
Subject: [PATCH 05/11] Create c-cpp.yml

---
 .github/workflows/c-cpp.yml | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 .github/workflows/c-cpp.yml

diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
new file mode 100644
index 00000000..6a9c312e
--- /dev/null
+++ b/.github/workflows/c-cpp.yml
@@ -0,0 +1,23 @@
+name: C/C++ CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: configure
+      run: ./configure
+    - name: make
+      run: make
+    - name: make check
+      run: make check
+    - name: make distcheck
+      run: make distcheck

From b22af6c08af88eb6a779158334f062c6bfc78d9f Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:13:02 +0800
Subject: [PATCH 06/11] Create cmake-multi-platform.yml

---
 .github/workflows/cmake-multi-platform.yml | 75 ++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 .github/workflows/cmake-multi-platform.yml

diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml
new file mode 100644
index 00000000..7ab1b4d7
--- /dev/null
+++ b/.github/workflows/cmake-multi-platform.yml
@@ -0,0 +1,75 @@
+# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform.
+# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml
+name: CMake on multiple platforms
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
+      fail-fast: false
+
+      # Set up a matrix to run the following 3 configurations:
+      # 1. <Windows, Release, latest MSVC compiler toolchain on the default runner image, default generator>
+      # 2. <Linux, Release, latest GCC compiler toolchain on the default runner image, default generator>
+      # 3. <Linux, Release, latest Clang compiler toolchain on the default runner image, default generator>
+      #
+      # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list.
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        build_type: [Release]
+        c_compiler: [gcc, clang, cl]
+        include:
+          - os: windows-latest
+            c_compiler: cl
+            cpp_compiler: cl
+          - os: ubuntu-latest
+            c_compiler: gcc
+            cpp_compiler: g++
+          - os: ubuntu-latest
+            c_compiler: clang
+            cpp_compiler: clang++
+        exclude:
+          - os: windows-latest
+            c_compiler: gcc
+          - os: windows-latest
+            c_compiler: clang
+          - os: ubuntu-latest
+            c_compiler: cl
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set reusable strings
+      # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
+      id: strings
+      shell: bash
+      run: |
+        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: >
+        cmake -B ${{ steps.strings.outputs.build-output-dir }}
+        -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+        -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+        -S ${{ github.workspace }}
+
+    - name: Build
+      # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
+
+    - name: Test
+      working-directory: ${{ steps.strings.outputs.build-output-dir }}
+      # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest --build-config ${{ matrix.build_type }}

From d7920924134b74733577c3236a52a2906e195103 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:21:51 +0800
Subject: [PATCH 07/11] =?UTF-8?q?=E4=BF=AE=E6=94=B9CI=E5=B7=A5=E4=BD=9C?=
 =?UTF-8?q?=E6=B5=81=EF=BC=8C=E8=BF=9B=E8=A1=8C=E6=9C=AC=E5=9C=B0=E4=BB=93?=
 =?UTF-8?q?=E5=BA=93=E6=B5=8B=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/build.yml                | 309 +++++++++++----------
 .github/workflows/c-cpp.yml                |  23 --
 .github/workflows/cmake-multi-platform.yml |  75 -----
 3 files changed, 155 insertions(+), 252 deletions(-)
 delete mode 100644 .github/workflows/c-cpp.yml
 delete mode 100644 .github/workflows/cmake-multi-platform.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 710ff7ce..935d2830 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -24,120 +24,121 @@ jobs:
             compiler: msvc
 
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-
-    - name: Set up build environment (Ubuntu)
-      if: matrix.os == 'ubuntu-latest'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y build-essential
-        if [ "${{ matrix.compiler }}" = "clang++" ]; then
-          sudo apt-get install -y clang
-        fi
-
-    - name: Set up build environment (macOS)
-      if: matrix.os == 'macos-latest'
-      run: |
-        if [ "${{ matrix.compiler }}" = "clang++" ]; then
-          # clang++ is already available on macOS
-          echo "Using system clang++"
-        else
-          # Install GCC if needed
-          brew install gcc
-        fi
-
-    - name: Set up MSVC (Windows)
-      if: matrix.os == 'windows-latest' && matrix.compiler == 'msvc'
-      uses: ilammy/msvc-dev-cmd@v1
-
-    - name: Set up MinGW (Windows)
-      if: matrix.os == 'windows-latest' && matrix.compiler == 'g++'
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: MINGW64
-        update: true
-        install: mingw-w64-x86_64-gcc
-
-    - name: Build with GCC/Clang (Unix)
-      if: matrix.os != 'windows-latest' || matrix.compiler == 'g++'
-      working-directory: interpreter
-      shell: bash
-      run: |
-        if [ "${{ matrix.os }}" = "windows-latest" ]; then
-          # Use MSYS2 environment for MinGW
-          export PATH="/c/msys64/mingw64/bin:$PATH"
-        fi
-        
-        echo "Building with ${{ matrix.compiler }}..."
-        ${{ matrix.compiler }} --version
-        
-        # Compile the interpreter
-        ${{ matrix.compiler }} -std=c++17 -O2 -Wall -Wextra \
-          main.cpp lexer.cpp parser.cpp interpreter.cpp \
-          -o lamina${{ matrix.os == 'windows-latest' && '.exe' || '' }}
-        
-        echo "Build completed successfully!"
-
-    - name: Build with MSVC (Windows)
-      if: matrix.os == 'windows-latest' && matrix.compiler == 'msvc'
-      working-directory: interpreter
-      run: |
-        echo "Building with MSVC..."
-        cl /EHsc /std:c++17 /O2 main.cpp lexer.cpp parser.cpp interpreter.cpp /Fe:lamina.exe
-        echo "Build completed successfully!"
-
-    - name: Test basic functionality
-      working-directory: interpreter
-      shell: bash
-      run: |
-        echo "Testing basic functionality..."
-        
-        # Create a simple test file
-        if [ "${{ matrix.os }}" = "windows-latest" ]; then
-          echo 'print("Hello, Lamina!");' > test.lm
-          echo 'var x = 2 + 3;' >> test.lm
-          echo 'print("2 + 3 =", x);' >> test.lm
-          ./lamina.exe test.lm
-        else
-          echo 'print("Hello, Lamina!");' > test.lm
-          echo 'var x = 2 + 3;' >> test.lm
-          echo 'print("2 + 3 =", x);' >> test.lm
-          ./lamina test.lm
-        fi
-        
-        echo "Basic test passed!"
-
-    - name: Run example programs
-      working-directory: interpreter
-      shell: bash
-      run: |
-        echo "Running example programs..."
-        
-        # Test all example files if they exist
-        if [ -d "examples" ]; then
-          for example in examples/*.lm; do
-            if [ -f "$example" ]; then
-              echo "Testing $example..."
-              if [ "${{ matrix.os }}" = "windows-latest" ]; then
-                ./lamina.exe "$example" || echo "Warning: $example failed"
-              else
-                ./lamina "$example" || echo "Warning: $example failed"
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up build environment (Ubuntu)
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential
+          if [ "${{ matrix.compiler }}" = "clang++" ]; then
+            sudo apt-get install -y clang
+          fi
+
+      - name: Set up build environment (macOS)
+        if: matrix.os == 'macos-latest'
+        run: |
+          if [ "${{ matrix.compiler }}" = "clang++" ]; then
+            # clang++ is already available on macOS
+            echo "Using system clang++"
+          else
+            # Install GCC if needed
+            brew install gcc
+          fi
+
+      - name: Set up MSVC (Windows)
+        if: matrix.os == 'windows-latest' && matrix.compiler == 'msvc'
+        uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Set up MinGW (Windows)
+        if: matrix.os == 'windows-latest' && matrix.compiler == 'g++'
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: true
+          install: mingw-w64-x86_64-gcc
+
+      - name: Build with GCC/Clang (Unix)
+        if: matrix.os != 'windows-latest' || matrix.compiler == 'g++'
+        working-directory: interpreter
+        shell: bash
+        run: |
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            # Use MSYS2 environment for MinGW
+            export PATH="/c/msys64/mingw64/bin:$PATH"
+          fi
+          
+          echo "Building with ${{ matrix.compiler }}..."
+          ${{ matrix.compiler }} --version
+          
+          # 编译命令中添加了module.cpp
+          ${{ matrix.compiler }} -std=c++17 -O2 -Wall -Wextra \
+            main.cpp lexer.cpp parser.cpp interpreter.cpp module.cpp \
+            -o lamina${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+          
+          echo "Build completed successfully!"
+
+      - name: Build with MSVC (Windows)
+        if: matrix.os == 'windows-latest' && matrix.compiler == 'msvc'
+        working-directory: interpreter
+        run: |
+          echo "Building with MSVC..."
+          # 编译命令中添加了module.cpp
+          cl /EHsc /std:c++17 /O2 main.cpp lexer.cpp parser.cpp interpreter.cpp module.cpp /Fe:lamina.exe
+          echo "Build completed successfully!"
+
+      - name: Test basic functionality
+        working-directory: interpreter
+        shell: bash
+        run: |
+          echo "Testing basic functionality..."
+          
+          # Create a simple test file
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            echo 'print("Hello, Lamina!");' > test.lm
+            echo 'var x = 2 + 3;' >> test.lm
+            echo 'print("2 + 3 =", x);' >> test.lm
+            ./lamina.exe test.lm
+          else
+            echo 'print("Hello, Lamina!");' > test.lm
+            echo 'var x = 2 + 3;' >> test.lm
+            echo 'print("2 + 3 =", x);' >> test.lm
+            ./lamina test.lm
+          fi
+          
+          echo "Basic test passed!"
+
+      - name: Run example programs
+        working-directory: interpreter
+        shell: bash
+        run: |
+          echo "Running example programs..."
+          
+          # Test all example files if they exist
+          if [ -d "examples" ]; then
+            for example in examples/*.lm; do
+              if [ -f "$example" ]; then
+                echo "Testing $example..."
+                if [ "${{ matrix.os }}" = "windows-latest" ]; then
+                  ./lamina.exe "$example" || echo "Warning: $example failed"
+                else
+                  ./lamina "$example" || echo "Warning: $example failed"
+                fi
               fi
-            fi
-          done
-        else
-          echo "No examples directory found, skipping example tests"
-        fi
-
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: lamina-${{ matrix.os }}-${{ matrix.compiler }}
-        path: |
-          interpreter/lamina${{ matrix.os == 'windows-latest' && '.exe' || '' }}
-          interpreter/examples/
-        retention-days: 30
+            done
+          else
+            echo "No examples directory found, skipping example tests"
+          fi
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: lamina-${{ matrix.os }}-${{ matrix.compiler }}
+          path: |
+            interpreter/lamina${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+            interpreter/examples/
+          retention-days: 30
 
   release:
     needs: build
@@ -145,44 +146,44 @@ jobs:
     if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))
     
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-      
-    - name: Download all artifacts
-      uses: actions/download-artifact@v4
-      with:
-        path: artifacts
-        
-    - name: Create release assets
-      run: |
-        mkdir -p release
-        
-        # Package Linux build
-        if [ -f "artifacts/lamina-ubuntu-latest-g++/lamina" ]; then
-          cd artifacts/lamina-ubuntu-latest-g++
-          tar -czf ../../release/lamina-linux-x64.tar.gz lamina examples/
-          cd ../..
-        fi
-        
-        # Package Windows build
-        if [ -f "artifacts/lamina-windows-latest-g++/lamina.exe" ]; then
-          cd artifacts/lamina-windows-latest-g++
-          zip -r ../../release/lamina-windows-x64.zip lamina.exe examples/
-          cd ../..
-        fi
-        
-        # Package macOS build
-        if [ -f "artifacts/lamina-macos-latest-g++/lamina" ]; then
-          cd artifacts/lamina-macos-latest-g++
-          tar -czf ../../release/lamina-macos-x64.tar.gz lamina examples/
-          cd ../..
-        fi
-        
-        ls -la release/
-
-    - name: Upload release assets
-      uses: actions/upload-artifact@v4
-      with:
-        name: lamina-release-packages
-        path: release/
-        retention-days: 90
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Create release assets
+        run: |
+          mkdir -p release
+          
+          # Package Linux build
+          if [ -f "artifacts/lamina-ubuntu-latest-g++/lamina" ]; then
+            cd artifacts/lamina-ubuntu-latest-g++
+            tar -czf ../../release/lamina-linux-x64.tar.gz lamina examples/
+            cd ../..
+          fi
+          
+          # Package Windows build
+          if [ -f "artifacts/lamina-windows-latest-g++/lamina.exe" ]; then
+            cd artifacts/lamina-windows-latest-g++
+            zip -r ../../release/lamina-windows-x64.zip lamina.exe examples/
+            cd ../..
+          fi
+          
+          # Package macOS build
+          if [ -f "artifacts/lamina-macos-latest-g++/lamina" ]; then
+            cd artifacts/lamina-macos-latest-g++
+            tar -czf ../../release/lamina-macos-x64.tar.gz lamina examples/
+            cd ../..
+          fi
+          
+          ls -la release/
+
+      - name: Upload release assets
+        uses: actions/upload-artifact@v4
+        with:
+          name: lamina-release-packages
+          path: release/
+          retention-days: 90
diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
deleted file mode 100644
index 6a9c312e..00000000
--- a/.github/workflows/c-cpp.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: C/C++ CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: configure
-      run: ./configure
-    - name: make
-      run: make
-    - name: make check
-      run: make check
-    - name: make distcheck
-      run: make distcheck
diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml
deleted file mode 100644
index 7ab1b4d7..00000000
--- a/.github/workflows/cmake-multi-platform.yml
+++ /dev/null
@@ -1,75 +0,0 @@
-# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform.
-# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml
-name: CMake on multiple platforms
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
-      fail-fast: false
-
-      # Set up a matrix to run the following 3 configurations:
-      # 1. <Windows, Release, latest MSVC compiler toolchain on the default runner image, default generator>
-      # 2. <Linux, Release, latest GCC compiler toolchain on the default runner image, default generator>
-      # 3. <Linux, Release, latest Clang compiler toolchain on the default runner image, default generator>
-      #
-      # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list.
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        build_type: [Release]
-        c_compiler: [gcc, clang, cl]
-        include:
-          - os: windows-latest
-            c_compiler: cl
-            cpp_compiler: cl
-          - os: ubuntu-latest
-            c_compiler: gcc
-            cpp_compiler: g++
-          - os: ubuntu-latest
-            c_compiler: clang
-            cpp_compiler: clang++
-        exclude:
-          - os: windows-latest
-            c_compiler: gcc
-          - os: windows-latest
-            c_compiler: clang
-          - os: ubuntu-latest
-            c_compiler: cl
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Set reusable strings
-      # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
-      id: strings
-      shell: bash
-      run: |
-        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
-
-    - name: Configure CMake
-      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
-      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
-      run: >
-        cmake -B ${{ steps.strings.outputs.build-output-dir }}
-        -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
-        -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
-        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-        -S ${{ github.workspace }}
-
-    - name: Build
-      # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
-      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
-
-    - name: Test
-      working-directory: ${{ steps.strings.outputs.build-output-dir }}
-      # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: ctest --build-config ${{ matrix.build_type }}

From ba2d03e57015252e59b6f29c8ba743c90e489d8d Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:26:37 +0800
Subject: [PATCH 08/11] =?UTF-8?q?=E4=BF=AE=E5=A4=8Dwindows-msvc=EF=BC=8Cma?=
 =?UTF-8?q?cos=E7=BC=96=E8=AF=91=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/build.yml | 1 -
 interpreter/interpreter.cpp | 8 ++------
 interpreter/module.cpp      | 6 +++---
 3 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 935d2830..fc9abff5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -72,7 +72,6 @@ jobs:
           echo "Building with ${{ matrix.compiler }}..."
           ${{ matrix.compiler }} --version
           
-          # 编译命令中添加了module.cpp
           ${{ matrix.compiler }} -std=c++17 -O2 -Wall -Wextra \
             main.cpp lexer.cpp parser.cpp interpreter.cpp module.cpp \
             -o lamina${{ matrix.os == 'windows-latest' && '.exe' || '' }}
diff --git a/interpreter/interpreter.cpp b/interpreter/interpreter.cpp
index 151340cd..b3f602c3 100644
--- a/interpreter/interpreter.cpp
+++ b/interpreter/interpreter.cpp
@@ -12,17 +12,12 @@
 #include <cstdlib> // For std::exit
 #include <cstring> // For strcmp
 #ifdef _WIN32
-// 平台相关头文件
-#ifdef _WIN32
 #include <windows.h>
 #include <io.h>
 #include <direct.h>
-
-#else
+#elif __linux__
 #include <limits.h>
 #include <unistd.h>
-#endif
-#else
 #include <unistd.h> // For isatty
 #include <cstdlib>  // For getenv
 #include <dlfcn.h>
@@ -30,6 +25,7 @@
 #endif
 
 
+
 // 这些异常类已经移到了 interpreter.hpp
 
 // Scope stack operations
diff --git a/interpreter/module.cpp b/interpreter/module.cpp
index b25ca591..5e85cd39 100644
--- a/interpreter/module.cpp
+++ b/interpreter/module.cpp
@@ -33,8 +33,8 @@ void* ModuleLoader::findSymbol(const std::string& symbolName) {
         std::cerr << "Error looking up symbol '" << symbolName << "': " << dlsym_error << std::endl;
         return nullptr;
     }
-    return symbol;
 #endif
+    return symbol;
 }
 
 bool ModuleLoader::isLoaded() const {
@@ -84,7 +84,7 @@ std::vector<ModuleLoader::EntryFunction> ModuleLoader::findEntryFunctions() {
             }
         }
     }
-
-    return entryFunctions;
 #endif
+    return entryFunctions;
+
 }
\ No newline at end of file

From 5e04b2914facd2bfe2465c989d7e8cea0a78114c Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:30:44 +0800
Subject: [PATCH 09/11] =?UTF-8?q?=E4=BF=AE=E5=A4=8Dmodule.cpp=E7=BC=96?=
 =?UTF-8?q?=E8=AF=91=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 interpreter/module.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/interpreter/module.cpp b/interpreter/module.cpp
index 5e85cd39..3721a809 100644
--- a/interpreter/module.cpp
+++ b/interpreter/module.cpp
@@ -33,8 +33,11 @@ void* ModuleLoader::findSymbol(const std::string& symbolName) {
         std::cerr << "Error looking up symbol '" << symbolName << "': " << dlsym_error << std::endl;
         return nullptr;
     }
-#endif
     return symbol;
+
+#else
+    return nullptr;
+#endif
 }
 
 bool ModuleLoader::isLoaded() const {
@@ -84,7 +87,8 @@ std::vector<ModuleLoader::EntryFunction> ModuleLoader::findEntryFunctions() {
             }
         }
     }
-#endif
     return entryFunctions;
-
+#else
+    return nullptr;
+#endif
 }
\ No newline at end of file

From d8ee21e0c80b4f8b8eee1e97fedccb736f7c0ef9 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:34:37 +0800
Subject: [PATCH 10/11] =?UTF-8?q?=E7=BB=A7=E7=BB=AD=E5=B0=9D=E8=AF=95?=
 =?UTF-8?q?=E4=BF=AE=E5=A4=8DMACOS=EF=BC=8CWIN=E5=B9=B3=E5=8F=B0=E4=B8=8B?=
 =?UTF-8?q?=E7=9A=84=E7=BC=96=E8=AF=91=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 interpreter/interpreter.cpp |  6 ++++++
 interpreter/module.cpp      | 13 +++++--------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/interpreter/interpreter.cpp b/interpreter/interpreter.cpp
index b3f602c3..ad74e6f2 100644
--- a/interpreter/interpreter.cpp
+++ b/interpreter/interpreter.cpp
@@ -22,6 +22,12 @@
 #include <cstdlib>  // For getenv
 #include <dlfcn.h>
 #include <link.h>
+#else
+#include <limits.h>
+#include <unistd.h>
+#include <unistd.h> // For isatty
+#include <cstdlib>  // For getenv
+#include <dlfcn.h>
 #endif
 
 
diff --git a/interpreter/module.cpp b/interpreter/module.cpp
index 3721a809..05e2b1d3 100644
--- a/interpreter/module.cpp
+++ b/interpreter/module.cpp
@@ -22,22 +22,20 @@ ModuleLoader::~ModuleLoader() {
 }
 
 void* ModuleLoader::findSymbol(const std::string& symbolName) {
+    void* symbol = nullptr;
 #ifdef __linux__
     if (!m_handle) {
         return nullptr;
     }
     dlerror();
-    void* symbol = dlsym(m_handle, symbolName.c_str());
+    symbol = dlsym(m_handle, symbolName.c_str());
     const char* dlsym_error = dlerror();
     if (dlsym_error) {
         std::cerr << "Error looking up symbol '" << symbolName << "': " << dlsym_error << std::endl;
         return nullptr;
     }
-    return symbol;
-
-#else
-    return nullptr;
 #endif
+    return symbol;
 }
 
 bool ModuleLoader::isLoaded() const {
@@ -45,8 +43,8 @@ bool ModuleLoader::isLoaded() const {
 }
 
 std::vector<ModuleLoader::EntryFunction> ModuleLoader::findEntryFunctions() {
-#ifdef __linux__
     std::vector<EntryFunction> entryFunctions;
+#ifdef __linux__
     if (!m_handle) {
         return entryFunctions;
     }
@@ -88,7 +86,6 @@ std::vector<ModuleLoader::EntryFunction> ModuleLoader::findEntryFunctions() {
         }
     }
     return entryFunctions;
-#else
-    return nullptr;
 #endif
+    return entryFunctions;
 }
\ No newline at end of file

From 27e8ea73f4776d58a7c986283a12e8830b6714b9 Mon Sep 17 00:00:00 2001
From: Ange1PLSGreet <663267554@qq.com>
Date: Wed, 30 Jul 2025 02:40:53 +0800
Subject: [PATCH 11/11] =?UTF-8?q?=E7=BB=A7=E7=BB=AD=E4=BF=AE=E6=94=B9CI?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/ci.yml | 188 +++++++++++++++++++--------------------
 1 file changed, 94 insertions(+), 94 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 92977811..ec1326fe 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -9,97 +9,97 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y build-essential g++
-        
-    - name: Compile Lamina
-      working-directory: interpreter
-      run: |
-        echo "Compiling Lamina interpreter..."
-        g++ -std=c++17 -Wall -Wextra -O2 \
-          main.cpp lexer.cpp parser.cpp interpreter.cpp \
-          -o lamina
-        echo " Compilation successful!"
-        
-    - name: Basic functionality test
-      working-directory: interpreter
-      run: |
-        echo "Running basic tests..."
-        
-        # Test 1: Hello World
-        echo 'print("Hello, Lamina!");' > test1.lm
-        ./lamina test1.lm
-        
-        # Test 2: Basic arithmetic
-        echo 'var x = 2 + 3 * 4;' > test2.lm
-        echo 'print("2 + 3 * 4 =", x);' >> test2.lm
-        ./lamina test2.lm
-        
-        # Test 3: Precise fractions
-        echo 'var fraction = 16 / 9;' > test3.lm
-        echo 'print("16/9 =", fraction);' >> test3.lm
-        ./lamina test3.lm
-        
-        # Test 4: Functions
-        echo 'func add(a, b) { return a + b; }' > test4.lm
-        echo 'var result = add(10, 20);' >> test4.lm
-        echo 'print("add(10, 20) =", result);' >> test4.lm
-        ./lamina test4.lm
-        
-        # Test 5: Include statement syntax (should show error for old syntax)
-        echo 'include test_module;' > test5.lm
-        echo 'print("This should not execute");' >> test5.lm
-        if ./lamina test5.lm 2>&1 | grep -q "Include statement requires a quoted string"; then
-          echo " Include syntax enforcement working correctly"
-        else
-          echo "❌ Include syntax enforcement failed"
-          exit 1
-        fi
-        
-        # Test 6: Correct include syntax (should parse correctly)
-        echo 'print("Testing correct include syntax");' > test6.lm
-        echo 'include "nonexistent";' >> test6.lm
-        if ./lamina test6.lm 2>&1 | grep -q "Cannot load module"; then
-          echo " Correct include syntax parsing working"
-        else
-          echo "❌ Correct include syntax parsing failed"
-          exit 1
-        fi
-        
-        echo " All basic tests passed!"
-        
-    - name: Test example programs
-      working-directory: interpreter
-      run: |
-        echo "Testing example programs..."
-        
-        if [ -d "examples" ]; then
-          for example in examples/*.lm; do
-            if [ -f "$example" ]; then
-              echo "Testing $(basename "$example")..."
-              ./lamina "$example" || echo "⚠️  Warning: $example execution failed"
-            fi
-          done
-        else
-          echo "ℹ️  No examples directory found"
-        fi
-        
-    - name: Check for memory leaks (with valgrind)
-      working-directory: interpreter
-      run: |
-        echo "Installing valgrind for memory leak detection..."
-        sudo apt-get install -y valgrind
-        
-        echo "Running memory leak test..."
-        echo 'var x = 42; print("x =", x);' > memtest.lm
-        
-        if valgrind --leak-check=full --error-exitcode=1 ./lamina memtest.lm 2>&1; then
-          echo " No memory leaks detected"
-        else
-          echo "⚠️  Memory leaks detected, but continuing..."
-        fi
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential g++
+
+      - name: Compile Lamina
+        working-directory: interpreter
+        run: |
+          echo "Compiling Lamina interpreter..."
+          g++ -std=c++17 -Wall -Wextra -O2 \
+            main.cpp lexer.cpp parser.cpp interpreter.cpp module.cpp \
+            -o lamina
+          echo " Compilation successful!"
+
+      - name: Basic functionality test
+        working-directory: interpreter
+        run: |
+          echo "Running basic tests..."
+          
+          # Test 1: Hello World
+          echo 'print("Hello, Lamina!");' > test1.lm
+          ./lamina test1.lm
+          
+          # Test 2: Basic arithmetic
+          echo 'var x = 2 + 3 * 4;' > test2.lm
+          echo 'print("2 + 3 * 4 =", x);' >> test2.lm
+          ./lamina test2.lm
+          
+          # Test 3: Precise fractions
+          echo 'var fraction = 16 / 9;' > test3.lm
+          echo 'print("16/9 =", fraction);' >> test3.lm
+          ./lamina test3.lm
+          
+          # Test 4: Functions
+          echo 'func add(a, b) { return a + b; }' > test4.lm
+          echo 'var result = add(10, 20);' >> test4.lm
+          echo 'print("add(10, 20) =", result);' >> test4.lm
+          ./lamina test4.lm
+          
+          # Test 5: Include statement syntax (should show error for old syntax)
+          echo 'include test_module;' > test5.lm
+          echo 'print("This should not execute");' >> test5.lm
+          if ./lamina test5.lm 2>&1 | grep -q "Include statement requires a quoted string"; then
+            echo " Include syntax enforcement working correctly"
+          else
+            echo "❌ Include syntax enforcement failed"
+            exit 1
+          fi
+          
+          # Test 6: Correct include syntax (should parse correctly)
+          echo 'print("Testing correct include syntax");' > test6.lm
+          echo 'include "nonexistent";' >> test6.lm
+          if ./lamina test6.lm 2>&1 | grep -q "Cannot load module"; then
+            echo " Correct include syntax parsing working"
+          else
+            echo "❌ Correct include syntax parsing failed"
+            exit 1
+          fi
+          
+          echo " All basic tests passed!"
+
+      - name: Test example programs
+        working-directory: interpreter
+        run: |
+          echo "Testing example programs..."
+          
+          if [ -d "examples" ]; then
+            for example in examples/*.lm; do
+              if [ -f "$example" ]; then
+                echo "Testing $(basename "$example")..."
+                ./lamina "$example" || echo "⚠️  Warning: $example execution failed"
+              fi
+            done
+          else
+            echo "ℹ️  No examples directory found"
+          fi
+
+      - name: Check for memory leaks (with valgrind)
+        working-directory: interpreter
+        run: |
+          echo "Installing valgrind for memory leak detection..."
+          sudo apt-get install -y valgrind
+          
+          echo "Running memory leak test..."
+          echo 'var x = 42; print("x =", x);' > memtest.lm
+          
+          if valgrind --leak-check=full --error-exitcode=1 ./lamina memtest.lm 2>&1; then
+            echo " No memory leaks detected"
+          else
+            echo "⚠️  Memory leaks detected, but continuing..."
+          fi