refactor: 调整gc机制

Var和VarSpace都使用gc机制
GC可达性分析activity分析机制调整: 分析af_VarList和af_Object

include/env.h

@@ -11,6 +11,11 @@ typedef struct af_Message af_Message;
 typedef void TopMsgProcessFunc(af_Message *msg, af_Environment *env);
 DEFINE_DLC_SYMBOL(TopMsgProcessFunc);
 
+enum GcRunTime {
+    grt_always = 0,  // 总是运行
+    grt_count,  // 累计式运行
+};
+
 #include "code.h"
 #include "object.h"
 #include "var.h"
@@ -20,9 +25,10 @@ char getPrefix(size_t name, af_Environment *env);
 char setPrefix(size_t name, char prefix, af_Environment *env);
 
 /* 运行环境函数 */
-af_Environment *makeEnvironment(void);
+af_Environment *makeEnvironment(enum GcRunTime grt);
 bool enableEnvironment(af_Environment *env);
 void freeEnvironment(af_Environment *env);
+void checkRunGC(af_Environment *env);
 
 /* 保护空间管理函数 */
 bool addVarToProtectVarSpace(af_Var *var, af_Environment *env);
@@ -42,6 +48,9 @@ af_Message *popMessageUp(af_Environment *env);
 void *getMessageData(af_Message *msg);
 void connectMessage(af_Message **base, af_Message *msg);
 
+/* 消息工具函数 */
+af_Message *makeNORMALMessage(af_Object *obj);
+
 /* 下行消息表管理函数 */
 void pushMessageDown(af_Message *msg, af_Environment *env);
 af_Message *popMessageDown(char *type, af_Environment *env);

include/func.h

@@ -42,7 +42,8 @@ void freeAllArgList(af_ArgList *al);
 /* af_ArgList 操作函数 */
 af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new);
 af_ArgList **pushNewArgList(af_ArgList **base, char *name, af_Object *obj);
-bool runArgList(af_ArgList *al, af_VarSpaceListNode *vsl);
+
+bool runArgList(af_ArgList *al, af_VarSpaceListNode *vsl, af_Environment *env);
 
 /* FuncInfo 创建与释放 */
 af_FuncInfo *makeFuncInfo(enum af_FuncInfoScope scope, enum af_FuncInfoEmbedded embedded, bool is_macro);

include/gc.h

@@ -28,6 +28,6 @@ void gc_delVarReference(af_Var *obj);
 void gc_delVarSpaceReference(af_VarSpace *obj);
 
 /* gc 运行时函数 */
-bool resetGC(af_Environment *env);
+void resetGC(af_Environment *env);
 
 #endif //AFUN__GC_H_PUBLIC

include/object.h

@@ -16,7 +16,7 @@ DEFINE_DLC_SYMBOL(objectAPIFunc);
 /* 对象创建与释放函数 */
 af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Object *belong,
                       af_Inherit *inherit, af_Environment *env);
-void freeObject(af_Object *obj);
+void freeObject(af_Object *obj, af_Environment *env);
 
 /* 对象属性获取函数 */
 af_Object *getBelongObject(af_Object *object, af_Environment *env);

include/var.h

@@ -9,30 +9,25 @@ typedef struct af_VarSpaceListNode af_VarSpaceListNode;
 #include "object.h"
 
 /* 变量创建与释放 */
-af_Var *makeVar(char *name, char p_self, char p_external, af_Object *obj);
-void freeVar(af_Var *var);
+af_Var *makeVar(char *name, char p_self, char p_external, af_Object *obj, af_Environment *env);
+void freeVar(af_Var *var, af_Environment *env);
 
 /* 变量值管理 */
 void addVarNode(af_Var var, af_Object *obj, char *id);
 
 /* 变量空间创建与释放 */
-af_VarSpace *makeVarSpace(void);
-void freeVarSpace(af_VarSpace *vs);
-
-/* 变量的GC管理工具
- * 注意: 变量和变量空间默认是非GC管理的
- */
-void addVarSpaceGC(af_VarSpace *vs, af_Environment *env);
-void addVarGC(af_Var *var, af_Environment *env);
+af_VarSpace *makeVarSpace(af_Environment *env);
+void freeVarSpace(af_VarSpace *vs, af_Environment *env);
 
 /* 变量赋值类函数 */
 bool addVarToVarSpace(af_Var *var, af_VarSpace *vs);
-bool makeVarToVarSpace(char *name, char p_self, char p_external, af_Object *obj,
-                       af_VarSpace *vs);
+
+bool makeVarToVarSpace(char *name, char p_self, char p_external, af_Object *obj, af_VarSpace *vs, af_Environment *env);
 
 bool addVarToVarSpaceList(af_Var *var, af_VarSpaceListNode *vsl);
-bool makeVarToVarSpaceList(char *name, char p_self, char p_external, af_Object *obj,
-                           af_VarSpaceListNode *vsl);
+
+bool makeVarToVarSpaceList(char *name, char p_self, char p_external, af_Object *obj, af_VarSpaceListNode *vsl,
+                           af_Environment *env);
 
 /* 变量寻值类函数 */
 af_Var *findVarFromVarSpace(char *name, af_VarSpace *vs);
@@ -45,7 +40,7 @@ void freeAllVarSpaceList(af_VarSpaceListNode *vsl);
 bool freeVarSpaceListCount(size_t count, af_VarSpaceListNode *vsl);
 
 /* 变量空间链管理 */
-af_VarSpaceListNode *pushNewVarList(af_VarSpaceListNode *base);
+af_VarSpaceListNode *pushNewVarList(af_VarSpaceListNode *base, af_Environment *env);
 af_VarSpaceListNode *popLastVarList(af_VarSpaceListNode *base);
 
 #endif //AFUN__VAR_H_PUBLIC

src/core/__env.h

@@ -17,6 +17,7 @@ typedef struct af_LiteralDataList af_LiteralDataList;
 #include "__gc.h"
 #include "__func.h"
 
