refactor & feat: 整合Object, Var和VarSpace

include/core/aFuncore.h

@@ -4,11 +4,11 @@
 #include "init.h"
 #include "code.h"
 #include "inter.h"
-#include "gc.h"
+#include "object.h"
 #include "msg.h"
 #include "env-var.h"
-#include "value.h"
-#include "var.h"
+#include "object-value.h"
+#include "varlist.h"
 #include "core-activation.h"
 #include "core-exception.h"
 

include/core/core-activation.h

@@ -4,8 +4,8 @@
 #include "aFunCoreExport.h"
 #include "msg.h"
 #include "code.h"
-#include "value.h"
-#include "var.h"
+#include "object-value.h"
+#include "varlist.h"
 
 namespace aFuncore {
     class Inter;

include/core/gc.h

@@ -1,48 +0,0 @@
-#ifndef AFUN_GC_H
-#define AFUN_GC_H
-#include <queue>
-#include <list>
-#include "aFuntool.h"
-#include "aFunCoreExport.h"
-
-namespace aFuncore {
-    typedef unsigned GcCount;
-    class Inter;
-
-    class AFUN_CORE_EXPORT GcObjectBase {
-    public:
-        GcObjectBase(const GcObjectBase &) = delete;
-        GcObjectBase &operator=(const GcObjectBase &) = delete;
-
-        inline void addReference();
-        inline void delReference();
-        [[nodiscard]] inline GcCount getReference() const;
-        inline void setClear(bool clear=false);
-
-        static void checkReachable(std::list<GcObjectBase *> &list);
-        static void setReachable(std::list<GcObjectBase *> &list, std::queue<GcObjectBase *> &des, std::queue<GcObjectBase *> &del);
-        static void destructUnreachable(std::queue<GcObjectBase *> &des, Inter &gc_inter);
-        static void deleteUnreachable(std::queue<GcObjectBase *> &del);
-        static void destructAll(std::list<GcObjectBase *> &list, Inter &gc_inter);
-        static void deleteAll(std::list<GcObjectBase *> &list);
-    protected:
-        std::mutex lock;
-
-        inline GcObjectBase();
-        virtual ~GcObjectBase() = default;
-
-        virtual void destruct(Inter &gc_inter);
-        virtual void linkObject(std::queue<GcObjectBase *> &queue);
-
-    private:
-        bool done_destruct;
-        bool not_clear;  // 不清除
-        bool reachable;  // 可达标记 [同时标识已迭代]
-        GcCount reference;  // 引用计数
-    };
-
-};
-
-#include "gc.inline.h"
-
-#endif //AFUN_GC_H

include/core/gc.inline.h

@@ -1,29 +0,0 @@
-#ifndef AFUN_GC_INLINE_H
-#define AFUN_GC_INLINE_H
-#include "gc.h"
-
-namespace aFuncore {
-    inline GcObjectBase::GcObjectBase() : not_clear{false}, reference{1}, reachable{false}, done_destruct{false} {
-
-    }
-
-    inline void GcObjectBase::addReference() {
-        std::unique_lock<std::mutex> mutex{lock};
-        reference++;
-    }
-
-    inline void GcObjectBase::delReference() {
-        std::unique_lock<std::mutex> mutex{lock};
-        reference--;
-    }
-
-    inline GcCount GcObjectBase::getReference() const {
-        return reference;
-    }
-
-    inline void GcObjectBase::setClear(bool clear) {
-        not_clear=!clear;
-    }
-}
-
-#endif //AFUN_GC_INLINE_H

include/core/inter.h

@@ -11,7 +11,7 @@
 
 namespace aFuncore {
     class Activation;
-    class GcObjectBase;
+    class Object;
     class Var;
     class ProtectVarSpace;
     class VarSpace;
@@ -40,7 +40,7 @@ namespace aFuncore {
         std::mutex lock;
         size_t reference;  // 引用计数
         bool destruct;
-        std::list<GcObjectBase *> gc;
+        std::list<Object *> gc;
         Inter &gc_inter;  /* 需要在lock和reference后初始化 */
         std::thread gc_thread;
 

include/core/var.h → include/core/object-value.h

@@ -1,33 +1,31 @@
-#ifndef AFUN_VAR_H
-#define AFUN_VAR_H
+#ifndef AFUN_OBJECT_VALUE_H
+#define AFUN_OBJECT_VALUE_H
 #include <list>
-#include <unordered_map>
 #include <mutex>
 #include "aFuntool.h"
 #include "aFunCoreExport.h"
-#include "gc.h"
+#include "object.h"
+#include "code.h"
 #include "inter.h"
 
 namespace aFuncore {
-    class Object;
-
-    class AFUN_CORE_EXPORT Var : public GcObjectBase {
+    class AFUN_CORE_EXPORT Var : public Object {
     public:
         Environment &env;
 
         Var(Object *data_, Inter &inter);
         Var(Object *data_, Environment &env_);
-        ~Var() override;
+        ~Var() override = default;
 
         [[nodiscard]] inline virtual Object *getData();
         virtual void inline setData(Object *data_);
-        void linkObject(std::queue<GcObjectBase *> &queue) override;
+        void linkObject(std::queue<Object *> &queue) override;
 
     private:
         Object *data;
     };
 
-    class AFUN_CORE_EXPORT VarSpace : public GcObjectBase {
+    class AFUN_CORE_EXPORT VarSpace : public Object {
     public:
         typedef enum VarOperationFlat {
             vof_success = 0,  // 成功
@@ -40,7 +38,7 @@ namespace aFuncore {
 
         explicit VarSpace(Inter &inter);
         explicit VarSpace(Environment &env_);
-        ~VarSpace() override;
+        ~VarSpace() override = default;
 
         template <typename Callable,typename...T>
         void forEach(Callable func, T...arg);
@@ -56,7 +54,7 @@ namespace aFuncore {
         virtual VarOperationFlat delVar(const std::string &name);
 
         [[nodiscard]] Object *findObject(const std::string &name);
-        void linkObject(std::queue<GcObjectBase *> &queue) override;
+        void linkObject(std::queue<Object *> &queue) override;
 
         static const size_t VAR_HASH_SIZE = 100;  // 环境变量哈希表大小
 
@@ -81,42 +79,45 @@ namespace aFuncore {
         bool is_protect;
     };
 
-    class AFUN_CORE_EXPORT VarList {
+    class AFUN_CORE_EXPORT Function : public virtual Object {
     public:
-        explicit inline VarList() = default;
-        explicit VarList(VarList *varlist);
-        explicit VarList(VarSpace *varspace);
-        ~VarList() = default;
-        VarList(const VarList &) = delete;
-        VarList &operator=(const VarList &) = delete;
+        class AFUN_CORE_EXPORT CallFunction;
 
-        void connect(VarList *varlist);
-        inline void push(VarSpace *varspace_);
+        virtual CallFunction *getCallFunction(const Code::ByteCode *code, Inter &inter) = 0;
+        virtual inline bool isInfix();
+    };
 
-        template <typename Callable,typename...T>
-        void forEach(Callable func, T...arg);
+    class AFUN_CORE_EXPORT Function::CallFunction {
+    public:
+        struct ArgCodeList;
 
-        template <typename Callable,typename...T>
-        void forEachLock(Callable func, T...arg);
+        CallFunction() = default;
+        virtual ~CallFunction() = default;
+        CallFunction(const CallFunction &)=delete;
+        CallFunction &operator=(const CallFunction &)=delete;
 
-        [[nodiscard]] virtual Var *findVar(const std::string &name);
-        virtual bool defineVar(const std::string &name, Object *data);
-        virtual bool defineVar(const std::string &name, Var *data);
-        virtual bool setVar(const std::string &name, Object *data);
-        virtual bool delVar(const std::string &name);
-        [[nodiscard]] inline Object *findObject(const std::string &name);
+        virtual std::list<ArgCodeList> *getArgCodeList(Inter &inter, Activation &activation, const Code::ByteCode *call) = 0;
+        virtual void runFunction() = 0;
+    };
 
-        inline void GcLinkObject(std::queue<GcObjectBase *> &queue);  /* 虽然不是GcObject, 但是也设定改函数便于将其包含的varspace快速压入queue中 */
+    struct Function::CallFunction::ArgCodeList {
+        const Code::ByteCode *code = nullptr;
+        Object *ret = nullptr;
+    };
 
-    protected:
-        std::mutex lock;
+    class AFUN_CORE_EXPORT Literaler : public virtual Object {
+    public:
+        virtual void getObject(const std::string &literal, char prefix, Inter &inter, Activation &activation) = 0;
+    };
 
-    private:
-        std::list<VarSpace *> varspace;
+    class AFUN_CORE_EXPORT CallBackVar : public virtual Object {
+    public:
+        virtual inline bool isCallBack(Inter &inter, Activation &activation);
+        virtual void callBack(Inter &inter, Activation &activation) = 0;
     };
-}
+};
 
-#include "var.inline.h"
-#include "var.template.h"
+#include "object-value.inline.h"
+#include "object-value.template.h"
 
-#endif //AFUN_VAR_H
+#endif //AFUN_OBJECT_VALUE_H

include/core/var.inline.h → include/core/object-value.inline.h

@@ -1,6 +1,6 @@
-#ifndef AFUN_VAR_INLINE_H
-#define AFUN_VAR_INLINE_H
-#include "var.h"
+#ifndef AFUN_OBJECT_VALUE_INLINE_H
+#define AFUN_OBJECT_VALUE_INLINE_H
+#include "object-value.h"
 
 namespace aFuncore {
     inline Object *Var::getData() {
@@ -39,24 +39,13 @@ namespace aFuncore {
         bool ret = is_protect; is_protect = protect; return ret;
     }
 
-    inline VarList::VarList(VarSpace *varspace) {
-        this->varspace.push_front(varspace);
+    inline bool Function::isInfix() {
+        return false;
     }
 
-    inline void VarList::push(VarSpace *varspace_) {
-        std::unique_lock<std::mutex> mutex{lock};
-        varspace.push_front(varspace_);
-    }
-
-    inline Object *VarList::findObject(const std::string &name) {
-        Var *var = findVar(name);
-        return var ? var->getData() : nullptr;
-    }
-
-    inline void VarList::GcLinkObject(std::queue<GcObjectBase *> &queue) {
-        for (auto var : varspace)
-            queue.push(var);
+    inline bool CallBackVar::isCallBack(Inter &inter, Activation &activation) {
+        return true;
     }
-}
+};
 
-#endif //AFUN_VAR_INLINE_H
+#endif //AFUN_OBJECT_VALUE_INLINE_H

include/core/object-value.template.h

@@ -0,0 +1,25 @@
+#ifndef AFUN_OBJECT_VALUE_TEMPLATE_H
+#define AFUN_OBJECT_VALUE_TEMPLATE_H
+
+#include "object-value.h"
+
+namespace aFuncore {
+    template <typename Callable, typename...T>
+    void VarSpace::forEach(Callable func, T...arg) {
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &tmp : var) {
+            mutex.unlock();
+            func(tmp.second, arg...);
+            mutex.lock();
+        }
+    }
+
+    template <typename Callable, typename...T>
+    void VarSpace::forEachLock(Callable func, T...arg) {
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &tmp : var)
+            func(tmp.second, arg...);
+    }
+}
+
+#endif //AFUN_OBJECT_VALUE_TEMPLATE_H

include/core/object.h

@@ -0,0 +1,52 @@
+#ifndef AFUN_OBJECT_H
+#define AFUN_OBJECT_H
+#include <queue>
+#include <list>
+#include "aFuntool.h"
+#include "aFunCoreExport.h"
+
+namespace aFuncore {
+    typedef unsigned GcCount;
+    class Inter;
+    class Environment;
+
+    class AFUN_CORE_EXPORT Object {
+    public:
+        Object(std::string type_, Inter &inter);
+        Object(std::string type_, Environment &env_);
+        virtual ~Object();
+        Object(const Object &) = delete;
+        Object &operator=(const Object &) = delete;
+
+        inline void addReference();
+        inline void delReference();
+        [[nodiscard]] inline GcCount getReference() const;
+        inline void setClear(bool clear=false);
+
+        static void checkReachable(std::list<Object *> &list);
+        static void setReachable(std::list<Object *> &list, std::queue<Object *> &des, std::queue<Object *> &del);
+        static void destructUnreachable(std::queue<Object *> &des, Inter &gc_inter);
+        static void deleteUnreachable(std::queue<Object *> &del);
+        static void destructAll(std::list<Object *> &list, Inter &gc_inter);
+        static void deleteAll(std::list<Object *> &list);
+    protected:
+        Environment &env;
+        const std::string type;  // 标识 Object 的字符串
+
+        std::mutex lock;
+
+        virtual void destruct(Inter &gc_inter);
+        virtual void linkObject(std::queue<Object *> &queue);
+
+    private:
+        bool done_destruct;
+        bool not_clear;  // 不清除
+        bool reachable;  // 可达标记 [同时标识已迭代]
+        GcCount reference;  // 引用计数
+    };
+
+};
+
+#include "object.inline.h"
+
+#endif //AFUN_OBJECT_H

include/core/object.inline.h

@@ -0,0 +1,25 @@
+#ifndef AFUN_OBJECT_INLINE_H
+#define AFUN_OBJECT_INLINE_H
+#include "object.h"
+
+namespace aFuncore {
+    inline void Object::addReference() {
+        std::unique_lock<std::mutex> mutex{lock};
+        reference++;
+    }
+
+    inline void Object::delReference() {
+        std::unique_lock<std::mutex> mutex{lock};
+        reference--;
+    }
+
+    inline GcCount Object::getReference() const {
+        return reference;
+    }
+
+    inline void Object::setClear(bool clear) {
+        not_clear=!clear;
+    }
+}
+
+#endif //AFUN_OBJECT_INLINE_H

include/core/value.h

@@ -1,62 +0,0 @@
-#ifndef AFUN_VALUE_H
-#define AFUN_VALUE_H
-#include <list>
-#include <mutex>
-#include "aFuntool.h"
-#include "aFunCoreExport.h"
-#include "gc.h"
-#include "code.h"
-#include "inter.h"
-
-namespace aFuncore {
-    class AFUN_CORE_EXPORT Object : public GcObjectBase {
-    public:
-        Environment &env;
-        const std::string type;  // 标识 Object 的字符串
-
-        Object(std::string type_, Inter &inter);
-        Object(std::string type_, Environment &env_);
-        ~Object() override;
-    };
-
-    class AFUN_CORE_EXPORT Function : public virtual Object {
-    public:
-        class AFUN_CORE_EXPORT CallFunction;
-
-        virtual CallFunction *getCallFunction(const Code::ByteCode *code, Inter &inter) = 0;
-        virtual inline bool isInfix();
-    };
-
-    class AFUN_CORE_EXPORT Function::CallFunction {
-    public:
-        struct ArgCodeList;
-
-        CallFunction() = default;
-        virtual ~CallFunction() = default;
-        CallFunction(const CallFunction &)=delete;
-        CallFunction &operator=(const CallFunction &)=delete;
-
-        virtual std::list<ArgCodeList> *getArgCodeList(Inter &inter, Activation &activation, const Code::ByteCode *call) = 0;
-        virtual void runFunction() = 0;
-    };
-
-    struct Function::CallFunction::ArgCodeList {
-        const Code::ByteCode *code = nullptr;
-        Object *ret = nullptr;
-    };
-
-    class AFUN_CORE_EXPORT Literaler : public virtual Object {
-    public:
-        virtual void getObject(const std::string &literal, char prefix, Inter &inter, Activation &activation) = 0;
-    };
-
-    class AFUN_CORE_EXPORT CallBackVar : public virtual Object {
-    public:
-        virtual inline bool isCallBack(Inter &inter, Activation &activation);
-        virtual void callBack(Inter &inter, Activation &activation) = 0;
-    };
-};
-
-#include "value.inline.h"
-
-#endif //AFUN_VALUE_H

include/core/value.inline.h

@@ -1,15 +0,0 @@
-#ifndef AFUN_VALUE_INLINE_H
-#define AFUN_VALUE_INLINE_H
-#include "value.h"
-
-namespace aFuncore {
-    inline bool Function::isInfix() {
-        return false;
-    }
-
-    inline bool CallBackVar::isCallBack(Inter &inter, Activation &activation) {
-        return true;
-    }
-};
-
-#endif //AFUN_VALUE_INLINE_H

include/core/var.template.h

@@ -1,40 +0,0 @@
-#ifndef AFUN_VAR_TEMPLATE_H
-#define AFUN_VAR_TEMPLATE_H
-
-namespace aFuncore {
-    template <typename Callable, typename...T>
-    void VarSpace::forEach(Callable func, T...arg) {
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &tmp : var) {
-            mutex.unlock();
-            func(tmp.second, arg...);
-            mutex.lock();
-        }
-    }
-
-    template <typename Callable, typename...T>
-    void VarSpace::forEachLock(Callable func, T...arg) {
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &tmp : var)
-            func(tmp.second, arg...);
-    }
-
-    template <typename Callable, typename...T>
-    void VarList::forEach(Callable func, T...arg) {
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &vs : varspace) {
-            mutex.unlock();
-            func(vs, arg...);
-            mutex.lock();
-        }
-    }
-
-    template <typename Callable, typename...T>
-    void VarList::forEachLock(Callable func, T...arg) {
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &vs : varspace)
-            func(vs, arg...);
-    }
-}
-
-#endif //AFUN_VAR_TEMPLATE_H

include/core/varlist.h

@@ -0,0 +1,50 @@
+#ifndef AFUN_VARLIST_H
+#define AFUN_VARLIST_H
+#include <list>
+#include <unordered_map>
+#include <mutex>
+#include "aFuntool.h"
+#include "aFunCoreExport.h"
+#include "object-value.h"
+#include "inter.h"
+
+namespace aFuncore {
+    class AFUN_CORE_EXPORT VarList {
+    public:
+        explicit inline VarList() = default;
+        explicit VarList(VarList *varlist);
+        explicit VarList(VarSpace *varspace);
+        ~VarList() = default;
+        VarList(const VarList &) = delete;
+        VarList &operator=(const VarList &) = delete;
+
+        void connect(VarList *varlist);
+        inline void push(VarSpace *varspace_);
+
+        template <typename Callable,typename...T>
+        void forEach(Callable func, T...arg);
+
+        template <typename Callable,typename...T>
+        void forEachLock(Callable func, T...arg);
+
+        [[nodiscard]] virtual Var *findVar(const std::string &name);
+        virtual bool defineVar(const std::string &name, Object *data);
+        virtual bool defineVar(const std::string &name, Var *data);
+        virtual bool setVar(const std::string &name, Object *data);
+        virtual bool delVar(const std::string &name);
+        [[nodiscard]] inline Object *findObject(const std::string &name);
+
+        inline void GcLinkObject(std::queue<Object *> &queue);  /* 虽然不是GcObject, 但是也设定改函数便于将其包含的varspace快速压入queue中 */
+
+    protected:
+        std::mutex lock;
+
+    private:
+        std::list<VarSpace *> varspace;
+    };
+}
+
+#include "varlist.inline.h"
+#include "varlist.template.h"
+
+#endif //AFUN_VARLIST_H

include/core/varlist.inline.h

@@ -0,0 +1,26 @@
+#ifndef AFUN_VARLIST_INLINE_H
+#define AFUN_VARLIST_INLINE_H
+#include "varlist.h"
+
+namespace aFuncore {
+    inline VarList::VarList(VarSpace *varspace) {
+        this->varspace.push_front(varspace);
+    }
+
+    inline void VarList::push(VarSpace *varspace_) {
+        std::unique_lock<std::mutex> mutex{lock};
+        varspace.push_front(varspace_);
+    }
+
+    inline Object *VarList::findObject(const std::string &name) {
+        Var *var = findVar(name);
+        return var ? var->getData() : nullptr;
+    }
+
+    inline void VarList::GcLinkObject(std::queue<Object *> &queue) {
+        for (auto var : varspace)
+            queue.push(var);
+    }
+}
+
+#endif //AFUN_VARLIST_INLINE_H

include/core/varlist.template.h

@@ -0,0 +1,25 @@
+#ifndef AFUN_VARLIST_TEMPLATE_H
+#define AFUN_VARLIST_TEMPLATE_H
+
+#include "varlist.h"
+
+namespace aFuncore {
+    template <typename Callable, typename...T>
+    void VarList::forEach(Callable func, T...arg) {
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &vs : varspace) {
+            mutex.unlock();
+            func(vs, arg...);
+            mutex.lock();
+        }
+    }
+
+    template <typename Callable, typename...T>
+    void VarList::forEachLock(Callable func, T...arg) {
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &vs : varspace)
+            func(vs, arg...);
+    }
+}
+
+#endif //AFUN_VARLIST_TEMPLATE_H

src/core/gc.cpp

@@ -1,76 +0,0 @@
-#include "gc.h"
-#include "inter.h"
-#include "init.h"
-
-namespace aFuncore {
-    void GcObjectBase::destructAll(std::list<GcObjectBase *>& list, Inter &gc_inter) {
-        for (auto obj : list)
-            if (!obj->done_destruct) {
-                obj->done_destruct = true;
-                obj->destruct(gc_inter);
-            }
-    }
-
-    void GcObjectBase::deleteAll(std::list<GcObjectBase *>& list) {
-        while (!list.empty())
-            delete list.front();  /* 自带pop */
-        if (!list.empty())
-            warningLog(aFunCoreLogger, "After GcObjectBase destructAll, list is not empty");
-    }
-
-    void GcObjectBase::destruct(Inter &inter) {
-        /* 什么都不做, 但virtual函数不能是inline */
-    }
-
-    void GcObjectBase::linkObject(std::queue<GcObjectBase *> &queue) {
-        /* 什么都不做, 但virtual函数不能是inline */
-    }
-
-    void GcObjectBase::checkReachable(std::list<GcObjectBase *> &list) {
-        std::queue<GcObjectBase *> queue;
-
-        for (auto *obj : list) {
-            obj->reachable = false;
-            if (obj->reference > 0 || obj->not_clear)
-                queue.push(obj);
-        }
-
-        while (!queue.empty()) {
-            auto obj = queue.front();
-            if (!obj->reachable) {
-                obj->reachable = true;
-                obj->linkObject(queue);
-            }
-            queue.pop();
-        }
-    }
-
-    void GcObjectBase::setReachable(std::list<GcObjectBase *> &list, std::queue<GcObjectBase *> &des,
-                                    std::queue<GcObjectBase *> &del) {
-        for (auto *obj : list) {
-            if (!obj->reachable) {
-                if (obj->done_destruct)
-                    del.push(obj);
-                else
-                    des.push(obj);
-            }
-        }
-    }
-
-    void GcObjectBase::destructUnreachable(std::queue<GcObjectBase *> &des, Inter &gc_inter) {
-        while (!des.empty()) {
-            auto obj = des.front();
-            obj->done_destruct = true;
-            obj->destruct(gc_inter);
-            des.pop();
-        }
-    }
-
-    void GcObjectBase::deleteUnreachable(std::queue<GcObjectBase *> &del) {
-        while (!del.empty()) {
-            auto obj = del.front();
-            del.pop();
-            delete obj;
-        }
-    }
-}

src/core/inter.cpp

@@ -173,21 +173,21 @@ namespace aFuncore {
 
     void Environment::gcThread() {
         while(true) {
-            std::queue<GcObjectBase *> del;
-            std::queue<GcObjectBase *> des;
+            std::queue<Object *> del;
+            std::queue<Object *> des;
             {
                 std::unique_lock<std::mutex> mutex{lock};
                 if (destruct)
                     break;
-                GcObjectBase::checkReachable(gc);
-                GcObjectBase::setReachable(gc, des, del);
+                Object::checkReachable(gc);
+                Object::setReachable(gc, des, del);
             }
-            GcObjectBase::deleteUnreachable(del);
-            GcObjectBase::destructUnreachable(des, gc_inter);
+            Object::deleteUnreachable(del);
+            Object::destructUnreachable(des, gc_inter);
             aFuntool::safeSleep(1);
         }
 
-        GcObjectBase::destructAll(gc, gc_inter); /* 不需要mutex锁 */
+        Object::destructAll(gc, gc_inter); /* 不需要mutex锁 */
     }
 
     Environment::Environment(int argc, char **argv)
@@ -231,7 +231,7 @@ namespace aFuncore {
         protect->delReference();
         global->delReference();
 
-        GcObjectBase::deleteAll(gc); /* 不需要mutex锁 */
+        Object::deleteAll(gc); /* 不需要mutex锁 */
 
         if (reference != 0)
             throw EnvironmentDestructException();

src/core/object-value.cpp

@@ -0,0 +1,155 @@
+#include "object-value.h"
+#include "inter.h"
+#include "init.h"
+
+namespace aFuncore {
+    Var::Var(Object *data_, Inter &inter) : Object("Var", inter), data{data_}, env{inter.getEnvironment()}{
+
+    }
+
+    Var::Var(Object *data_, Environment &env_) : Object("Var", env_), data{data_}, env{env_}{
+
+    }
+
+
+    VarSpace::VarSpace(Inter &inter) : Object("VarSpace", inter), env{inter.getEnvironment()}{
+
+    }
+
+    VarSpace::VarSpace(Environment &env_) : Object("VarSpace", env_), env{env_}{
+
+    }
+
+    void Var::linkObject(std::queue<Object *> &queue) {
+        queue.push(getData());
+    }
+
+    /**
+     * 访问指定变量
+     * @param name 变量名
+     * @return
+     */
+    Var *VarSpace::findVar(const std::string &name){
+        std::unique_lock<std::mutex> mutex{lock};
+        auto v = var.find(name);
+        if (v == var.end())
+            return nullptr;
+        return v->second;
+    }
+
+    /**
+     * 定义变量
+     * @param name 变量名
+     * @param data 变量（Object）
+     * @return
+     */
+    VarSpace::VarOperationFlat VarSpace::defineVar(const std::string &name, Object *data) {
+        std::unique_lock<std::mutex> mutex{lock};
+        if (var.find(name) != var.end())
+            return vof_redefine_var;
+        auto new_var = new Var(data, env);
+        var.emplace(name, new_var);
+        new_var->delReference();
+        return vof_success;
+    }
+
+    /**
+     * 定义变量
+     * @param name 变量名
+     * @param data 变量（Var）
+     * @return
+     */
+    VarSpace::VarOperationFlat VarSpace::defineVar(const std::string &name, Var *data){
+        std::unique_lock<std::mutex> mutex{lock};
+        if (var.find(name) != var.end())
+            return vof_redefine_var;
+        var.emplace(name, data);
+        return vof_success;
+    }
+
+    /**
+     * 设定变量的值
+     * @param name 变量名
+     * @param data 变量
+     * @return
+     */
+    VarSpace::VarOperationFlat VarSpace::setVar(const std::string &name, Object *data){
+        std::unique_lock<std::mutex> mutex{lock};
+        auto v = var.find(name);
+        if (v == var.end())
+            return vof_not_var;
+        v->second->setData(data);
+        return vof_success;
+    }
+
+    /**
+     * 删除变量
+     * @param name 变量名
+     * @return
+     */
+    VarSpace::VarOperationFlat VarSpace::delVar(const std::string &name){
+        std::unique_lock<std::mutex> mutex{lock};
+        auto v = var.find(name);
+        if (v == var.end())
+            return vof_not_var;
+        var.erase(v);
+        return vof_success;
+    }
+
+    void VarSpace::linkObject(std::queue<Object *> &queue) {
+        for (auto tmp : var)
+            queue.push(tmp.second);
+    }
+
+    /**
+     * 定义变量
+     * 若启用保护且变量名存在，则返回错误redefine
+     * 若启用保护则返回错误fail
+     * @param name 变量名
+     * @param data 变量（Object）
+     * @return
+     */
+    VarSpace::VarOperationFlat ProtectVarSpace::defineVar(const std::string &name, Object *data){
+        return VarSpace::defineVar(name, data);
+    }
+
+    /**
+     * 定义变量
+     * 若启用保护且变量名存在，则返回错误redefine
+     * 若启用保护则返回错误fail
+     * @param name 变量名
+     * @param data 变量（Var）
+     * @return
+     */
+    VarSpace::VarOperationFlat ProtectVarSpace::defineVar(const std::string &name, Var *data){
+        return VarSpace::defineVar(name, data);
+    }
+
+    /**
+     * 设定变量的值
+     * 若启用保护且变量名存在，则返回错误fail
+     * 若启用保护则返回错误 not_var
+     * @param name 变量名
+     * @param data 变量（Var）
+     * @return
+     */
+    VarSpace::VarOperationFlat ProtectVarSpace::setVar(const std::string &name, Object *data){
+        if (is_protect)
+            return findVar(name) ? vof_fail : vof_not_var;
+        return VarSpace::setVar(name, data);
+    }
+
+    /**
+     * 删除变量
+     * 若启用保护且变量名存在，则返回错误fail
+     * 若启用保护则返回错误 not_var
+     * @param name 变量名
+     * @param data 变量（Var）
+     * @return
+     */
+    VarSpace::VarOperationFlat ProtectVarSpace::delVar(const std::string &name){
+        if (is_protect)
+            return findVar(name) ? vof_fail : vof_not_var;
+        return VarSpace::delVar(name);
+    }
+}

src/core/object.cpp

@@ -0,0 +1,97 @@
+#include "object.h"
+#include "inter.h"
+#include "init.h"
+
+namespace aFuncore {
+    Object::Object(std::string type_, Inter &inter)
+        : not_clear{false}, reference{1}, reachable{false}, done_destruct{false},
+          type{std::move(type_)}, env{inter.getEnvironment()}{
+        std::unique_lock<std::mutex> mutex{env.lock};
+        env.gc.push_back(this);
+    }
+
+    Object::Object(std::string type_, Environment &env_)
+        : not_clear{false}, reference{1}, reachable{false}, done_destruct{false},
+          type{std::move(type_)}, env{env_}{
+        std::unique_lock<std::mutex> mutex{env.lock};
+        env.gc.push_back(this);
+    }
+
+    Object::~Object() {
+        if (reference != 0)
+            warningLog(aFunCoreLogger, "Object %p destruct reference: %d", this, getReference());
+        std::unique_lock<std::mutex> mutex{env.lock};
+        env.gc.remove(this);
+    }
+
+    void Object::destructAll(std::list<Object *>& list, Inter &gc_inter) {
+        for (auto obj : list)
+            if (!obj->done_destruct) {
+                obj->done_destruct = true;
+                obj->destruct(gc_inter);
+            }
+    }
+
+    void Object::deleteAll(std::list<Object *>& list) {
+        while (!list.empty())
+            delete list.front();  /* 自带pop */
+        if (!list.empty())
+            warningLog(aFunCoreLogger, "After Object destructAll, list is not empty");
+    }
+
+    void Object::destruct(Inter &inter) {
+        /* 什么都不做, 但virtual函数不能是inline */
+    }
+
+    void Object::linkObject(std::queue<Object *> &queue) {
+        /* 什么都不做, 但virtual函数不能是inline */
+    }
+
+    void Object::checkReachable(std::list<Object *> &list) {
+        std::queue<Object *> queue;
+
+        for (auto *obj : list) {
+            obj->reachable = false;
+            if (obj->reference > 0 || obj->not_clear)
+                queue.push(obj);
+        }
+
+        while (!queue.empty()) {
+            auto obj = queue.front();
+            if (!obj->reachable) {
+                obj->reachable = true;
+                obj->linkObject(queue);
+            }
+            queue.pop();
+        }
+    }
+
+    void Object::setReachable(std::list<Object *> &list, std::queue<Object *> &des,
+                                    std::queue<Object *> &del) {
+        for (auto *obj : list) {
+            if (!obj->reachable) {
+                if (obj->done_destruct)
+                    del.push(obj);
+                else
+                    des.push(obj);
+            }
+        }
+    }
+
+    void Object::destructUnreachable(std::queue<Object *> &des, Inter &gc_inter) {
+        while (!des.empty()) {
+            auto obj = des.front();
+            obj->done_destruct = true;
+            obj->destruct(gc_inter);
+            des.pop();
+        }
+    }
+
+    void Object::deleteUnreachable(std::queue<Object *> &del) {
+        while (!del.empty()) {
+            auto obj = del.front();
+            del.pop();
+            delete obj;
+        }
+    }
+}

src/core/value.cpp

@@ -1,24 +0,0 @@
-#include "value.h"
-#include "inter.h"
-#include "init.h"
-
-namespace aFuncore {
-    Object::Object(std::string type_, Inter &inter)
-            : type{std::move(type_)}, env{inter.getEnvironment()}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-
-    Object::Object(std::string type_, Environment &env_)
-            : type{std::move(type_)}, env{env_}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-
-    Object::~Object() {
-        if (getReference() != 0)
-            warningLog(aFunCoreLogger, "Object %p destruct reference: %d", this, getReference());
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.remove(this);
-    }
-}

src/core/var.cpp

@@ -1,280 +0,0 @@
-#include "var.h"
-#include "value.h"
-#include "inter.h"
-#include "init.h"
-
-namespace aFuncore {
-    Var::Var(Object *data_, Inter &inter) : data{data_}, env{inter.getEnvironment()}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-    
-    Var::Var(Object *data_, Environment &env_) : data{data_}, env{env_}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-
-    Var::~Var() {
-        if (getReference() != 0)
-            warningLog(aFunCoreLogger, "Var %p destruct reference: %d", this, getReference());
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.remove(this);
-    }
-    
-    VarSpace::VarSpace(Inter &inter) : env{inter.getEnvironment()}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-    
-    VarSpace::VarSpace(Environment &env_) : env{env_}{
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.push_back(this);
-    }
-
-    VarSpace::~VarSpace() {
-        if (getReference() != 0)
-            warningLog(aFunCoreLogger, "VarSpace %p destruct reference: %d", this, getReference());
-        std::unique_lock<std::mutex> mutex{env.lock};
-        env.gc.remove(this);
-    }
-
-    void Var::linkObject(std::queue<GcObjectBase *> &queue) {
-        queue.push(getData());
-    }
-
-    /**
-     * 访问指定变量
-     * @param name 变量名
-     * @return
-     */
-    Var *VarSpace::findVar(const std::string &name){
-        std::unique_lock<std::mutex> mutex{lock};
-        auto v = var.find(name);
-        if (v == var.end())
-            return nullptr;
-        return v->second;
-    }
-    
-    /**
-     * 定义变量
-     * @param name 变量名
-     * @param data 变量（Object）
-     * @return
-     */
-    VarSpace::VarOperationFlat VarSpace::defineVar(const std::string &name, Object *data) {
-        std::unique_lock<std::mutex> mutex{lock};
-        if (var.find(name) != var.end())
-            return vof_redefine_var;
-        auto new_var = new Var(data, env);
-        var.emplace(name, new_var);
-        new_var->delReference();
-        return vof_success;
-    }
-    
-    /**
-     * 定义变量
-     * @param name 变量名
-     * @param data 变量（Var）
-     * @return
-     */
-    VarSpace::VarOperationFlat VarSpace::defineVar(const std::string &name, Var *data){
-        std::unique_lock<std::mutex> mutex{lock};
-        if (var.find(name) != var.end())
-            return vof_redefine_var;
-        var.emplace(name, data);
-        return vof_success;
-    }
-    
-    /**
-     * 设定变量的值
-     * @param name 变量名
-     * @param data 变量
-     * @return
-     */
-    VarSpace::VarOperationFlat VarSpace::setVar(const std::string &name, Object *data){
-        std::unique_lock<std::mutex> mutex{lock};
-        auto v = var.find(name);
-        if (v == var.end())
-            return vof_not_var;
-        v->second->setData(data);
-        return vof_success;
-    }
-    
-    /**
-     * 删除变量
-     * @param name 变量名
-     * @return
-     */
-    VarSpace::VarOperationFlat VarSpace::delVar(const std::string &name){
-        std::unique_lock<std::mutex> mutex{lock};
-        auto v = var.find(name);
-        if (v == var.end())
-            return vof_not_var;
-        var.erase(v);
-        return vof_success;
-    }
-
-    void VarSpace::linkObject(std::queue<GcObjectBase *> &queue) {
-        for (auto tmp : var)
-            queue.push(tmp.second);
-    }
-    
-    VarList::VarList(VarList *varlist){
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &t: varlist->varspace)
-            this->varspace.push_back(t);
-    }
-    
-    /**
-     * 定义变量
-     * 若启用保护且变量名存在，则返回错误redefine
-     * 若启用保护则返回错误fail
-     * @param name 变量名
-     * @param data 变量（Object）
-     * @return
-     */
-    VarSpace::VarOperationFlat ProtectVarSpace::defineVar(const std::string &name, Object *data){
-        return VarSpace::defineVar(name, data);
-    }
-    
-    /**
-     * 定义变量
-     * 若启用保护且变量名存在，则返回错误redefine
-     * 若启用保护则返回错误fail
-     * @param name 变量名
-     * @param data 变量（Var）
-     * @return
-     */
-    VarSpace::VarOperationFlat ProtectVarSpace::defineVar(const std::string &name, Var *data){
-        return VarSpace::defineVar(name, data);
-    }
-    
-    /**
-     * 设定变量的值
-     * 若启用保护且变量名存在，则返回错误fail
-     * 若启用保护则返回错误 not_var
-     * @param name 变量名
-     * @param data 变量（Var）
-     * @return
-     */
-    VarSpace::VarOperationFlat ProtectVarSpace::setVar(const std::string &name, Object *data){
-        if (is_protect)
-            return findVar(name) ? vof_fail : vof_not_var;
-        return VarSpace::setVar(name, data);
-    }
-    
-    /**
-     * 删除变量
-     * 若启用保护且变量名存在，则返回错误fail
-     * 若启用保护则返回错误 not_var
-     * @param name 变量名
-     * @param data 变量（Var）
-     * @return
-     */
-    VarSpace::VarOperationFlat ProtectVarSpace::delVar(const std::string &name){
-        if (is_protect)
-            return findVar(name) ? vof_fail : vof_not_var;
-        return VarSpace::delVar(name);
-    }
-    
-    /**
-     * 访问变量
-     * @param name 变量名
-     * @return
-     */
-    Var *VarList::findVar(const std::string &name){
-        std::unique_lock<std::mutex> mutex{lock};
-        Var *ret = nullptr;
-        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == nullptr; tmp++) {
-            mutex.unlock();
-            ret = (*tmp)->findVar(name);
-            mutex.lock();
-        }
-        return ret;
-    }
-    
-    /**
-     * 定义变量
-     * 若定义出现redefine则退出报错
-     * 若出现fail则跳到下一个变量空间尝试定义
-     * @param name 变量名
-     * @param data 变量（Object）
-     * @return
-     */
-    bool VarList::defineVar(const std::string &name, Object *data){
-        std::unique_lock<std::mutex> mutex{lock};
-        VarSpace::VarOperationFlat ret = VarSpace::vof_fail;
-        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_fail; tmp++) {
-            mutex.unlock();
-            ret = (*tmp)->defineVar(name, data);
-            mutex.lock();
-        }
-        return ret == VarSpace::vof_success;
-    }
-    
-    /**
-     * 定义变量
-     * 若定义出现redefine则退出报错
-     * 若出现fail则跳到下一个变量空间尝试定义
-     * @param name 变量名
-     * @param data 变量（Var）
-     * @return
-     */
-    bool VarList::defineVar(const std::string &name, Var *data){
-        std::unique_lock<std::mutex> mutex{lock};
-        VarSpace::VarOperationFlat ret = VarSpace::vof_fail;
-        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_fail; tmp++) {
-            mutex.unlock();
-            ret = (*tmp)->defineVar(name, data);
-            mutex.lock();
-        }
-        return ret == VarSpace::vof_success;
-    }
-    
-    /**
-     * 设置变量的值
-     * 若not_var则跳到下一个变量空间
-     * 若fail则结束
-     * @param name 变量名
-     * @param data 数据
-     * @return
-     */
-    bool VarList::setVar(const std::string &name, Object *data){
-        std::unique_lock<std::mutex> mutex{lock};
-        VarSpace::VarOperationFlat ret = VarSpace::vof_not_var;
-        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_not_var; tmp++) {
-            mutex.unlock();
-            ret = (*tmp)->setVar(name, data);
-            mutex.lock();
-        }
-        return ret == VarSpace::vof_success;
-    }
-    
-    /**
-     * 删除变量
-     * 若not_var则跳到下一个变量空间
-     * 若fail则结束
-     * @param name
-     * @return
-     */
-    bool VarList::delVar(const std::string &name){
-        std::unique_lock<std::mutex> mutex{lock};
-        VarSpace::VarOperationFlat ret = VarSpace::vof_not_var;
-        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_not_var; tmp++) {
-            mutex.unlock();
-            ret = (*tmp)->delVar(name);
-            mutex.lock();
-        }
-        return ret == VarSpace::vof_success;
-    }
-    
-    void VarList::connect(VarList *varlist){
-        std::unique_lock<std::mutex> mutex{lock};
-        for (auto &t: varlist->varspace) {
-            mutex.unlock();
-            this->varspace.push_back(t);
-            mutex.lock();
-        }
-    }
-
-}

