refactor: 拆分Environment和Inter

include/core/aFuncore.h

@@ -5,6 +5,7 @@
 #include "core-message.h"
 #include "core-message-stream.h"
 #include "env-var.h"
+#include "environment.h"
 #include "inter.h"
 #include "object.h"
 #include "core-activation.h"

include/core/environment.h

@@ -0,0 +1,46 @@
+#ifndef AFUN_ENVIRONMENT_H
+#define AFUN_ENVIRONMENT_H
+#include <list>
+#include <mutex>
+#include "aFunCoreExport.h"
+#include "aFuntool.h"
+#include "env-var.h"
+#include "core-activation.h"
+#include "object.h"
+
+namespace aFuncore {
+    class Inter;
+
+    class AFUN_CORE_EXPORT Environment {
+        friend class Object;
+        friend class Inter;
+
+    public:
+        explicit Environment(int argc = 0, char **argv = nullptr);
+        ~Environment() noexcept(false);
+        Environment(Environment &) = delete;
+        Environment &operator=(Environment &) = delete;
+
+        AFUN_INLINE size_t operator++();
+        AFUN_INLINE size_t operator--();
+        AFUN_INLINE size_t operator++(int);
+        AFUN_INLINE size_t operator--(int);
+
+        [[nodiscard]] AFUN_INLINE EnvVarSpace &getEnvVarSpace();
+    private:
+        std::mutex lock;
+        size_t reference;  // 引用计数
+        bool destruct;
+        std::list<Object *> gc;
+        Inter &gc_inter;  /* 需要在lock和reference后初始化 */
+        std::thread gc_thread;
+        void gcThread();
+
+    protected:  // 位于 mutex 之下
+        EnvVarSpace &env_var;
+    };
+}
+
+
+#include "environment.inline.h"
+#endif //AFUN_ENVIRONMENT_H

include/core/environment.inline.h

@@ -0,0 +1,11 @@
+#ifndef AFUN_ENVIRONMENT_INLINE_H
+#define AFUN_ENVIRONMENT_INLINE_H
+#include "environment.h"
+
+namespace aFuncore {
+    EnvVarSpace &Environment::getEnvVarSpace() {
+        return env_var;
+    }
+}
+
+#endif //AFUN_ENVIRONMENT_INLINE_H

include/core/inter.h

@@ -9,39 +9,11 @@
 #include "core-message-stream.h"
 #include "core-activation.h"
 #include "object.h"