+#define DEFAULT_GC_COUNT_MAX (10)
 #define ENV_VAR_HASH_SIZE (8)
 typedef uint16_t ActivityCount;
 
@@ -29,6 +30,9 @@ struct af_Core {  // 解释器核心
     struct af_Object *gc_Object;
     struct af_Var *gc_Var;
     struct af_VarSpace *gc_VarSpace;
+    size_t gc_count;  // gc量计数
+    size_t gc_count_max;  // gc计数最大值
+    enum GcRunTime gc_run;
 
     // 基本对象信息
     struct af_Object *global;  // 顶级属对象

src/core/__gc.h

@@ -7,15 +7,15 @@ typedef struct GC_VarSpace GC_VarSpace;
 typedef struct GC_Object GC_Object;
 typedef struct GC_ObjectData GC_ObjectData;
 
-#define GC_FREE_EXCHANGE(obj) do { \
-if ((obj)->gc.prev != NULL) (obj)->gc.prev->gc.next = (obj)->gc.next; \
-if ((obj)->gc.next != NULL) (obj)->gc.next->gc.prev = (obj)->gc.prev; } while(0)
+#define GC_FREE_EXCHANGE(obj, Type, Core) do { \
+{if ((obj)->gc.prev != NULL) {(obj)->gc.prev->gc.next = (obj)->gc.next;} \
+ else {(Core)->gc_##Type = (obj)->gc.next;}} \
+{if ((obj)->gc.next != NULL) {(obj)->gc.next->gc.prev = (obj)->gc.prev;}}} while(0)
 
 #define GC_CHAIN(type) struct type *next, *prev
 typedef uint32_t GcCount;
 
 struct gc_info {
-    bool start_gc;  // 启用gc
     bool not_clear;  // 不清除
     GcCount reference;  // 引用计数
     bool reachable;  // 可达标记 [同时标识已迭代]
@@ -76,8 +76,8 @@ void gc_addObjectByCore(struct af_Object *obj, af_Core *core);
 void gc_addVarByCore(struct af_Var *obj, af_Core *core);
 void gc_addVarSpaceByCore(struct af_VarSpace *obj, af_Core *core);
 
-/* gc 启动函数 : gc的启动由解释器完全管理 */
-bool gc_RunGC(af_Environment *env);
+/* gc 操控函数 : gc的启动由解释器完全管理 */
+void gc_RunGC(af_Environment *env);
 void gc_freeAllValue(af_Core *core);
 
 /* gc 信息函数 */

src/core/__object.h

@@ -61,6 +61,9 @@ struct af_Inherit {
 };
 
 /* ObjectData的释放函数 */
-void freeObjectData(af_ObjectData *od);  // gc使用
+void freeObjectDataByCore(af_ObjectData *od, af_Core *core);
+
+/* Object释放函数 */
+void freeObjectByCore(af_Object *obj, af_Core *core);
 
 #endif //AFUN__OBJECT_H

src/core/__var.h

@@ -40,8 +40,12 @@ struct af_VarSpaceListNode {  // 变量链
     struct af_VarSpaceListNode *next;
 };
 
-/* 变量(变量空间)托管gc函数 :  内部使用 gc 对象新增函数 （涉及af_Core不对外公开) */
-void addVarSpaceGCByCore(af_VarSpace *vs, af_Core *core);
-void addVarGCByCore(af_Var *var, af_Core *core);
+/* 变量空间创建与释放 */
+af_VarSpace *makeVarSpaceByCore(af_Core *core);
+void freeVarSpaceByCore(af_VarSpace *vs, af_Core *core);
+
+/* 变量创建与释放 */
+af_Var *makeVarByCore(char *name, char p_self, char p_external, af_Object *obj, af_Core *core);
+void freeVarByCore(af_Var *var, af_Core *core);
 
 #endif //AFUN__VAR_H

src/core/env.c

@@ -1,7 +1,7 @@
 #include "__env.h"
 
 /* Core 创建和释放 */
-static af_Core *makeCore(void);
+static af_Core *makeCore(enum GcRunTime grt);
 static void freeCore(af_Core *core);
 
 /* Core 初始化 */
@@ -39,26 +39,20 @@ static void runTopMessageProcess(af_Environment *env);
 static af_LiteralDataList *makeLiteralDataList(char *data);
 static af_LiteralDataList *freeLiteralData_Pri(af_LiteralDataList *ld);
 
-static af_Core *makeCore(void) {
+static af_Core *makeCore(enum GcRunTime grt) {
     af_Core *core = calloc(sizeof(af_Core), 1);
     core->in_init = true;
-    core->protect = makeVarSpace();
-    addVarSpaceGCByCore(core->protect, core);
-    gc_addReference(core->protect);  // protect被外部引用, 由gc管理, 此处标记一个Reference
+    core->protect = makeVarSpaceByCore(core);
 
     core->prefix[V_QUOTE] = '\'';
     core->prefix[B_EXEC] = '\'';
     core->prefix[B_EXEC_FIRST] = ',';
-
+    core->gc_run = grt;
+    core->gc_count_max = DEFAULT_GC_COUNT_MAX;
     return core;
 }
 
 static void freeCore(af_Core *core) {
-    if (core->object != NULL)
-        gc_delReference(core->object);
-    if (core->global != NULL)
-        gc_delReference(core->global);
-    gc_delReference(core->protect);
     printGCByCode(core);
     gc_freeAllValue(core);
     free(core);
@@ -122,11 +116,7 @@ static bool enableCore(af_Core *core) {
     if (object == NULL || object->data->inherit != NULL || !object->data->allow_inherit)
         return false;  // object未找到 或其继承自其他对象 或其不可被继承
 
-    core->global = global;
-    core->object = object;
-    addVarSpaceGCByCore(global->data->var_space, core);
-
-    for (af_Object *obj = core->object; obj != NULL; obj = obj->gc.next) {
+    for (af_Object *obj = core->gc_Object; obj != NULL; obj = obj->gc.next) {
         if (obj == global)
             continue;
         if (obj->belong == NULL)
@@ -139,9 +129,9 @@ static bool enableCore(af_Core *core) {
         checkInherit(&od->inherit, object);
     }
 
-    gc_addReference(object);
-    gc_addReference(global);
-    addVarSpaceGCByCore(global->data->var_space, core);  // global的vs是全局作用空间, 被外部引用, 所以由gc管理 (不需要要标记Reference, global已经标记了)
+    core->global = global;
+    core->object = object;
+    core->protect->is_protect = true;
     core->in_init = false;
     return true;
 }
@@ -159,9 +149,6 @@ static af_Activity *makeActivity(af_Code *bt_top, af_Code *bt_start, bool return
 
     activity->belong = belong;
     activity->func = func;
-    gc_addReference(belong);
-    if (func != NULL)
-        gc_addReference(func);
 
     activity->bt_top = bt_top;
     activity->bt_start = bt_start;
@@ -174,10 +161,6 @@ static af_Activity *makeActivity(af_Code *bt_top, af_Code *bt_start, bool return
 static af_Activity *freeActivity(af_Activity *activity) {
     af_Activity *prev = activity->prev;
 
-    gc_delReference(activity->belong);
-    if (activity->func != NULL)
-        gc_delReference(activity->func);
-
     freeAllMessage(activity->msg_down);  // msg转移后需要将对应成员设置为NULL
     freeMessageCount(activity->msg_up_count, activity->msg_up);
 
@@ -186,12 +169,6 @@ static af_Activity *freeActivity(af_Activity *activity) {
     freeVarSpaceListCount(activity->new_vs_count, activity->var_list);
     freeVarSpaceListCount(activity->macro_vs_count, activity->macro_vsl);
 
-    if (activity->return_obj != NULL)
-        gc_delReference(activity->return_obj);
-
-    if (activity->parentheses_call != NULL)
-        gc_delReference(activity->parentheses_call);
-
     freeAllArgCodeList(activity->acl_start);
     if (activity->fi != NULL)
         freeFuncInfo(activity->fi);
@@ -211,10 +188,6 @@ static void clearActivity(af_Activity *activity) {
     freeAllArgCodeList(activity->acl_start);
     if (activity->fi != NULL)
         freeFuncInfo(activity->fi);
-    if (activity->parentheses_call != NULL) {
-        gc_delReference(activity->parentheses_call);
-        activity->parentheses_call = NULL;
-    }
 
     activity->func_var_list = NULL;
     activity->bt_top = NULL;
@@ -351,6 +324,22 @@ void connectMessage(af_Message **base, af_Message *msg) {
     *base = msg;
 }
 
+void mp_NORMAL(af_Message *msg, af_Environment *env) {
+    if (msg->msg == NULL || *(af_Object **)msg->msg == NULL) {
+        printf("msg: %p error\n", msg->msg);
+        return;
+    }
+    gc_delReference(*(af_Object **)msg->msg);
+    printf("NORMAL Point: %p\n", *(af_Object **)msg->msg);
+}
+
+af_Message *makeNORMALMessage(af_Object *obj) {
+    af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
+    *(af_Object **)msg->msg = obj;  // env->activity->return_obj本来就有一个gc_Reference
+    gc_addReference(obj);
+    return msg;
+}
+
 static af_EnvVar *makeEnvVar(char *name, char *data) {
     af_EnvVar *var = calloc(sizeof(af_EnvVar), 1);
     var->name = strCopy(name);
@@ -409,19 +398,10 @@ char *findEnvVar(char *name, af_Environment *env) {
     return NULL;
 }
 
-void mp_NORMAL(af_Message *msg, af_Environment *env) {
-    if (msg->msg == NULL || *(af_Object **)msg->msg == NULL) {
-        printf("msg: %p error\n", msg->msg);
-        return;
-    }
-    gc_delReference(*(af_Object **)msg->msg);
-    printf("NORMAL Point: %p\n", *(af_Object **)msg->msg);
-}
-
-af_Environment *makeEnvironment(void) {
+af_Environment *makeEnvironment(enum GcRunTime grt) {
     af_Environment *env = calloc(sizeof(af_Environment), 1);
     DLC_SYMBOL(TopMsgProcessFunc) func = MAKE_SYMBOL(mp_NORMAL, TopMsgProcessFunc);
-    env->core = makeCore();
+    env->core = makeCore(grt);
     env->esv = makeEnvVarSpace();
     addTopMsgProcess("NORMAL", func, env);
     FREE_SYMBOL(func);
@@ -452,6 +432,13 @@ void freeEnvironment(af_Environment *env) {
     free(env);
 }
 
+void checkRunGC(af_Environment *env) {
+    if (env->core->gc_run == grt_always ||
+        env->core->gc_run == grt_count && env->core->gc_count >= env->core->gc_count_max) {
+        gc_RunGC(env);
+    }
+}
+
 bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
     return addVarToVarSpace(var, env->core->protect);
 }
@@ -539,9 +526,6 @@ bool pushFuncActivity(af_Code *bt, af_Environment *env) {
     af_Code *next;
     af_Code *func;
     af_Object *parentheses_call = env->activity->parentheses_call;
-
-    if (parentheses_call != NULL)
-        gc_delReference(parentheses_call);
     env->activity->parentheses_call = NULL;
 
     if (!getCodeBlockNext(bt, &next)) {
@@ -621,15 +605,8 @@ bool setFuncActivityToArg(af_Object *func, af_Environment *env) {
         return false;
     }
 
-    af_Object *belong = getBelongObject(func, env);
-    gc_delReference(env->activity->belong);
-    if (env->activity->func != NULL)
-        gc_delReference(env->activity->func);
-    gc_addReference(func);
-    gc_addReference(belong);
-
     env->activity->func = func;
-    env->activity->belong = belong;
+    env->activity->belong = getBelongObject(func, env);
     env->activity->status = act_arg;
 
     /* 遇到错误时 get_acl 和 get_var_list 要自行设定msg */
@@ -691,14 +668,14 @@ bool setFuncActivityAddVar(af_Environment *env){
     }
 
     if (env->activity->fi->embedded != super_embedded) {  // 不是超内嵌函数则引入一层新的变量空间
-        env->activity->var_list = pushNewVarList(env->activity->var_list);
+        env->activity->var_list = pushNewVarList(env->activity->var_list, env);
         env->activity->new_vs_count++;
     }
 
     env->activity->func_var_list = NULL;
     if (!get_arg_list(&al, env->activity->func, env->activity->acl_start, env->activity->mark, env))
         return false;
-    runArgList(al, env->activity->var_list);
+    runArgList(al, env->activity->var_list, env);
     freeAllArgList(al);
 
     if (env->activity->fi->embedded == protect_embedded)
@@ -781,8 +758,7 @@ void popActivity(af_Message *msg, af_Environment *env) {
         if (env->activity->return_obj == NULL)
             msg = makeMessage("ERROR-STR", 0);
         else {
-            msg = makeMessage("NORMAL", sizeof(af_Object *));
-            *(af_Object **)msg->msg = env->activity->return_obj;  // env->activity->return_obj本来就有一个gc_Reference
+            msg = makeNORMALMessage(env->activity->return_obj);
             env->activity->return_obj = NULL;
         }
     }

src/core/func.c

@@ -103,9 +103,9 @@ af_ArgList **pushNewArgList(af_ArgList **base, char *name, af_Object *obj) {
     return &((*base)->next);
 }
 
-bool runArgList(af_ArgList *al, af_VarSpaceListNode *vsl) {
+bool runArgList(af_ArgList *al, af_VarSpaceListNode *vsl, af_Environment *env){
     for (NULL; al != NULL; al = al->next) {
-        if (!makeVarToVarSpaceList(al->name, 3, 3, al->obj, vsl))
+        if (!makeVarToVarSpaceList(al->name, 3, 3, al->obj, vsl, env))
             return false;
     }
     return true;

src/core/gc.c

@@ -42,7 +42,7 @@ static pgc_Analyzed reachableObject(struct af_Object *od, pgc_Analyzed plist);
 
 /* gc运行函数 */
 static void freeValue(af_Core *core);
-static pgc_Analyzed reachable(af_Activity *active, pgc_Analyzed plist);
+static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist);
 static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist);
 static void freeAllAnalyzed(gc_Analyzed *base);
 
@@ -98,7 +98,6 @@ static pgc_Analyzed newVarSpaceAnalyzed(struct af_VarSpace *vs, pgc_Analyzed pli
 
 // 使用 gc_Analyzed 目的是令可达性分析程序不需要使用递归
 // Object->OvjectData->VarSpace->Var; 仅允许单项调用, 不发生递归
-
 static pgc_Analyzed reachableObject(struct af_Object *od, pgc_Analyzed plist) {
     for (NULL; od != NULL && !od->gc.info.reachable; od = od->belong) {
         od->gc.info.reachable = true;
@@ -154,8 +153,10 @@ static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
 
 static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist) {
     plist = reachableVarSpace(core->protect, plist);
-    plist = reachableObject(core->object, plist);
-    plist = reachableObject(core->global, plist);
+    if (core->object != NULL)
+        plist = reachableObject(core->object, plist);
+    if (core->global != NULL)
+        plist = reachableObject(core->global, plist);
 
     for (af_ObjectData *od = core->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (!od->gc.info.reachable && (od->gc.info.reference > 0 || od->gc.info.not_clear))
@@ -179,61 +180,84 @@ static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist) {
     return plist;
 }
 
-static pgc_Analyzed reachable(af_Activity *active, pgc_Analyzed plist) {
-    for (NULL; active != NULL; active = active->prev) {
-        for (af_VarSpaceListNode *vsn = active->var_list; vsn != NULL; vsn = vsn->next) {
+static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist) {
+    for (NULL; activity != NULL; activity = activity->prev) {
+        if (activity->belong != NULL)
+            plist = reachableObject(activity->belong, plist);
+
+        if (activity->func != NULL)
+            plist = reachableObject(activity->func, plist);
+
+        if (activity->return_obj != NULL)
+            plist = reachableObject(activity->return_obj, plist);
+
+        if (activity->parentheses_call != NULL)
+            plist = reachableObject(activity->parentheses_call, plist);
+
+        for (af_VarSpaceListNode *vsn = activity->var_list; vsn != NULL; vsn = vsn->next) {
+            if (!vsn->vs->gc.info.reachable)
+                plist = reachableVarSpace(vsn->vs, plist);
+        }
+
+        for (af_VarSpaceListNode *vsn = activity->func_var_list; vsn != NULL; vsn = vsn->next) {
+            if (!vsn->vs->gc.info.reachable)
+                plist = reachableVarSpace(vsn->vs, plist);
+        }
+
+        for (af_VarSpaceListNode *vsn = activity->macro_vsl; vsn != NULL; vsn = vsn->next) {
             if (!vsn->vs->gc.info.reachable)
                 plist = reachableVarSpace(vsn->vs, plist);
         }
+
     }
     return plist;
 }
 
-bool resetGC(af_Environment *env) {
+void resetGC(af_Environment *env) {
     for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next)
         od->gc.info.reachable = false;
 
     for (af_Object *obj = env->core->gc_Object; obj != NULL; obj = obj->gc.next)
         obj->gc.info.reachable = false;
 
-    for (af_VarSpace *vs = env->core->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
+    for (af_VarSpace *vs = env->core->gc_VarSpace; vs != NULL; vs = vs->gc.next)
         vs->gc.info.reachable = false;
-        if (!vs->gc.info.start_gc)  // 未启用gc但却在gc链中
-            return false;
-    }
 
-    for (af_Var *var = env->core->gc_Var; var != NULL; var = var->gc.next) {
+    for (af_Var *var = env->core->gc_Var; var != NULL; var = var->gc.next)
         var->gc.info.reachable = false;
-        if (!var->gc.info.start_gc)  // 未启用gc但却在gc链中
-            return false;
-    }
-
-    return true;
 }
 
 static void freeValue(af_Core *core) {
     for (af_ObjectData *od = core->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
-        if (!od->gc.info.reachable)  // 暂时不考虑析构函数
-            freeObjectData(od);
+        if (!od->gc.info.reachable) { // 暂时不考虑析构函数
+            printf("- gc free ObjectData: %p\n", od);
+            freeObjectDataByCore(od, core);
+        }
     }
 
     for (af_Object *obj = core->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
-        if (!obj->gc.info.reachable)
-            freeObject(obj);
+        if (!obj->gc.info.reachable) {
+            printf("- gc free Object: %p\n", obj);
+            freeObjectByCore(obj, core);
+        }
     }
 
     for (af_VarSpace *vs = core->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
-        if (!vs->gc.info.reachable)
-            freeVarSpace(vs);
+        if (!vs->gc.info.reachable) {
+            printf("- gc free VarSpace: %p\n", vs);
+            freeVarSpaceByCore(vs, core);
+        }
     }
 
     for (af_Var *var = core->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
-        if (!var->gc.info.reachable)
-            freeVar(var);
+        if (!var->gc.info.reachable) {
+            printf("- gc free Var: %p\n", var);
+            freeVarByCore(var, core);
+        }
     }
 }
 
@@ -247,6 +271,7 @@ void gc_add##type(af_##type *obj, af_Environment *env) { \
     env->core->gc_##type = obj; \
 } \
 void gc_add##type##ByCore(af_##type *obj, af_Core *core) { \
+if (obj->gc.next != NULL || obj->gc.prev != NULL) {return;} \
 obj->gc.prev = NULL; \
 obj->gc.next = core->gc_##type; \
 core->gc_##type = obj; \
@@ -265,12 +290,10 @@ GC_FUNC_DEFINED(VarSpace)
 
 #undef GC_FUNC_DEFINED
 
-bool gc_RunGC(af_Environment *env) {
-    gc_Analyzed *analyzed;
+void gc_RunGC(af_Environment *env) {
+    gc_Analyzed *analyzed = NULL;
     pgc_Analyzed plist = &analyzed;
-
-    if (!resetGC(env))
-        return false;
+    resetGC(env);
 
     plist = iterLinker(env->core, plist);  // 临时量分析 (临时量都是通过reference标记的)
     plist = reachable(env->activity, plist);
@@ -296,28 +319,27 @@ bool gc_RunGC(af_Environment *env) {
 
     freeValue(env->core);
     freeAllAnalyzed(analyzed);
-    return true;
 }
 
 void gc_freeAllValue(af_Core *core) {
     for (af_ObjectData *od = core->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
-        freeObjectData(od);  // 暂时不考虑析构函数
+        freeObjectDataByCore(od, core);  // 暂时不考虑析构函数
     }
 
     for (af_Object *obj = core->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
-        freeObject(obj);
+        freeObjectByCore(obj, core);
     }
 
     for (af_VarSpace *vs = core->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
-        freeVarSpace(vs);
+        freeVarSpaceByCore(vs, core);
     }
 
     for (af_Var *var = core->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
-        freeVar(var);
+        freeVarByCore(var, core);
     }
 }
 

src/core/object.c

@@ -3,8 +3,9 @@
 #include "tool.h"
 
 /* ObjectData 创建与释放 */
-static af_ObjectData *makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit);
-static af_Object *makeObject_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit);
+static af_ObjectData *
+makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Environment *env);
+static af_Object *makeObject_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Environment *env);
 
 /* ObjectData API 创建与释放 */
 static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, char *api_name);
@@ -21,7 +22,8 @@ static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af
  * 注意: af_ObjectData不是对外开放的结构体
  * 注意: api不能为NULL
  */
-static af_ObjectData *makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit) {
+static af_ObjectData * makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit,
+                                          af_Environment *env){
     af_ObjectData *od = calloc(sizeof(af_ObjectData), 1);
     od->id = strCopy(id == NULL ? "Unknow" : id);
 
@@ -42,18 +44,20 @@ static af_ObjectData *makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *
     od->free_api = free_api;
     od->allow_inherit = allow_inherit;
 
-    od->var_space = makeVarSpace();
+    od->var_space = makeVarSpace(env);
     od->inherit = NULL;
 
     od->base = NULL;
+    gc_addObjectData(od, env);
     return od;
 }
 
-static af_Object *makeObject_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit) {
+static af_Object *makeObject_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Environment *env){
     af_Object *obj = calloc(sizeof(af_Object), 1);
     obj->belong = NULL;
-    obj->data = makeObjectData_Pri(id, free_api, api, allow_inherit);
+    obj->data = makeObjectData_Pri(id, free_api, api, allow_inherit, env);
     obj->data->base = obj;
+    gc_addObject(obj, env);
     return obj;
 }
 
@@ -76,7 +80,7 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
     if (!env->core->in_init && ih == NULL)
         return NULL;
 
-    af_Object *obj = makeObject_Pri(id, free_api, api, allow_inherit);
+    af_Object *obj = makeObject_Pri(id, free_api, api, allow_inherit, env);
 
     if (env->core->in_init || belong != NULL)
         obj->belong = belong;
@@ -86,17 +90,16 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
         return NULL;
 
     obj->data->inherit = ih;
-    gc_addObjectData(obj->data, env);
-    gc_addObject(obj, env);
     return obj;
 }
 
 /*
- * 函数名: freeObjectData
- * 目标: 释放ObjectData, 仅GC和freeObject函数可用
+ * 函数名: freeObjectDataByCore
+ * 目标: 释放ObjectData, 仅GC函数可用
  * 对外API中, 创建对象的基本单位都是af_Object, 无法直接操控af_ObjectData
+ * af_ObjectData对外不可见, 因此无使用env的freeObjectData函数
  */
-void freeObjectData(af_ObjectData *od) {
+void freeObjectDataByCore(af_ObjectData *od, af_Core *core) {
     if (od->size != 0) {
         obj_freeData *func = findAPI("obj_freeData", od->api);
         if (func != NULL)
@@ -107,15 +110,18 @@ void freeObjectData(af_ObjectData *od) {
     free(od->data);
     if (od->free_api)
         freeObjectAPI(od->api);
-    if (!od->var_space->gc.info.start_gc)
-        freeVarSpace(od->var_space);
     freeAllInherit(od->inherit);
-    GC_FREE_EXCHANGE(od);
+    GC_FREE_EXCHANGE(od, ObjectData, core);
     free(od);
 }
 
-void freeObject(af_Object *obj) {
-    GC_FREE_EXCHANGE(obj);
+void freeObject(af_Object *obj, af_Environment *env) {
+    GC_FREE_EXCHANGE(obj, Object, env->core);
+    free(obj);
+}
+
+void freeObjectByCore(af_Object *obj, af_Core *core) {
+    GC_FREE_EXCHANGE(obj, Object, core);
     free(obj);
 }
 

src/core/run.c

@@ -13,7 +13,6 @@ static bool checkInMsgType(char *type, af_Environment *env);
 
 static bool codeVariable(af_Code *code, af_Environment *env) {
     af_Var *var = findVarFromVarList(code->variable.name, env->activity->vsl);
-    af_Message *msg;
 
     if (var == NULL) {
         pushMessageDown(makeMessage("ERROR-STR", 0), env);
@@ -24,13 +23,9 @@ static bool codeVariable(af_Code *code, af_Environment *env) {
     af_Object *obj = var->vn->obj;
     is_obj_func *func;
     if (code->prefix == env->core->prefix[V_QUOTE] ||
-        (func = findAPI("is_obj_func", obj->data->api)) == NULL ||
-        !func(obj)) {  // 非对象函数 或 引用调用
-        msg = makeMessage("NORMAL", sizeof(af_Object *));
-        *((af_Object **)msg->msg) = obj;
-        gc_addReference(obj);
+        (func = findAPI("is_obj_func", obj->data->api)) == NULL || !func(obj)) {  // 非对象函数 或 引用调用
+        pushMessageDown(makeNORMALMessage(obj), env);
         env->activity->bt_next = env->activity->bt_next->next;
-        pushMessageDown(msg, env);
         printf("Get Variable %s : %p\n", code->variable.name, obj);
         return false;
     }
@@ -92,6 +87,7 @@ static bool checkLiteral(af_Message **msg, af_Environment *env) {
     freeAllLiteralData(env->activity->ld);
     env->activity->ld = NULL;
     env->activity->is_literal = false;
+    printf("Literal %p\n", obj);
     return true;
 }
 
@@ -111,7 +107,7 @@ bool iterCode(af_Code *code, af_Environment *env) {
     if (!addTopActivity(code, env))
         return false;
 
-    while (env->activity != NULL) {
+    for (NULL; env->activity != NULL; checkRunGC(env)) {
         af_Message *msg = NULL;
         bool run_code = false;
 
@@ -149,16 +145,13 @@ bool iterCode(af_Code *code, af_Environment *env) {
             if (!EQ_STR(msg->type, "NORMAL")) {  // 若msg为非正常值
                 pushMessageDown(msg, env);  // msg不弹出
                 if (env->activity->status != act_normal || !checkInMsgType(msg->type, env)) {  // 非normal模式, 或normal模式不匹配该msg
-                    if (env->activity->return_obj != NULL)
-                        gc_delReference(env->activity->return_obj);
+                    env->activity->return_first = false;
                     env->activity->return_obj = NULL;
                     popActivity(NULL, env);  // msg 已经 push进去了
                     continue;
                 }
-            } else if (env->activity->return_first && env->activity->return_obj == NULL) {  // 设置return_first
+            } else if (env->activity->return_first && env->activity->return_obj == NULL)  // 设置return_first
                 env->activity->return_obj = *(af_Object **)msg->msg;
-                gc_addReference(env->activity->return_obj);
-            }
         }
 
         switch (env->activity->status) {
@@ -194,11 +187,10 @@ bool iterCode(af_Code *code, af_Environment *env) {
                             freeMessage(msg);
                             break;
                     }
-                } else if (env->activity->bt_next->type == block && env->activity->bt_next->block.type == parentheses &&
-                           env->activity->bt_next->prefix != env->core->prefix[B_EXEC]) {  // 类前缀调用
-                    env->activity->parentheses_call = *(af_Object **)(msg->msg);
-                    freeMessage(msg);
                 } else {  // 继续运行
+                    if (env->activity->bt_next->type == block && env->activity->bt_next->block.type == parentheses &&
+                           env->activity->bt_next->prefix != env->core->prefix[B_EXEC])
+                        env->activity->parentheses_call = *(af_Object **)(msg->msg);  // 类前缀调用
                     gc_delReference(*(af_Object **)(msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
                     freeMessage(msg);
                 }

src/core/var.c

@@ -35,22 +35,39 @@ static void freeAllVarNode(af_VarNode *vn) {
         vn = freeVarNode(vn);
 }
 
-af_Var *makeVar(char *name, char p_self, char p_external, af_Object *obj) {
+af_Var *makeVar(char *name, char p_self, char p_external, af_Object *obj, af_Environment *env) {
     af_VarNode *vn = makeVarNode(obj, NULL);
     af_Var *var = calloc(sizeof(af_Var), 1);
     var->name = strCopy(name);
     var->vn = vn;
     var->permissions[0] = p_self;
     var->permissions[1] = p_external;
+    gc_addVar(var, env);
+    return var;
+}
+
+af_Var *makeVarByCore(char *name, char p_self, char p_external, af_Object *obj, af_Core *core) {
+    af_VarNode *vn = makeVarNode(obj, NULL);
+    af_Var *var = calloc(sizeof(af_Var), 1);
+    var->name = strCopy(name);
+    var->vn = vn;
+    var->permissions[0] = p_self;
+    var->permissions[1] = p_external;
+    gc_addVarByCore(var, core);
     return var;
 }
 
-void freeVar(af_Var *var) {
+void freeVar(af_Var *var, af_Environment *env){
     freeAllVarNode(var->vn);
     free(var->name);
-    if (var->gc.info.start_gc) {
-        GC_FREE_EXCHANGE(var);
-    }
+    GC_FREE_EXCHANGE(var, Var, env->core);
+    free(var);
+}
+
+void freeVarByCore(af_Var *var, af_Core *core) {
+    freeAllVarNode(var->vn);
+    free(var->name);
+    GC_FREE_EXCHANGE(var, Var, core);
     free(var);
 }
 
@@ -68,8 +85,6 @@ static af_VarCup *makeVarCup(af_Var *var) {
 
 static af_VarCup *freeVarCup(af_VarCup *vp) {
     af_VarCup *next = vp->next;
-    if (!vp->var->gc.info.start_gc)
-        freeVar(vp->var);
     free(vp);
     return next;
 }
@@ -79,17 +94,29 @@ static void freeAllVarCup(af_VarCup *vp) {
         vp = freeVarCup(vp);
 }
 
-af_VarSpace *makeVarSpace(void) {
+af_VarSpace *makeVarSpace(af_Environment *env) {
     af_VarSpace *vs = calloc(sizeof(af_VarSpace), 1);
+    gc_addVarSpace(vs, env);
+    return vs;
+}
+
+af_VarSpace *makeVarSpaceByCore(af_Core *core) {
+    af_VarSpace *vs = calloc(sizeof(af_VarSpace), 1);
+    gc_addVarSpaceByCore(vs, core);
     return vs;
 }
 
-void freeVarSpace(af_VarSpace *vs) {
+void freeVarSpace(af_VarSpace *vs, af_Environment *env) {
     for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
         freeAllVarCup(vs->var[i]);
-    if (vs->gc.info.start_gc) {
-        GC_FREE_EXCHANGE(vs);
-    }
+    GC_FREE_EXCHANGE(vs, VarSpace, env->core);
+    free(vs);
+}
+
+void freeVarSpaceByCore(af_VarSpace *vs, af_Core *core) {
+    for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
+        freeAllVarCup(vs->var[i]);
+    GC_FREE_EXCHANGE(vs, VarSpace, core);
     free(vs);
 }
 
@@ -99,15 +126,13 @@ af_VarSpaceListNode *makeVarSpaceList(af_VarSpace *vs) {
     return vsl;
 }
 
-af_VarSpaceListNode *freeVarSpaceList(af_VarSpaceListNode *vsl) {
+af_VarSpaceListNode *freeVarSpaceList(af_VarSpaceListNode *vsl){
     af_VarSpaceListNode *next = vsl->next;
-    if (!vsl->vs->gc.info.start_gc)
-        freeVarSpace(vsl->vs);
     free(vsl);
     return next;
 }
 
-void freeAllVarSpaceList(af_VarSpaceListNode *vsl) {
+void freeAllVarSpaceList(af_VarSpaceListNode *vsl){
     while (vsl != NULL)
         vsl = freeVarSpaceList(vsl);
 }
@@ -116,43 +141,11 @@ bool freeVarSpaceListCount(size_t count, af_VarSpaceListNode *vsl) {
     for (size_t i = count; i > 0; i--) {
         if (vsl == NULL)  // 发生了错误
             return false;
-        vsl = popLastVarList(vsl);
+        vsl = freeVarSpaceList(vsl);
     }
     return true;
 }
 
-void addVarSpaceGCByCore(af_VarSpace *vs, af_Core *core) {
-    if (vs->gc.info.start_gc)
-        return;
-
-    vs->gc.info.start_gc = true;
-    gc_addVarSpaceByCore(vs, core);
-}
-
-void addVarSpaceGC(af_VarSpace *vs, af_Environment *env) {
-    if (vs->gc.info.start_gc)
-        return;
-
-    vs->gc.info.start_gc = true;
-    gc_addVarSpace(vs, env);
-}
-
-void addVarGCByCore(af_Var *var, af_Core *core) {
-    if (var->gc.info.start_gc)
-        return;
-
-    var->gc.info.start_gc = true;
-    gc_addVarByCore(var, core);
-}
-
-void addVarGC(af_Var *var, af_Environment *env) {
-    if (var->gc.info.start_gc)
-        return;
-
-    var->gc.info.start_gc = true;
-    gc_addVar(var, env);
-}
-
 /*
  * 函数名: addVarToVarSpace
  * 目标: 把var添加到VarSpace中
@@ -181,9 +174,8 @@ bool addVarToVarSpace(af_Var *var, af_VarSpace *vs) {
  * 若已存在同名Var则返回false不作修改
  * 否则返回true
  */
-bool makeVarToVarSpace(char *name, char p_self, char p_external, af_Object *obj,
-                       af_VarSpace *vs) {
-    return addVarToVarSpace(makeVar(name, p_self, p_external, obj), vs);
+bool makeVarToVarSpace(char *name, char p_self, char p_external, af_Object *obj, af_VarSpace *vs, af_Environment *env){
+    return addVarToVarSpace(makeVar(name, p_self, p_external, obj, env), vs);
 }
 
 bool addVarToVarSpaceList(af_Var *var, af_VarSpaceListNode *vsl) {
@@ -194,9 +186,8 @@ bool addVarToVarSpaceList(af_Var *var, af_VarSpaceListNode *vsl) {
     return false;
 }
 
-bool makeVarToVarSpaceList(char *name, char p_self, char p_external, af_Object *obj,
-                           af_VarSpaceListNode *vsl) {
-    return addVarToVarSpaceList(makeVar(name, p_self, p_external, obj), vsl);
+bool makeVarToVarSpaceList(char *name, char p_self, char p_external, af_Object *obj, af_VarSpaceListNode *vsl, af_Environment *env){
+    return addVarToVarSpaceList(makeVar(name, p_self, p_external, obj, env), vsl);
 }
 
 /*
@@ -236,8 +227,8 @@ af_Var *findVarFromVarList(char *name, af_VarSpaceListNode *vsl) {
     return NULL;
 }
 
-af_VarSpaceListNode *pushNewVarList(af_VarSpaceListNode *base) {
-    af_VarSpaceListNode *new = makeVarSpaceList(makeVarSpace());
+af_VarSpaceListNode *pushNewVarList(af_VarSpaceListNode *base, af_Environment *env){
+    af_VarSpaceListNode *new = makeVarSpaceList(makeVarSpace(env));
     new->next = base;
     return new;
 }

src/main.c

@@ -33,7 +33,7 @@ bool getAcl(af_ArgCodeList **acl, af_Object *obj, af_Code *code, int **mark, af_
 
 bool getVsl(af_VarSpaceListNode **vsl, af_Object *obj, void *mark, af_Environment *env) {  // [桩]
     *vsl = makeVarSpaceList(getProtectVarSpace(env));
-    pushNewVarList(*vsl);
+    pushNewVarList(*vsl, env);
     return true;
 }
 
@@ -59,10 +59,7 @@ void testFunc(int *mark, af_Environment *env) {  // 测试用函数
         FREE_SYMBOL(literal_set);
     }
 
-    af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
-    *((af_Object **)(getMessageData(msg))) = obj;
-    gc_addReference(obj);
-    pushMessageDown(msg, env);
+    pushMessageDown(makeNORMALMessage(obj), env);
 }
 
 bool getInfo(af_FuncInfo **fi, af_Object *obj, af_Code *code, void *mark, af_Environment *env) {
@@ -110,10 +107,7 @@ void testFunc2(int *mark, af_Environment *env) {  // 测试用函数
         FREE_SYMBOL(free_mark);
     }
 
-    af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
-    *((af_Object **)(getMessageData(msg))) = obj;
-    gc_addReference(obj);
-    pushMessageDown(msg, env);
+    pushMessageDown(makeNORMALMessage(obj), env);
 }
 
 bool getInfo2(af_FuncInfo **fi, af_Object *obj, af_Code *code, void *mark, af_Environment *env) {
@@ -144,10 +138,7 @@ void testFunc4(int *mark, af_Environment *env) {  // 测试用函数
         FREE_SYMBOL(literal_set);
     }
 
-    af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
-    *((af_Object **)(getMessageData(msg))) = obj;
-    gc_addReference(obj);
-    pushMessageDown(msg, env);
+    pushMessageDown(makeNORMALMessage(obj), env);
 }
 
 bool getInfo4(af_FuncInfo **fi, af_Object *obj, af_Code *code, void *mark, af_Environment *env) {
@@ -166,7 +157,7 @@ int main() {
     aFunInit();
     printf("Hello World\n");
 
-    af_Environment *env = makeEnvironment();
+    af_Environment *env = makeEnvironment(grt_always);
     {
         af_ObjectAPI *api = makeObjectAPI();
         af_Object *obj;
@@ -181,7 +172,7 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("global", 3, 3,
-                                        (obj = makeObject("global", true, api, true, NULL, NULL, env))),
+                                        (obj = makeObject("global", true, api, true, NULL, NULL, env)), env),
                                 env);
         FREE_SYMBOL(getSize_);
         FREE_SYMBOL(initData_);
@@ -209,7 +200,7 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("func", 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, NULL, env))),
+                                        (obj = makeObject("func", true, api, true, NULL, NULL, env)), env),
                                 env);
         FREE_SYMBOL(get_alc);
         FREE_SYMBOL(get_vsl);
@@ -239,7 +230,7 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("func2", 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, NULL, env))),
+                                        (obj = makeObject("func", true, api, true, NULL, NULL, env)), env),
                                 env);
         FREE_SYMBOL(get_alc);
         FREE_SYMBOL(get_vsl);
@@ -269,7 +260,7 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("func3", 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, NULL, env))),
+                                        (obj = makeObject("func", true, api, true, NULL, NULL, env)), env),
                                 env);
         FREE_SYMBOL(get_alc);
         FREE_SYMBOL(get_vsl);
@@ -302,7 +293,7 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("func4", 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, NULL, env))),
+                                        (obj = makeObject("func", true, api, true, NULL, NULL, env)), env),
                                 env);
         FREE_SYMBOL(get_alc);
         FREE_SYMBOL(get_vsl);
@@ -316,7 +307,8 @@ int main() {
     {
         af_Object *obj;
         addVarToProtectVarSpace(makeVar("object", 3, 3,
-                                        (obj = makeObject("object", true, makeObjectAPI(), true, NULL, NULL, env))),
+                                        (obj = makeObject("object", true, makeObjectAPI(), true, NULL, NULL, env)),
+                                        env),
                                 env);
         printf("object(%p)\n", obj);
     }

test/test_env.c

@@ -18,7 +18,7 @@ void freeData(int **data) {
 int main() {
     aFunInit();
 
-    af_Environment *env = makeEnvironment();
+    af_Environment *env = makeEnvironment(grt_always);
     {
         af_ObjectAPI *api = makeObjectAPI();
         DLC_SYMBOL(objectAPIFunc) getSize_ = MAKE_SYMBOL(getSize, objectAPIFunc);
@@ -32,14 +32,14 @@ int main() {
             return 2;
 
         addVarToProtectVarSpace(makeVar("global", 3, 3,
-                                        makeObject("global", true, api, true, NULL, NULL, env)),
+                                        makeObject("global", true, api, true, NULL, NULL, env), env),
                                 env);
         FREE_SYMBOL(getSize_);
         FREE_SYMBOL(initData_);
         FREE_SYMBOL(freeData_);
     }
     addVarToProtectVarSpace(makeVar("object", 3, 3,
-                                    makeObject("object", true, makeObjectAPI(), true, NULL, NULL, env)),
+                                    makeObject("object", true, makeObjectAPI(), true, NULL, NULL, env), env),
                             env);
     if (!enableEnvironment(env)) {
         fprintf(stderr, "Enable Error.\n");