src/core/varlist.cpp

@@ -0,0 +1,113 @@
+#include "varlist.h"
+#include "object-value.h"
+#include "inter.h"
+#include "init.h"
+
+namespace aFuncore {
+    VarList::VarList(VarList *varlist){
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &t: varlist->varspace)
+            this->varspace.push_back(t);
+    }
+
+    /**
+     * 访问变量
+     * @param name 变量名
+     * @return
+     */
+    Var *VarList::findVar(const std::string &name){
+        std::unique_lock<std::mutex> mutex{lock};
+        Var *ret = nullptr;
+        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == nullptr; tmp++) {
+            mutex.unlock();
+            ret = (*tmp)->findVar(name);
+            mutex.lock();
+        }
+        return ret;
+    }
+
+    /**
+     * 定义变量
+     * 若定义出现redefine则退出报错
+     * 若出现fail则跳到下一个变量空间尝试定义
+     * @param name 变量名
+     * @param data 变量（Object）
+     * @return
+     */
+    bool VarList::defineVar(const std::string &name, Object *data){
+        std::unique_lock<std::mutex> mutex{lock};
+        VarSpace::VarOperationFlat ret = VarSpace::vof_fail;
+        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_fail; tmp++) {
+            mutex.unlock();
+            ret = (*tmp)->defineVar(name, data);
+            mutex.lock();
+        }
+        return ret == VarSpace::vof_success;
+    }
+    
+    /**
+     * 定义变量
+     * 若定义出现redefine则退出报错
+     * 若出现fail则跳到下一个变量空间尝试定义
+     * @param name 变量名
+     * @param data 变量（Var）
+     * @return
+     */
+    bool VarList::defineVar(const std::string &name, Var *data){
+        std::unique_lock<std::mutex> mutex{lock};
+        VarSpace::VarOperationFlat ret = VarSpace::vof_fail;
+        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_fail; tmp++) {
+            mutex.unlock();
+            ret = (*tmp)->defineVar(name, data);
+            mutex.lock();
+        }
+        return ret == VarSpace::vof_success;
+    }
+    
+    /**
+     * 设置变量的值
+     * 若not_var则跳到下一个变量空间
+     * 若fail则结束
+     * @param name 变量名
+     * @param data 数据
+     * @return
+     */
+    bool VarList::setVar(const std::string &name, Object *data){
+        std::unique_lock<std::mutex> mutex{lock};
+        VarSpace::VarOperationFlat ret = VarSpace::vof_not_var;
+        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_not_var; tmp++) {
+            mutex.unlock();
+            ret = (*tmp)->setVar(name, data);
+            mutex.lock();
+        }
+        return ret == VarSpace::vof_success;
+    }
+    
+    /**
+     * 删除变量
+     * 若not_var则跳到下一个变量空间
+     * 若fail则结束
+     * @param name
+     * @return
+     */
+    bool VarList::delVar(const std::string &name){
+        std::unique_lock<std::mutex> mutex{lock};
+        VarSpace::VarOperationFlat ret = VarSpace::vof_not_var;
+        for (auto tmp = varspace.begin(), end = varspace.end(); tmp != end && ret == VarSpace::vof_not_var; tmp++) {
+            mutex.unlock();
+            ret = (*tmp)->delVar(name);
+            mutex.lock();
+        }
+        return ret == VarSpace::vof_success;
+    }
+    
+    void VarList::connect(VarList *varlist){
+        std::unique_lock<std::mutex> mutex{lock};
+        for (auto &t: varlist->varspace) {
+            mutex.unlock();
+            this->varspace.push_back(t);
+            mutex.lock();
+        }
+    }
+
+}