+#include "environment.h"
 
 namespace aFuncore {
     class Inter;
 
-    class AFUN_CORE_EXPORT Environment {
-        friend class Object;
-        friend class Inter;
-
-    public:
-        explicit Environment(int argc = 0, char **argv = nullptr);
-        ~Environment() noexcept(false);
-        Environment(Environment &) = delete;
-        Environment &operator=(Environment &) = delete;
-
-        AFUN_INLINE size_t operator++();
-        AFUN_INLINE size_t operator--();
-        AFUN_INLINE size_t operator++(int);
-        AFUN_INLINE size_t operator--(int);
-
-        [[nodiscard]] AFUN_INLINE EnvVarSpace &getEnvVarSpace();
-    private:
-        std::mutex lock;
-        size_t reference;  // 引用计数
-        bool destruct;
-        std::list<Object *> gc;
-        Inter &gc_inter;  /* 需要在lock和reference后初始化 */
-        std::thread gc_thread;
-        void gcThread();
-
-    protected:  // 位于 mutex 之下
-        EnvVarSpace &env_var;
-    };
-
     class AFUN_CORE_EXPORT Inter {
         friend class Activation;
 

include/core/inter.inline.h

@@ -3,10 +3,6 @@
 #include "inter.h"
 
 namespace aFuncore {
-    EnvVarSpace &Environment::getEnvVarSpace() {
-        return env_var;
-    }
-
     Environment &Inter::getEnvironment() {
         return env;
     }

src/core/environment.cpp

@@ -0,0 +1,68 @@
+#include "inter.h"
+#include "object.h"
+#include "environment.h"
+#include "core-exception.h"
+
+namespace aFuncore {
+    void Environment::gcThread() {
+        while(true) {
+            std::queue<Object *> del;
+            std::queue<Object *> des;
+            {
+                std::unique_lock<std::mutex> mutex{lock};
+                if (destruct)
+                    break;
+                Object::checkReachable(gc);
+                Object::setReachable(gc, des, del);
+            }
+            Object::deleteUnreachable(del);
+            Object::destructUnreachable(des, gc_inter);
+
+            int32_t intervals = 1000;
+            env_var.findNumber("sys:gc-intervals", intervals);
+            if (intervals < 100)
+                intervals = 100;
+            std::this_thread::sleep_for(std::chrono::milliseconds(intervals));
+        }
+
+        Object::destructAll(gc, gc_inter); /* 不需要mutex锁 */
+    }
+
+    Environment::Environment(int argc, char **argv)
+            : reference{0}, destruct{false}, gc_inter{*(new Inter(*this))}, env_var{*new EnvVarSpace()} {
+        /* 生成 gc_inter 后, reference == 1 */
+
+        env_var.setNumber("sys:gc-intervals", 1000);
+        env_var.setNumber("sys:exit-code", 0);
+        env_var.setNumber("sys:argc", argc);
+        for (int i = 0; i < argc; i++) {
+            char buf[20];
+            snprintf(buf, 10, "sys:arg%d", i);
+            env_var.setString(buf, argv[i]);
+        }
+
+        gc_thread = std::thread([this](){this->gcThread();});
+    }
+
+    Environment::~Environment() noexcept(false) {
+        {   /* 使用互斥锁, 防止与gc线程出现不同步的情况 */
+            std::unique_lock<std::mutex> mutex{lock};
+            if (reference != 1)  // gc_inter 有一个引用
+                throw EnvironmentDestructException();
+
+            if (destruct)
+                return;
+
+            destruct = true;
+        }
+
+        gc_thread.join();
+        delete &gc_inter;
+        delete &env_var;
+
+        Object::deleteAll(gc); /* 不需要mutex锁 */
+
+        if (reference != 0)
+            throw EnvironmentDestructException();
+    }
+}

src/core/inter.cpp

@@ -1,9 +1,7 @@
 #include "inter.h"
 #include "core-activation.h"
 #include "core-logger.h"
-#include "core-message-stream.h"
 #include "core-exception.h"
-#include "object.h"
 
 namespace aFuncore {
     Inter::Inter(Environment &env_)
@@ -122,66 +120,4 @@ namespace aFuncore {
         }
         return true;
     }
-
-    void Environment::gcThread() {
-        while(true) {
-            std::queue<Object *> del;
-            std::queue<Object *> des;
-            {
-                std::unique_lock<std::mutex> mutex{lock};
-                if (destruct)
-                    break;
-                Object::checkReachable(gc);
-                Object::setReachable(gc, des, del);
-            }
-            Object::deleteUnreachable(del);
-            Object::destructUnreachable(des, gc_inter);
-
-            int32_t intervals = 1000;
-            env_var.findNumber("sys:gc-intervals", intervals);
-            if (intervals < 100)
-                intervals = 100;
-            std::this_thread::sleep_for(std::chrono::milliseconds(intervals));
-        }
-
-        Object::destructAll(gc, gc_inter); /* 不需要mutex锁 */
-    }
-
-    Environment::Environment(int argc, char **argv)
-        : reference{0}, destruct{false}, gc_inter{*(new Inter(*this))}, env_var{*new EnvVarSpace()} {
-        /* 生成 gc_inter 后, reference == 1 */
-
-        env_var.setNumber("sys:gc-intervals", 1000);
-        env_var.setNumber("sys:exit-code", 0);
-        env_var.setNumber("sys:argc", argc);
-        for (int i = 0; i < argc; i++) {
-            char buf[20];
-            snprintf(buf, 10, "sys:arg%d", i);
-            env_var.setString(buf, argv[i]);
-        }
-
-        gc_thread = std::thread([this](){this->gcThread();});
-    }
-
-    Environment::~Environment() noexcept(false) {
-        {   /* 使用互斥锁, 防止与gc线程出现不同步的情况 */
-            std::unique_lock<std::mutex> mutex{lock};
-            if (reference != 1)  // gc_inter 有一个引用
-                throw EnvironmentDestructException();
-
-            if (destruct)
-                return;
-
-            destruct = true;
-        }
-
-        gc_thread.join();
-        delete &gc_inter;
-        delete &env_var;
-
-        Object::deleteAll(gc); /* 不需要mutex锁 */
-
-        if (reference != 0)
-            throw EnvironmentDestructException();
-    }
 }