feat: 新增gc线程模块

注: 仍存在bug

include/core/global_obj.h

@@ -4,5 +4,5 @@
 #include "object.h"
 
 AFUN_CORE_EXPORT af_Object *makeGlobalObject(af_Environment *env);
-
+AFUN_CORE_EXPORT af_Object *makeCycleObject(af_Environment *env);
 #endif //AFUN_GLOBAL_OBJ_H

include/core/info/magic_func.h

@@ -10,7 +10,7 @@
 
 /* gc模块 */
 #define mg_gc_destruct MAGIC_NAME(gc, destruct)
-
+#define mg_sys_cycle MAGIC_NAME(sys, cycle)
 
 /* 内置环境变量 */
 #define SYS_NAME(job) "sys-" #job

include/core/thread.h

@@ -1,8 +1,9 @@
 #ifndef AFUN_THREAD_H
 #define AFUN_THREAD_H
 
-AFUN_CORE_EXPORT af_Environment *startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code,
-                                                bool derive_tmp, bool derive_guardian, bool derive_lr, bool enable);
-AFUN_CORE_EXPORT void tartRunThread_(af_Environment *env, af_Code *code);
+AFUN_CORE_EXPORT af_Environment *
+startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code, bool free_code, bool derive_tmp,
+               bool derive_guardian, bool derive_lr, bool enable);
+AFUN_CORE_EXPORT void startRunThread_(af_Environment *env, af_Code *code, bool free_code);
 
 #endif //AFUN_THREAD_H

include/tool/log_macro.h

@@ -94,7 +94,10 @@
 
 #endif
 
-#if (!aFunWriteTrack || !defined aFunConsoleTrack)
+#if defined aFunDEBUG
+#undef aFunConsoleTrack
+#define aFunConsoleTrack 1
+#elif (!aFunWriteTrack || !defined aFunConsoleTrack)
 #undef aFunConsoleTrack
 #define aFunConsoleTrack 0
 #endif

include/tool/time_s.h

@@ -2,6 +2,12 @@
 #define AFUN_TIME_H
 #include "aFunToolExport.h"
 
+#ifdef aFunWin32
+
+#else
+#include <unistd.h>
+#endif
+
 /* 时间工具 */
 AFUN_TOOL_EXPORT void safeSleep(double ms);
 AFUN_TOOL_EXPORT char *getTime(time_t *t, char *format);

src/core/__env.h

@@ -212,6 +212,7 @@ struct af_Environment {  // 运行环境
 
     bool is_derive;  // 是否派生
     struct af_Environment *base;  // 主线程
+    struct af_Environment *gc_env;  // 主线程的 gc线程
 
     struct af_Object *result;  // 线程执行的结果
     struct af_EnvironmentList *env_list;  // 主线程记录所有的子线程

src/core/env.c

@@ -84,9 +84,14 @@ static void mp_NORMAL(af_Message *msg, bool is_top, af_Environment *env);
 static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env);
 static void mp_IMPORT(af_Message *msg, bool is_top, af_Environment *env);
 
+typedef struct guardian_GC_data guardian_GC_data;
+struct guardian_GC_data{
+    time_t last_time;
+};
+
 /* 内置守护器 */
 static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char err[], af_Environment *env);
-static af_GuardianList *guardian_GC(char *type, bool is_guard, void *data, af_Environment *env);
+static af_GuardianList *guardian_GC(char *type, bool is_guard, guardian_GC_data *data, af_Environment *env);
 static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, af_Environment *env);
 
 /* 变量检查函数 */
@@ -842,11 +847,18 @@ static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char
  * 函数名: checkRunGC
  * 目标: 检查是否该运行gc, 若是则返回true并运行gc, 否则返回false
  */
-static af_GuardianList *guardian_GC(char *type, bool is_guard, void *data, af_Environment *env) {
+static af_GuardianList *guardian_GC(char *type, bool is_guard, guardian_GC_data *data, af_Environment *env) {
+    time_t now = clock();
+    if ((now - data->last_time) < 1 * CLOCKS_PER_SEC)  // 间隔 1s 再执行
+        return NULL;
+    data->last_time = now;
+
     af_GuardianList *gl = NULL;
     enum GcRunTime grt = getGcRun(env);
     if (grt == grt_always || grt == grt_count && getGcCount(env) >= getGcMax(env)) {
         GcCountToZero(env);  // 清零
+
+        writeDebugLog(aFunCoreLogger, "GC Run");
         gl = gc_RunGC(env);
         if (gl != NULL)
             writeDebugLog(aFunCoreLogger, "GC run destruct function");
@@ -916,7 +928,6 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
 
     /* 创建保护空间 */
     env->protect = makeVarSpace(NULL, 3, 3, 3, env);
-    gc_delReference(env->protect, env);
 
     /* 生成global对象 */
     env->global = makeGlobalObject(env);
@@ -934,19 +945,17 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
     addTopMsgProcess("IMPORT", func3, env);
     FREE_SYMBOL(func3);
 
-    /* 设置守护器 */
-    DLC_SYMBOL(GuardianFunc) func4 = MAKE_SYMBOL(guardian_Signal, GuardianFunc);
-    addGuardian("SIGNAL", false, false, 0, func4, NULL, NULL, env);
-    FREE_SYMBOL(func4);
-
-    DLC_SYMBOL(GuardianFunc) func5 = MAKE_SYMBOL(guardian_GC, GuardianFunc);
-    addGuardian("GC", true, false, 0, func5, NULL, NULL, env);
-    FREE_SYMBOL(func5);
-
     env->status = core_init;
     env->activity = makeTopActivity(NULL, NULL, env->protect, env->global);
+
     makeVarToProtectVarSpace("global", 3, 3, 3, env->global, env);
     gc_delReference(env->global, env);
+
+    af_Object *cycle = makeCycleObject(env);
+    makeVarToProtectVarSpace(mg_sys_cycle, 3, 3, 3, cycle, env);
+
+    gc_delReference(env->protect, env);
+    gc_delReference(cycle, env);
     return env;
 }
 
@@ -1018,8 +1027,29 @@ af_Environment *deriveEnvironment(bool derive_tmp, bool derive_guardian, bool de
 }
 
 void enableEnvironment(af_Environment *env) {
-    setVarSpaceProtect(NULL, env->protect, true);
     env->status = core_normal;
+    if (!env->is_derive) {  // 派生 gc 线程
+        setVarSpaceProtect(NULL, env->protect, true);
+
+        af_Environment *gc_env = startRunThread(env, NULL, NULL, true,
+                                                true, false, true, false);
+
+        /* 设置守护器 */
+        DLC_SYMBOL(GuardianFunc) func1 = MAKE_SYMBOL(guardian_Signal, GuardianFunc);
+        addGuardian("SIGNAL", false, false, 0, func1, NULL, NULL, gc_env);
+        FREE_SYMBOL(func1);
+
+        DLC_SYMBOL(GuardianFunc) func2 = MAKE_SYMBOL(guardian_GC, GuardianFunc);
+        addGuardian("GC", true, false, sizeof(guardian_GC_data),
+                    func2, NULL, NULL, gc_env);
+        FREE_SYMBOL(func2);
+
+        gc_env->status = core_normal;  // 手动启动env
+        af_Code *bt1 = makeElementCode(mg_sys_cycle, NUL, 1, "gc.aun.sys");
+        af_Code *bt2 = makeBlockCode(curly, bt1, NUL, 1, "gc.aun.sys", NULL);
+        startRunThread_(gc_env, bt2, true);
+        env->gc_env = gc_env;
+    }
 }
 
 bool freeEnvironment(af_Environment *env) {
@@ -1496,6 +1526,8 @@ bool setFuncActivityAddVar(af_Environment *env){
         env->activity->run_varlist = tmp;
         env->activity->count_run_varlist++;
         pthread_rwlock_unlock(&env->activity->gc_lock);
+
+        gc_delReference(tmp->vs, env);
     }
 
     if (fi->var_this && env->activity->belong != NULL) {
@@ -2313,6 +2345,9 @@ void waitForEnviromentExit(af_Environment *env) {
     env->status = core_exit;  // 不需要设置 exit_code
     pthread_mutex_unlock(&env->status_lock);
 
+    if (env->gc_env != NULL)
+        setEnviromentExit_out(env->gc_env);
+
     pthread_mutex_lock(&env->thread_lock);
     while (env->env_list != NULL)
         pthread_cond_wait(&env->thread_cond, &env->thread_lock);

src/core/gc.c

@@ -16,6 +16,7 @@ void gc_addObjectData(af_ObjectData *od, af_Environment *base){
     base->gc_factory->gc_ObjectData = od;
     GcCountAdd1(base);
     pthread_mutex_unlock(&base->gc_factory->mutex);
+    writeTrackLog(aFunCoreLogger, "Make ObjectData %p", od);
 }
 
 void gc_addObjectDataReference(af_ObjectData *od, af_Environment *base){
@@ -44,6 +45,7 @@ void gc_addObject(af_Object *obj, af_Environment *base){
     base->gc_factory->gc_Object = obj;
     GcCountAdd1(base);
     pthread_mutex_unlock(&base->gc_factory->mutex);
+    writeTrackLog(aFunCoreLogger, "Make Object %p", obj);
 }
 
 void gc_addObjectReference(af_Object *obj, af_Environment *base){
@@ -63,7 +65,6 @@ void gc_delObjectReference(af_Object *obj, af_Environment *base){
 }
 
 void gc_addVar(af_Var *var, af_Environment *base) {
-    pthread_mutex_lock(&base->gc_factory->mutex);
     var->gc.info.reference = 1;
     var->gc.prev = ((void *) 0);
     if (base->gc_factory->gc_Var != ((void *) 0))
@@ -71,7 +72,7 @@ void gc_addVar(af_Var *var, af_Environment *base) {
     var->gc.next = base->gc_factory->gc_Var;
     base->gc_factory->gc_Var = var;
     GcCountAdd1(base);
-    pthread_mutex_unlock(&base->gc_factory->mutex);
+    writeTrackLog(aFunCoreLogger, "Make Var %p", var);
 }
 
 void gc_addVarReference(af_Var *var, af_Environment *base) {
@@ -90,15 +91,21 @@ void gc_delVarReference(af_Var *var, af_Environment *base) {
     pthread_mutex_unlock(&base->gc_factory->mutex);
 }
 
+/**
+ * 将 VarSpace 添加到 gc 链中
+ * 只能由MakeVarSpace调用
+ * 注意: 不上锁
+ * @param vs
+ * @param base
+ */
 void gc_addVarSpace(af_VarSpace *vs, af_Environment *base){
-    pthread_mutex_lock(&base->gc_factory->mutex);
     vs->gc.info.reference = 1;
     vs->gc.prev = ((void *) 0);
     if (base->gc_factory->gc_VarSpace != ((void *) 0)) { base->gc_factory->gc_VarSpace->gc.prev = vs; }
     vs->gc.next = base->gc_factory->gc_VarSpace;
     base->gc_factory->gc_VarSpace = vs;
     GcCountAdd1(base);
-    pthread_mutex_unlock(&base->gc_factory->mutex);
+    writeTrackLog(aFunCoreLogger, "Make VarSpace %p", vs);
 }
 
 void gc_addVarSpaceReference(af_VarSpace *vs, af_Environment *base) {
@@ -143,6 +150,7 @@ af_GcList *makeGcList(enum af_GcListType type, void *data) {
     af_GcList *gl = calloc(1, sizeof(af_GcList));
     gl->type = type;
     gl->data = data;
+    assertWarningLog(data != NULL, aFunCoreLogger, "GcList not data write.");
     return gl;
 }
 
@@ -215,6 +223,7 @@ static pgc_Analyzed checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed plist);
 static pgc_Analyzed reachableObject(struct af_Object *obj, pgc_Analyzed plist) {
     for (NULL; obj != NULL && !obj->gc.info.reachable; obj = obj->belong) {
         obj->gc.info.reachable = true;
+        writeTrackLog(aFunCoreLogger, "Reachable Object %p -> data %p -> vs %p", obj, obj->data, obj->data->var_space);
 
         pthread_rwlock_rdlock(&obj->lock);
         if (!obj->data->gc.info.reachable)
@@ -225,41 +234,58 @@ static pgc_Analyzed reachableObject(struct af_Object *obj, pgc_Analyzed plist) {
 }
 
 static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed plist) {  // 暂时不考虑API调用
+    writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p wait", od);
     if (od->gc.info.reachable)
         return plist;
 
+    writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p -> vs %p", od, od->var_space);
     od->gc.info.reachable = true;
 
     pthread_rwlock_rdlock(&od->lock);
     plist = reachableVarSpace(od->var_space, plist);
-    if (!od->base->gc.info.reachable)
+    if (!od->base->gc.info.reachable) {
         plist = makeAnalyzed(od->base, plist);
+        writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p add object %p", od, od->base);
+    }
 
     for (af_Inherit *ih = od->inherit; ih != NULL; ih = getInheritNext(ih)) {
         af_Object *obj = getInheritObject(ih);
         af_VarSpace *vs = getInheritVarSpace(ih);
-        if (!obj->gc.info.reachable)
+        if (!obj->gc.info.reachable) {
+            writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p inherit add object %p", od, obj);
             plist = makeAnalyzed(obj, plist);
-        if (!vs->gc.info.reachable)
+        }
+
+        if (!vs->gc.info.reachable) {
+            writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p inherit add varspace %p", od, vs);
             plist = reachableVarSpace(vs, plist);
+        }
     }
 
     obj_getGcList *func = findAPI("obj_getGcList", od->api);
     if (func != NULL) {
         af_GcList *gl = func(od->id, od->base, od->data);
         for (af_GcList *tmp = gl; tmp != NULL; tmp = tmp->next) {
+            if (tmp->data == NULL)
+                continue;
+
             switch (tmp->type) {
                 case glt_obj:
-                    if (!tmp->obj->gc.info.reachable)
-                        plist = makeAnalyzed(od->base, plist);
+                    if (!tmp->obj->gc.info.reachable) {
+                        writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p gl add object %p", od, tmp->obj);
+                        plist = makeAnalyzed(tmp->obj, plist);
+                    }
                     break;
                 case glt_var:
+                    writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p gl add object %p", od, tmp->var);
                     plist = reachableVar(tmp->var, plist);
                     break;
                 case glt_vs:
+                    writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p gl add object %p", od, tmp->vs);
                     plist = reachableVarSpace(tmp->vs, plist);
                     break;
                 case glt_vsl:
+                    writeTrackLog(aFunCoreLogger, "Reachable ObjectData %p gl add object %p", od, tmp->vsl);
                     plist = reachableVarSpaceList(tmp->vsl, plist);
                     break;
                 default:
@@ -274,13 +300,19 @@ static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed p
 }
 
 static pgc_Analyzed reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed plist) {
+    writeTrackLog(aFunCoreLogger, "Reachable VarSpace %p wait", vs);
     if (vs->gc.info.reachable)
         return plist;
+
+    writeTrackLog(aFunCoreLogger, "Reachable VarSpace %p -> %p", vs, vs->belong);
     vs->gc.info.reachable = true;
 
     pthread_rwlock_rdlock(&vs->lock);
-    if (vs->belong != NULL)
+    if (vs->belong != NULL) {
         plist = makeAnalyzed(vs->belong, plist);
+        writeTrackLog(aFunCoreLogger, "Reachable VarSpace %p add object %p", vs, vs->belong);
+    }
+
     for (int i = 0; i < VAR_HASHTABLE_SIZE; i++) {
         for (af_VarCup *var = vs->var[i]; var != NULL; var = var->next)
             plist = reachableVar(var->var, plist);
@@ -291,14 +323,19 @@ static pgc_Analyzed reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed plist
 }
 
 static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
+    writeTrackLog(aFunCoreLogger, "Reachable Var %p wait", var);
     if (var->gc.info.reachable)
         return plist;
+
+    writeTrackLog(aFunCoreLogger, "Reachable VarSpace %p -> %p [%s]", var, var->vn->obj, var->name);
     var->gc.info.reachable = true;
 
     pthread_rwlock_rdlock(&var->lock);
     for (af_VarNode *vn = var->vn; vn != NULL; vn = vn->next) {
-        if (!vn->obj->gc.info.reachable)
+        if (!vn->obj->gc.info.reachable) {
             plist = makeAnalyzed(vn->obj, plist);
+            writeTrackLog(aFunCoreLogger, "Reachable Var %p add object %p", var, vn->obj);
+        }
     }
     pthread_rwlock_unlock(&var->lock);
     return plist;
@@ -373,6 +410,7 @@ static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist) {
         if (activity->parentheses_call != NULL)
             plist = reachableObject(activity->parentheses_call, plist);
 
+        plist = reachableVarSpaceList(activity->out_varlist, plist);
         plist = reachableVarSpaceList(activity->func_varlist, plist);
         plist = reachableVarSpaceList(activity->macro_varlist, plist);
         pthread_rwlock_unlock(&activity->gc_lock);
@@ -411,7 +449,7 @@ static void freeValue(af_Environment *env) {
     for (af_ObjectData *od = env->gc_factory->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
         if (!od->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "ObjectData: %p", od);
+            writeTrackLog(aFunCoreLogger, "GC free ObjectData: %p", od);
             freeObjectData(od, env);
         }
     }
@@ -419,7 +457,7 @@ static void freeValue(af_Environment *env) {
     for (af_Object *obj = env->gc_factory->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
         if (!obj->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "Object: %p", obj);
+            writeTrackLog(aFunCoreLogger, "GC free Object: %p", obj);
             freeObject(obj, env);
         }
     }
@@ -427,7 +465,7 @@ static void freeValue(af_Environment *env) {
     for (af_VarSpace *vs = env->gc_factory->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
         if (!vs->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "VarSpace: %p", vs);
+            writeTrackLog(aFunCoreLogger, "GC free VarSpace: %p [%p]", vs, vs->belong);
             freeVarSpace(vs, env);
         }
     }
@@ -435,7 +473,7 @@ static void freeValue(af_Environment *env) {
     for (af_Var *var = env->gc_factory->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
         if (!var->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "Var: %p", var);
+            writeTrackLog(aFunCoreLogger, "GC free Var: %p [%s]", var, var->name);
             freeVar(var, env);
         }
     }
@@ -476,6 +514,7 @@ af_GuardianList *gc_RunGC(af_Environment *env) {
     paf_GuardianList pgl = &gl;
     af_Environment *base = env->base;
 
+    pthread_mutex_lock(&base->gc_factory->mutex);
     resetGC(base);
     plist = iterLinker(base, plist);  // 临时量分析 (临时量都是通过reference标记的)
     plist = iterEnvironment(base, plist);
@@ -489,6 +528,7 @@ af_GuardianList *gc_RunGC(af_Environment *env) {
     plist = checkDestruct(base, &pgl, plist);  // 在检查析构
     checkAnalyzed(analyzed, plist);  // 在处理 checkDestruct 时产生的新引用
 
+    pthread_mutex_unlock(&base->gc_factory->mutex);
     freeValue(base);
     freeAllAnalyzed(analyzed);
     return gl;
@@ -502,8 +542,10 @@ af_GuardianList *gc_RunGC(af_Environment *env) {
  * @return
  */
 paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
-    pthread_mutex_lock(&env->gc_factory->mutex);
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
+    af_Environment *base = env->base;
+
+    pthread_mutex_lock(&base->gc_factory->mutex);
+    for (af_ObjectData *od = base->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (!od->gc.done_destruct) {
             af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, NULL, od, env);
             if (func == NULL)
@@ -511,14 +553,13 @@ paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
             od->gc.done_destruct = true;
 
             pthread_rwlock_rdlock(&od->lock);
-            af_Object *base = od->base;
+            af_Object *base_obj = od->base;
             pthread_rwlock_unlock(&od->lock);
-            gc_addReference(base, env);
-
-            pgl = pushGuardianList(base, func, pgl, env);
+            gc_addReference(base_obj, env);
+            pgl = pushGuardianList(base_obj, func, pgl, env);
         }
     }
-    pthread_mutex_unlock(&env->gc_factory->mutex);
+    pthread_mutex_unlock(&base->gc_factory->mutex);
     return pgl;
 }
 
@@ -527,11 +568,13 @@ paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
  * @param env
  */
 void gc_freeAllValueData(af_Environment *env) {
-    pthread_mutex_lock(&env->gc_factory->mutex);
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
+    af_Environment *base = env->base;
+
+    pthread_mutex_lock(&base->gc_factory->mutex);
+    for (af_ObjectData *od = base->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
         freeObjectDataData(od, env);
     }
-    pthread_mutex_unlock(&env->gc_factory->mutex);
+    pthread_mutex_unlock(&base->gc_factory->mutex);
 }
 
 /**
@@ -539,27 +582,29 @@ void gc_freeAllValueData(af_Environment *env) {
  * @param env
  */
 void gc_freeAllValue(af_Environment *env) {
-    pthread_mutex_lock(&env->gc_factory->mutex);
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData, *next; od != NULL; od = next) {
+    af_Environment *base = env->base;
+
+    pthread_mutex_lock(&base->gc_factory->mutex);
+    for (af_ObjectData *od = base->gc_factory->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
         freeObjectData(od, env);
     }
 
-    for (af_Object *obj = env->gc_factory->gc_Object, *next; obj != NULL; obj = next) {
+    for (af_Object *obj = base->gc_factory->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
         freeObject(obj, env);
     }
 
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace, *next; vs != NULL; vs = next) {
+    for (af_VarSpace *vs = base->gc_factory->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
         freeVarSpace(vs, env);
     }
 
-    for (af_Var *var = env->gc_factory->gc_Var, *next; var != NULL; var = next) {
+    for (af_Var *var = base->gc_factory->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
         freeVar(var, env);
     }
-    pthread_mutex_unlock(&env->gc_factory->mutex);
+    pthread_mutex_unlock(&base->gc_factory->mutex);
 }
 
 /**
@@ -571,36 +616,36 @@ void printGCByCore(af_Environment *env) {
     bool success = true;
     for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (od->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "af_ObjectData(%p) Reference: %d", od, od->gc.info.reference);
+            writeWarningLog(aFunCoreLogger, "GC Reference ObjectData(%p): %d", od, od->gc.info.reference);
             success = false;
         } else
-            writeTrackLog(aFunCoreLogger, "af_ObjectData(%p) Reference: %d", od, od->gc.info.reference);
+            writeTrackLog(aFunCoreLogger, "GC Reference ObjectData(%p): %d", od, od->gc.info.reference);
     }
 
     for (af_Object *obj = env->gc_factory->gc_Object; obj != NULL; obj = obj->gc.next) {
         if (obj->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "af_Object(%p->%p) Reference: %d", obj, obj->data, obj->gc.info.reference);
+            writeWarningLog(aFunCoreLogger, "GC Reference Object(%p->%p): %d", obj, obj->data, obj->gc.info.reference);
             success = false;
         } else
-            writeTrackLog(aFunCoreLogger, "af_Object(%p->%p) Reference: %d", obj, obj->data, obj->gc.info.reference);
+            writeTrackLog(aFunCoreLogger, "GC Reference Object(%p->%p): %d", obj, obj->data, obj->gc.info.reference);
     }
 
     for (af_VarSpace *vs = env->gc_factory->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
         if (vs->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "af_VarSpace(%p) Reference: %d", vs, vs->gc.info.reference);
+            writeWarningLog(aFunCoreLogger, "GC Reference VarSpace(%p): %d", vs, vs->gc.info.reference);
             success = false;
         } else
-            writeTrackLog(aFunCoreLogger, "af_VarSpace(%p) Reference: %d", vs, vs->gc.info.reference);
+            writeTrackLog(aFunCoreLogger, "GC Reference VarSpace(%p): %d", vs, vs->gc.info.reference);
     }
 
     for (af_Var *var = env->gc_factory->gc_Var; var != NULL; var = var->gc.next) {
         if (var->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "af_Var(%p) Reference: %d", var, var->gc.info.reference);
+            writeWarningLog(aFunCoreLogger, "GC Reference Var(%p): %d", var, var->gc.info.reference);
             success = false;
         } else
-            writeTrackLog(aFunCoreLogger, "af_Var(%p) Reference: %d", var, var->gc.info.reference);
+            writeTrackLog(aFunCoreLogger, "GC Reference Var(%p): %d", var, var->gc.info.reference);
     }
 
     if (!success)
-        writeWarningLog(aFunCoreLogger, "gc warning.");
+        writeWarningLog(aFunCoreLogger, "GC Reference warning.");
 }

src/core/global_obj.c

@@ -38,8 +38,7 @@ static af_GcList *getGcList(char *id, af_Object *obj, GlobalObjectData *data) {
 
     if (data->share != NULL)
         return pushGcList(glt_vs, data->share, NULL);
-    else
-        return NULL;
+    return NULL;
 }
 
 
@@ -75,3 +74,109 @@ af_Object *makeGlobalObject(af_Environment *env) {
 
     return makeObject(global_id, true, api, true, NULL, true, NULL, env);
 }
+
+size_t getSizec_Cycle(char *id, af_Object *obj) {
+    return sizeof(af_VarSpaceListNode *);
+}
+
+void initDatac_Cycle(char *id, af_Object *obj, af_VarSpaceListNode **data, af_Environment *env) {
+    *data = makeVarSpaceList(getProtectVarSpace(env));
+}
+
+void freeDatac_Cycle(char *id, af_Object *obj, af_VarSpaceListNode **data, af_Environment *env) {
+    freeAllVarSpaceList(*data);
+}
+
+typedef struct CycleMark CycleMark;
+struct CycleMark {
+    af_FuncInfo *fi;
+    af_FuncBody *body;
+};
+
+af_FuncBody *func_Cycle(af_CallFuncInfo *cfi, af_Environment *env) {  // 测试用函数
+    CycleMark *mark = cfi->mark;
+    cfi->body_next = mark->body;
+    pushMessageDown(makeNORMALMessage(getGlobal(env), env), env);
+    return NULL;
+}
+
+bool getInfoc_Cycle(char *id, af_Object *obj, af_FuncInfo **fi, af_Code *code, CycleMark *mark, af_Environment *env) {
+    mark->fi = makeFuncInfo(normal_scope, not_embedded, false, false, false);
+    *fi = mark->fi;
+    
+    DLC_SYMBOL(callFuncBody) func = MAKE_SYMBOL(func_Cycle, callFuncBody);
+    makeCFuncBodyToFuncInfo(func, NULL, mark->fi);  // 压入两个相同的 body
+    makeCFuncBodyToFuncInfo(func, NULL, mark->fi);
+    mark->body = mark->fi->body;
+    FREE_SYMBOL(func);
+    
+    return true;
+}
+
+bool getAclc_Cycle(char *id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, CycleMark **mark, af_Environment *env) {
+    *acl = NULL;
+    *mark = calloc(1, sizeof(CycleMark));
+    return true;
+}
+
+bool getVslc_Cycle(char *id, af_Object *obj, af_VarSpaceListNode **vsl, CycleMark *mark, af_Environment *env) {
+    *vsl = *(af_VarSpaceListNode **)getObjectData(obj);
+    return true;
+}
+
+af_GcList *getGcListc_Cycle(char *id, af_Object *obj, void *data) {
+    af_GcList *gl = pushGcList(glt_vsl, *(af_VarSpaceListNode **)data, NULL);
+    return gl;
+}
+
+bool getAlc_Cycle(char *id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, CycleMark *mark, af_Environment *env) {
+    *al = NULL;
+    return true;
+}
+
+void freeMarkc_Cycle(char *id, af_Object *obj, CycleMark *mark) {
+    free(mark);
+}
+
+af_Object *makeCycleObject(af_Environment *env) {
+    af_ObjectAPI *api = makeObjectAPI();
+    DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAclc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVslc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAlc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfoc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMarkc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcListc_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) get_size = MAKE_SYMBOL(getSizec_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) init_data = MAKE_SYMBOL(initDatac_Cycle, objectAPIFunc);
+    DLC_SYMBOL(objectAPIFunc) free_data = MAKE_SYMBOL(freeDatac_Cycle, objectAPIFunc);
+    if (addAPI(get_size, "obj_getDataSize", api) != 1)
+        return NULL;
+    if (addAPI(init_data, "obj_initData", api) != 1)
+        return NULL;
+    if (addAPI(free_data, "obj_destructData", api) != 1)
+        return NULL;
+    if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+        return NULL;
+    if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+        return NULL;
+    if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+        return NULL;
+    if (addAPI(get_info, "obj_funcGetInfo", api) != 1)
+        return NULL;
+    if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+        return NULL;
+    if (addAPI(get_gl, "obj_getGcList", api) != 1)
+        return NULL;
+
+    FREE_SYMBOL(get_alc);
+    FREE_SYMBOL(get_vsl);
+    FREE_SYMBOL(get_al);
+    FREE_SYMBOL(get_info);
+    FREE_SYMBOL(free_mark);
+    FREE_SYMBOL(get_gl);
+    FREE_SYMBOL(get_size);
+    FREE_SYMBOL(init_data);
+    FREE_SYMBOL(free_data);
+
+    return makeObject("func", true, api, true, NULL, true, NULL, env);
+}

src/core/object.c

@@ -2,6 +2,7 @@
 #include "__env.h"
 #include "__gc.h"
 #include "tool.h"
+#include "core_init.h"
 
 /* ObjectData 创建与释放 */
 static af_ObjectData * makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Object *base_obj,
@@ -34,24 +35,17 @@ 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(base_obj, 3, 2, 0, env);
-    gc_delReference(od->var_space, env);
-
     od->inherit = NULL;
 
     obj_getDataSize *func = findAPI("obj_getDataSize", api);
-    obj_initData *init = findAPI("obj_initData", api);
     if (func != NULL)
         od->size = func(id, base_obj);
     else
         od->size = 0;
 
-    if (od->size != 0) {
+    if (od->size != 0)
         od->data = calloc(1, od->size);
-        if (init != NULL)
-            init(id, base_obj, od->data, env);
-    }
 
     pthread_rwlock_init(&od->lock, NULL);
     gc_addObjectData(od, env->base);
@@ -89,7 +83,7 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
         if (env->global != NULL)
             ih = makeInherit(env->global);
         else if (status != core_creat)
-            return NULL;
+            writeFatalErrorLog(aFunCoreLogger, 1, "Make object inherit null");
     }
 
     if (belong == NULL) {
@@ -98,7 +92,7 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
         else if (status == core_init)  // init模式生成: global
             belong = env->global;
         else if (status != core_creat)  // 只有creat可以使用belong=NULL
-            return NULL;
+            writeFatalErrorLog(aFunCoreLogger, 1, "Make object belong null");
     }
 
     af_Object *obj = makeObject_Pri(id, free_api, api, allow_inherit, env);
@@ -106,7 +100,13 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
     obj->belong = belong;
     obj->data->inherit = ih;
     obj->data->free_inherit = free_inherit;
-    gc_delReference(obj->data, env);  // od已经被obj引用, 并且不再是临时变量
+
+    if (obj->data->size != 0) {
+        obj_initData *init = findAPI("obj_initData", obj->data->api);
+        if (init != NULL)
+            init(id, obj, obj->data->data, env);
+    }
+
     return obj;
 }
 
@@ -425,6 +425,10 @@ af_Object *findObjectAttributes(char *name, af_Object *visitor, af_Object *obj,
     return NULL;
 }
 
+/**
+ * 添加属性到Object中
+ * 注意: 必须保证 obj 又被 gc 引用
+ */
 bool setObjectAttributes(char *name, char p_self, char p_posterity, char p_external, af_Object *attributes,
                          af_Object *obj, af_Object *visitor, af_Environment *env){
     return makeVarToVarSpace(name, p_self, p_posterity, p_external, attributes, getObjectVarSpace(obj), visitor, env);

src/core/thread.c

@@ -6,6 +6,7 @@
 struct EnvCode {
     af_Environment *env;
     af_Code *code;
+    bool free_code;
 };
 
 static void *runThread(void *ec);
@@ -17,8 +18,8 @@ static void *runThread(void *ec);
  * @param vs 压入的变量空间
  * @param code 执行的代码
  */
-af_Environment *startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code,
-                               bool derive_tmp, bool derive_guardian, bool derive_lr, bool enable) {
+af_Environment *startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code, bool free_code, bool derive_tmp,
+                               bool derive_guardian, bool derive_lr, bool enable){
     af_Environment *base = env->base;
     af_Environment *new = deriveEnvironment(derive_tmp, derive_guardian, derive_lr, enable, base);
 
@@ -34,24 +35,17 @@ af_Environment *startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *co
     new->activity->count_run_varlist++;
     gc_delReference(vs, base);
 
-    if (!enable)  // 如果未Enable, 则暂时不启动线程
-        return new;
-
-    struct EnvCode *ec = calloc(1, sizeof(struct EnvCode));
-    ec->env = new;
-    ec->code = code;
-
-    pthread_t id;
-    pthread_create(&id, NULL, runThread, ec);
-    pthread_detach(id);
+    if (enable)  // 如果未Enable, 则暂时不启动线程
+        startRunThread_(new, code, free_code);
     return new;
 }
 
 
-void tartRunThread_(af_Environment *env, af_Code *code) {
+void startRunThread_(af_Environment *env, af_Code *code, bool free_code){
     struct EnvCode *ec = calloc(1, sizeof(struct EnvCode));
     ec->env = env;
     ec->code = code;
+    ec->free_code = free_code;
 
     pthread_t id;
     pthread_create(&id, NULL, runThread, ec);
@@ -62,6 +56,7 @@ void tartRunThread_(af_Environment *env, af_Code *code) {
 static void *runThread(void *ec) {
     af_Environment *env = ((struct EnvCode *)ec)->env;
     af_Code *code = ((struct EnvCode *)ec)->code;
+    bool free_code = ((struct EnvCode *)ec)->free_code;
     free(ec);
 
     writeInfoLog(aFunCoreLogger, "Thread start");
@@ -70,6 +65,9 @@ static void *runThread(void *ec) {
     writeInfoLog(aFunCoreLogger, "Thread free");
     freeEnvironment(env);
 
+    if (free_code)
+        freeAllCode(code);
+
     writeInfoLog(aFunCoreLogger, "Thread end");
     return NULL;
 }

src/core/var.c

@@ -1,6 +1,8 @@
 #include "__var.h"
+#include "core_init.h"
 #include "tool.h"
 
+
 /* VarNode 创建与释放 */
 static af_VarNode *makeVarNode(af_Object *obj, char *id);
 static af_VarNode *freeVarNode(af_VarNode *vn);
@@ -42,6 +44,8 @@ static void freeAllVarNode(af_VarNode *vn) {
 }
 
 af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env){
+    pthread_mutex_lock(&env->base->gc_factory->mutex);
+
     af_VarNode *vn = makeVarNode(obj, NULL);
     af_Var *var = calloc(1, sizeof(af_Var));
     var->name = strCopy(name);
@@ -51,6 +55,8 @@ af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_O
     var->permissions[2] = p_external;
     pthread_rwlock_init(&var->lock, NULL);
     gc_addVar(var, env->base);
+
+    pthread_mutex_unlock(&env->base->gc_factory->mutex);
     return var;
 }
 
@@ -128,8 +134,8 @@ static void freeAllVarCup(af_VarCup *vp) {
 }
 
 af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char p_external, af_Environment *env){
-    if (getCoreStatus(env) != core_creat && belong == NULL)
-        return NULL;
+    assertFatalErrorLog(getCoreStatus(env) == core_creat || belong != NULL, aFunCoreLogger, 1, "makeVarSpace error");
+    pthread_mutex_lock(&env->base->gc_factory->mutex);
 
     af_VarSpace *vs = calloc(1, sizeof(af_VarSpace));
     vs->belong = belong;
@@ -139,6 +145,8 @@ af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char
 
     pthread_rwlock_init(&vs->lock, NULL);
     gc_addVarSpace(vs, env->base);
+
+    pthread_mutex_unlock(&env->base->gc_factory->mutex);
     return vs;
 }
 
@@ -263,12 +271,12 @@ RETURN_FALSE:
     return false;
 }
 
-/*
- * 函数名: makeVarToVarSpace
- * 目标: 创建一个新的var添加到VarSpace中
+/**
+ * 创建一个新的var添加到VarSpace中
  * 若已存在同名Var则返回false不作修改
  * 否则返回true
  * 调用 addVarToVarSpace
+ * 注意: 必须保证 VarSpace被 gc 引用
  */
 bool makeVarToVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_VarSpace *vs,
                        af_Object *visitor, af_Environment *env){
@@ -293,11 +301,11 @@ bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarSpaceListNode *
     return false;
 }
 
-/*
- * 函数名: makeVarToVarSpace
- * 目标: 创建一个新的var到VarSpaceList
+/**
+ * 创建一个新的var到VarSpaceList
  * 自动跳过保护空间
  * 调用 addVarToVarSpaceList -> addVarToVarSpace
+ * 注意: 必须保证 VarSpace被 gc 引用
  */
 bool makeVarToVarSpaceList(char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
                            af_VarSpaceListNode *vsl, af_Object *visitor, af_Environment *env){
@@ -308,9 +316,8 @@ bool makeVarToVarSpaceList(char *name, char p_self, char p_posterity, char p_ext
     return false;
 }
 
-/*
- * 函数名: makeVarToProtectVarSpace
- * 目标: 创建一个新的var变量添加到保护空间中
+/**
+ * 创建一个新的var变量添加到保护空间中
  * 若已存在同名Var则返回false不作修改
  * 否则返回true
  * 调用 addVarToVarSpace
@@ -623,7 +630,6 @@ af_VarSpaceListNode *pushNewVarList(af_Object *belong, af_VarSpaceListNode *base
     af_VarSpace *vs = makeVarSpace(belong, 3, 2, 0, env);
     af_VarSpaceListNode *new = makeVarSpaceList(vs);
     new->next = base;
-    gc_delReference(vs, env);
     return new;
 }
 

src/runtime/base/base.c

@@ -2,8 +2,14 @@
 
 int aFunTool_base(af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
     writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base %p", vs);
+
     makeLiteralRegexFromList(literal, env);
+    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base literal success");
+
     makeStrFunc(visitor, vs, env);
+    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base str success");
+
     makeQuitFunc(visitor, vs, env);
+    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base quit success");
     return 0;
 }

src/runtime/base/str_obj.c

@@ -72,8 +72,7 @@ static af_FuncBody *strFuncBody(af_CallFuncInfo *cfi, af_Environment *env) {
     af_Object *obj = cfi->func;
     ObjectStrFunc *osf = getObjectData(obj);
     af_Object *str = makeObject((char *) string_id, false, osf->api, false, NULL, true, makeInherit(obj), env);
-    af_Message *msg = makeNORMALMessage(str, env);
-    pushMessageDown(msg, env);
+    pushMessageDown(makeNORMALMessage(str, env), env);
     return NULL;
 }
 
@@ -85,6 +84,12 @@ static bool strFuncGetInfo(char *id, af_Object *obj, af_FuncInfo **fi, af_Code *
     return true;
 }
 
+static af_GcList *strFuncGetGc(char *id, af_Object *obj, ObjectStrFunc *data) {
+    af_GcList *gl = pushGcList(glt_vsl, data->func_var_list, NULL);
+    gl = pushGcList(glt_vs, data->share_vs, gl);
+    return gl;
+}
+
 static void strFuncDestruct(char *id, af_Object *obj, ObjectStrFunc *data, af_Environment *env) {
     if (EQ_STR(id, string_func_id)) {
         freeObjectAPI(data->api);
@@ -101,6 +106,7 @@ void makeStrFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
             {.name="obj_funcGetVarList", .func=strFuncVarList, .dlc=NULL},
             {.name="obj_funcGetArgList", .func=strFuncArgList, .dlc=NULL},
             {.name="obj_funcGetInfo", .func=strFuncGetInfo, .dlc=NULL},
+            {.name="obj_getGcList", .func=strFuncGetGc, .dlc=NULL},
             {.name=NULL}
     };
 

src/runtime/runtime.c

@@ -8,11 +8,12 @@ static const ToolFunc global_tool_list[] = {
         {.name=NULL, .func=NULL},
 };
 
-/*
- * 函数名: runtimeTool
+/**
+ * runtimeTool
  * 目标: 调用指定内置包(tool)
  * 返回 (0)   执行正常
  * 返回 (1)  库不存在
+ * 必须保证 vs 有被 gc 引用
  */
 int runtimeTool(char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
     if (name == NULL || code == NULL || env == NULL || vs == NULL)
@@ -36,7 +37,7 @@ int runtimeTool(char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs,
 int runtimeToolImport(char *name, af_Object **obj, af_Code **code, af_Environment *env) {
     if (name == NULL || code == NULL || env == NULL || obj == NULL)
         return 1;
-    *obj = makeGlobalObject(env);
+    *obj = makeGlobalObject(env);  // 保留 gc 引用
     return runtimeTool(name, code, *obj, getObjectVarSpace((*obj)), env);
 }
 
@@ -64,9 +65,9 @@ af_ObjectAPI *makeAPIFromList(const APIFuncList api_list[]) {
     return api;
 }
 
-/*
- * 函数名: makeObjectFromList
- * 目标: 根据ObjectDefineList生成Object, 并保存到对应位置和变量空间中
+/**
+ * 根据ObjectDefineList生成Object, 并保存到对应位置和变量空间中
+ * 必须保证 VarSpace 有被 gc 引用
  */
 void makeObjectFromList(const ObjectDefineList obj_def[], af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
     for (const ObjectDefineList *od = obj_def; od->id != NULL; od++) {

src/tool/log.c

@@ -266,13 +266,13 @@ static void writeLogToFactory_(LogLevel level, char *id, pid_t tid, char *ti, ti
  * @param info 日志内容
  */
 static void writeLogToConsole_(LogLevel level, char *id, pid_t tid, char *ti, time_t t, char *file, int line, char *func, char *info) {
-#define FORMAT_SHORT "\r* %s[%d](%s:%d) : %s \n"  // 显示到终端, 添加\r回车符确保顶行显示
+#define FORMAT_SHORT "\r* %s[%d] %d (%s:%d) : %s \n"  // 显示到终端, 添加\r回车符确保顶行显示
 #define STD_BUF_SIZE (STR_LEN(info) + 1024)
     if (level < log_warning) {
-        printf_stdout(STD_BUF_SIZE, FORMAT_SHORT, LogLevelNameLong[level], tid, file, line, info);
+        printf_stdout(STD_BUF_SIZE, FORMAT_SHORT, LogLevelNameLong[level], tid, t, file, line, info);
         fflush(stdout);
     } else {
-        printf_stderr(STD_BUF_SIZE, FORMAT_SHORT, LogLevelNameLong[level], tid, file, line, info);
+        printf_stderr(STD_BUF_SIZE, FORMAT_SHORT, LogLevelNameLong[level], tid, t, file, line, info);
         fflush(stderr);
     }
 #undef FORMAT_SHORT

test/src/run_code.c

@@ -26,6 +26,7 @@ size_t getSize_Normal(char *id, af_Object *obj) {
 
 void initData_Normal(char *id, af_Object *obj, af_VarSpaceListNode **data, af_Environment *env) {
     *data = makeVarSpaceList(getProtectVarSpace(env));
+    printf("initData_Normal(): VarSpace %p\n", *data);
 }
 
 void freeData_Normal(char *id, af_Object *obj, af_VarSpaceListNode **data, af_Environment *env) {
@@ -408,7 +409,7 @@ int main(int argc, char **argv) {
 
     aFunInitInfo info = {
             .base_dir=base_path,
-            .level=log_debug,
+            .level=log_track,
             .log_asyn=true,
             .buf=&main_buf
     };
@@ -511,421 +512,381 @@ INIT_ERROR:
         printf("func-normal(%p)\n", obj);
     }
 
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info2 = MAKE_SYMBOL(getInfo_Macro, objectAPIFunc);  // 宏函数
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info2, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("macro", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info2);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("macro(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info3 = MAKE_SYMBOL(getInfo_Tail, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info3, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-tail", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info3);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-tail(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info4 = MAKE_SYMBOL(getInfo_Obj, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) obj_func = MAKE_SYMBOL(isObjTrue, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info4, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(obj_func, "obj_isObjFunc", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-obj", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info4);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(obj_func);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-obj(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info5 = MAKE_SYMBOL(getInfo_Gc, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info5, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-gc", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info5);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-gc(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_Object *obj = makeObject("func", true, makeObjectAPI(), true, NULL, true, NULL, env);
-        af_Object *des;
-
-        {
-            af_ObjectAPI *api = makeObjectAPI();
-            DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-            DLC_SYMBOL(objectAPIFunc) get_info6 = MAKE_SYMBOL(getInfo_GcDestruct, objectAPIFunc);
-            DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-            DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-            DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-            DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-            if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-                goto RETURN_2;
-            if (addAPI(initData_2, "obj_initData", api) != 1)
-                goto RETURN_2;
-            if (addAPI(freeData_2, "obj_destructData", api) != 1)
-                goto RETURN_2;
-            if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-                goto RETURN_2;
-            if (addAPI(get_info6, "obj_funcGetInfo", api) != 1)
-                goto RETURN_2;
-            if (addAPI(get_gl, "obj_getGcList", api) != 1)
-                goto RETURN_2;
-            des = makeObject("func-des", true, api, true, NULL, true, NULL, env);
-            FREE_SYMBOL(get_vsl);
-            FREE_SYMBOL(get_info6);
-            FREE_SYMBOL(get_gl);
-            FREE_SYMBOL(getSize_2);
-            FREE_SYMBOL(initData_2);
-            FREE_SYMBOL(freeData_2);
-        }
-
-        setObjectAttributes(mg_gc_destruct, 3, 3, 3, des, obj, obj, env);
-        makeVarToProtectVarSpace("func6", 3, 3, 3, obj, env);
-        printf("func6(%p), des(%p)\n", obj, des);
-        gc_delReference(obj, env);
-        gc_delReference(des, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info9 = MAKE_SYMBOL(getInfo_Dynamic, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info9, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-body-dynamic", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info9);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-body-dynamic(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfo_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) infix_func = MAKE_SYMBOL(isInfixTrue, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(infix_func, "obj_isInfixFunc", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-brackets", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        FREE_SYMBOL(infix_func);
-        printf("func-brackets(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info10 = MAKE_SYMBOL(getInfo_NotVar, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info10, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-no-var", 3, 3, 3,
-                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info10);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-no-var(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
-
-    {
-        af_ObjectAPI *api = makeObjectAPI();
-        af_Object *obj;
-        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_info11 = MAKE_SYMBOL(getInfo_Import, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
-        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
-        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
-            goto RETURN_2;
-        if (addAPI(initData_2, "obj_initData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(freeData_2, "obj_destructData", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_info11, "obj_funcGetInfo", api) != 1)
-            goto RETURN_2;
-        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-            goto RETURN_2;
-        if (addAPI(get_gl, "obj_getGcList", api) != 1)
-            goto RETURN_2;
-
-        makeVarToProtectVarSpace("func-import", 3, 3, 3,
-                                        (obj =makeObject("func", true, api, true, NULL, true, NULL, env)), env);
-        FREE_SYMBOL(get_alc);
-        FREE_SYMBOL(get_vsl);
-        FREE_SYMBOL(get_al);
-        FREE_SYMBOL(get_info11);
-        FREE_SYMBOL(free_mark);
-        FREE_SYMBOL(get_gl);
-        FREE_SYMBOL(getSize_2);
-        FREE_SYMBOL(initData_2);
-        FREE_SYMBOL(freeData_2);
-        printf("func-import(%p)\n", obj);
-        gc_delReference(obj, env);
-    }
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info2 = MAKE_SYMBOL(getInfo_Macro, objectAPIFunc);  // 宏函数
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info2, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("macro", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info2);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("macro(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info3 = MAKE_SYMBOL(getInfo_Tail, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info3, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-tail", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info3);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-tail(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info4 = MAKE_SYMBOL(getInfo_Obj, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) obj_func = MAKE_SYMBOL(isObjTrue, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info4, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(obj_func, "obj_isObjFunc", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-obj", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info4);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(obj_func);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-obj(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info5 = MAKE_SYMBOL(getInfo_Gc, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info5, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-gc", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info5);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-gc(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info9 = MAKE_SYMBOL(getInfo_Dynamic, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info9, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-body-dynamic", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info9);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-body-dynamic(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfo_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) infix_func = MAKE_SYMBOL(isInfixTrue, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(infix_func, "obj_isInfixFunc", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-brackets", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        FREE_SYMBOL(infix_func);
+//        printf("func-brackets(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info10 = MAKE_SYMBOL(getInfo_NotVar, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info10, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-no-var", 3, 3, 3,
+//                                        (obj = makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info10);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-no-var(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
+//
+//    {
+//        af_ObjectAPI *api = makeObjectAPI();
+//        af_Object *obj;
+//        DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAcl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVsl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_info11 = MAKE_SYMBOL(getInfo_Import, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData_Normal, objectAPIFunc);
+//        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData_Normal, objectAPIFunc);
+//        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(initData_2, "obj_initData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(freeData_2, "obj_destructData", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_info11, "obj_funcGetInfo", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
+//            goto RETURN_2;
+//        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+//            goto RETURN_2;
+//
+//        makeVarToProtectVarSpace("func-import", 3, 3, 3,
+//                                        (obj =makeObject("func", true, api, true, NULL, true, NULL, env)), env);
+//        FREE_SYMBOL(get_alc);
+//        FREE_SYMBOL(get_vsl);
+//        FREE_SYMBOL(get_al);
+//        FREE_SYMBOL(get_info11);
+//        FREE_SYMBOL(free_mark);
+//        FREE_SYMBOL(get_gl);
+//        FREE_SYMBOL(getSize_2);
+//        FREE_SYMBOL(initData_2);
+//        FREE_SYMBOL(freeData_2);
+//        printf("func-import(%p)\n", obj);
+//        gc_delReference(obj, env);
+//    }
 
     {
         af_Object *obj = getGlobal(env);
@@ -933,6 +894,7 @@ INIT_ERROR:
         gc_delReference(obj, env);
     }
     printf("\n");
+    sleep(2);
 
     {  // 正常程序
         printf("TAG A: [Normal test]\n");
@@ -942,22 +904,6 @@ INIT_ERROR:
 
         af_Code *bt3 = makeElementCode("func-normal", 0, 1, NULL);
         af_Code *bt5 = makeBlockCode(curly, bt3, 0, 1, NULL, NULL);
-        pushCode(&bt2, bt5);
-
-        af_Code *bt6 = makeElementCode("global", 0, 1, NULL);
-        pushCode(&bt5, bt6);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 宏函数
-        printf("TAG L: [Macro test]\n");
-        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagl.aun");
-
-        af_Code *bt3 = makeElementCode("macro", 0, 1, NULL);
-        af_Code *bt5 = makeBlockCode(curly, bt3, 0, 1, NULL, NULL);
         pushCode(&bt1, bt5);
 
         af_Code *bt6 = makeElementCode("global", 0, 1, NULL);
@@ -968,280 +914,298 @@ INIT_ERROR:
         printf("\n");
     }
 
-    {  // 测试顺序执行 '(xxx)
-        printf("TAG E: [ex]\n");
-        af_Code *bt3 = makeElementCode("data2", 0, 0, NULL);
-        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
-
-        pushCode(&bt3, bt4);
-
-        af_Code *bt5 = makeBlockCode(parentheses, bt3, '\'', 1, "Tage.aun", NULL);
-
-        runCodeFromMemory(bt5, 0, env);
-        freeAllCode(bt5);
-        printf("\n");
-    }
-
-    {  // 尾调用优化
-        printf("TAG B: [Tail test]\n");
-        af_Code *bt1 = makeElementCode("object", 0, 1, NULL);
-
-        af_Code *bt2 = makeElementCode("func-normal", 0, 1, NULL);
-        af_Code *bt3 = makeBlockCode(curly, bt2, 0, 1, NULL, NULL);
-        pushCode(&bt1, bt3);
-
-        af_Code *bt4 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagb.aun", NULL);
-
-        runCodeFromMemory(bt4, 0, env);
-        freeAllCode(bt4);
-        printf("\n");
-    }
-
-    {  // 尾调用优化2
-        printf("TAG C: [Tail test on literal]\n");
-        af_Code *bt1 = makeElementCode("data", 0, 0, "Tagc.aun");
-        af_Code *bt2 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagc.aun", NULL);
-
-        runCodeFromMemory(bt2, 0, env);
-        freeAllCode(bt2);
-        printf("\n");
-    }
-
-    {  // 测试类前缀调用
-        printf("TAG D: [parentheses-call]\n");
-        af_Code *bt1 = makeElementCode("func-normal", 0, 1, "Tagd.aun");
-        af_Code *bt2 = makeBlockCode(parentheses, NULL, 0, 1, NULL, NULL);
-        pushCode(&bt1, bt2);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-
-    {  // 测试顺序执行 $[xxx]
-        printf("TAG F: [ex-first]\n");
-        af_Code *bt3 = makeElementCode("data2", 0, 0, NULL);
-        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
-
-        pushCode(&bt3, bt4);
-
-        af_Code *bt5 = makeBlockCode(brackets, bt3, '$', 1, "Tagf.aun", NULL);
-
-        runCodeFromMemory(bt5, 0, env);
-        freeAllCode(bt5);
-        printf("\n");
-    }
-
-
-    {  // 双层尾调用优化 （函数内调用函数）
-        printf("TAG I: [Double tail test]\n");
-        af_Code *bt1 = makeElementCode("func-tail", 0, 1, NULL);
-        af_Code *bt2 = makeBlockCode(curly, bt1, 0, 1, "Tagi.aun", NULL);
-        af_Code *bt3 = makeBlockCode(parentheses, bt2, '\'', 1, "Tagi.aun", NULL);
-
-        runCodeFromMemory(bt3, 0, env);
-        freeAllCode(bt3);
-        printf("\n");
-    }
-
-    {  // 对象函数的调用
-        printf("TAG J: [object]\n");
-        af_Code *bt1 = makeElementCode("func-obj", 0, 1, "Tagj.aun");
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 变量引用调用
-        printf("TAG K: [not object]\n");
-        af_Code *bt1 = makeElementCode("func-obj", '\'', 1, "Tagk.aun");
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 对象函数的调用 (尾调用优化)
-        printf("TAG L: [pbject-tail]\n");
-        af_Code *bt1 = makeElementCode("func-obj", 0, 1, "Tagl.aun");
-        af_Code *bt2 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagi.aun", NULL);
-
-        runCodeFromMemory(bt2, 0, env);
-        freeAllCode(bt2);
-        printf("\n");
-    }
-
-
-    {  // gc测试
-        printf("TAG N: [gc-test]\n");
-
-        af_Code *bt2 = makeElementCode("func-gc", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tagn.aun", NULL);
-        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
-        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
-
-        pushCode(&bt1, bt3);
-        pushCode(&bt3, bt4);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // func_body_dynamic 测试
-        printf("TAG O:\n");
-
-        af_Code *bt2 = makeElementCode("func-body-dynamic", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tago.aun", NULL);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 中缀调用测试
-        printf("TAG P: [infix-call]\n");
-
-        af_Code *bt2 = makeElementCode("func-brackets", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(brackets, bt2, 0, 1, "Tagp.aun", NULL);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // func_body_import 测试
-        printf("TAG Q: [import]\n");
-
-        af_Code *bt2 = makeElementCode("func-import", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tagq.aun", NULL);
-        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
-
-        pushCode(&bt1, bt3);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 导入式运行
-        printf("TAG R: [import-Tagr]\n");
-        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagr.aun");
-        af_Code *bt2 = makeElementCode("data", 0, 0, NULL);
-        pushCode(&bt1, bt2);
-
-        af_Code *bt3 = makeElementCode("func-normal", 0, 1, NULL);
-        af_Code *bt5 = makeBlockCode(curly, bt3, 0, 1, NULL, NULL);
-        pushCode(&bt2, bt5);
-
-        af_Code *bt6 = makeElementCode("global", 0, 1, NULL);
-        pushCode(&bt5, bt6);
-
-        runCodeFromMemory(bt1, 1, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {
-        printf("TAG S: [string]\n");
-        int exit_code = runCodeFromString("str\ndata\n{func-normal}\nglobal\n", "Tags-string.aun", 1, env);
-        printf("exit code = %d\n\n", exit_code);
-    }
-
-
-    {
-        DLC_SYMBOL(GuardianFunc) func = MAKE_SYMBOL(gd_func, GuardianFunc);
-        DLC_SYMBOL(GuardianDestruct) des = MAKE_SYMBOL(gd_destruct, GuardianDestruct);
-        struct GDData *data = NULL;
-        addGuardian("test", false, true, sizeof(struct GDData), func, des, (void **) &data, env);
-        data->func = af_func;
-        gc_addReference(af_func, env);
-        FREE_SYMBOL(func);
-        FREE_SYMBOL(des);
-
-        printf("TAG U: [guardian]\n");
-        af_Code *bt1 = makeElementCode("func-normal", 0, 1, "TagU.aun");
-        af_Code *bt2 = makeElementCode("global", 0, 1, "TagU.aun");
-        af_Code *bt3 = makeElementCode("global", 0, 1, "TagU.aun");
-
-        pushCode(&bt1, bt2);
-        pushCode(&bt2, bt3);
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-
-        bool re = popGuardian("test", env);
-        printf("popGuardian: %d\n\n", re);
-    }
-
-    {
-        printf("TAG V: [Thread]\n");
-        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagv.aun");
-
-        startRunThread(env, NULL, bt1, true, true, true, true);
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    /* 错误用例 */
-
-    {  // 中缀调用测试
-        printf("TAG a: ERROR\n");
-
-        af_Code *bt2 = makeElementCode("func-normal", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(brackets, bt2, 0, 1, "Taga-error.aun", NULL);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 测试错误 (无函数指定)
-        printf("TAG b: ERROR\n");
-        af_Code *bt1 = makeBlockCode(curly, NULL, 0, 1, "Tagb-error.aun", NULL);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 测试错误 (object2 Var not found)
-        printf("TAG c: ERROR\n");
-        af_Code *bt1 = makeElementCode("object2", 0, 1, "Tagc-error.aun");
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 中缀保护测试
-        printf("TAG d: ERROR\n");
-
-        af_Code *bt1 = makeElementCode("global", 0, 1, "Tagd-error.aun");
-        af_Code *bt2 = makeElementCode("func-brackets", 0, 2, NULL);
-
-        pushCode(&bt1, bt2);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
-
-    {  // 错误回溯测试
-        printf("TAG e: ERROR\n");
-
-        af_Code *bt2 = makeElementCode("func-no-var", 0, 1, NULL);
-        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tage-error.aun", NULL);
-
-        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
-        pushCode(&bt1, bt3);
-
-        runCodeFromMemory(bt1, 0, env);
-        freeAllCode(bt1);
-        printf("\n");
-    }
+    sleep(2);
+
+//    {  // 宏函数
+//        printf("TAG L: [Macro test]\n");
+//        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagl.aun");
+//
+//        af_Code *bt3 = makeElementCode("macro", 0, 1, NULL);
+//        af_Code *bt5 = makeBlockCode(curly, bt3, 0, 1, NULL, NULL);
+//        pushCode(&bt1, bt5);
+//
+//        af_Code *bt6 = makeElementCode("global", 0, 1, NULL);
+//        pushCode(&bt5, bt6);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 测试顺序执行 '(xxx)
+//        printf("TAG E: [ex]\n");
+//        af_Code *bt3 = makeElementCode("data2", 0, 0, NULL);
+//        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
+//
+//        pushCode(&bt3, bt4);
+//
+//        af_Code *bt5 = makeBlockCode(parentheses, bt3, '\'', 1, "Tage.aun", NULL);
+//
+//        runCodeFromMemory(bt5, 0, env);
+//        freeAllCode(bt5);
+//        printf("\n");
+//    }
+//
+//    {  // 尾调用优化
+//        printf("TAG B: [Tail test]\n");
+//        af_Code *bt1 = makeElementCode("object", 0, 1, NULL);
+//
+//        af_Code *bt2 = makeElementCode("func-normal", 0, 1, NULL);
+//        af_Code *bt3 = makeBlockCode(curly, bt2, 0, 1, NULL, NULL);
+//        pushCode(&bt1, bt3);
+//
+//        af_Code *bt4 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagb.aun", NULL);
+//
+//        runCodeFromMemory(bt4, 0, env);
+//        freeAllCode(bt4);
+//        printf("\n");
+//    }
+//
+//    {  // 尾调用优化2
+//        printf("TAG C: [Tail test on literal]\n");
+//        af_Code *bt1 = makeElementCode("data", 0, 0, "Tagc.aun");
+//        af_Code *bt2 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagc.aun", NULL);
+//
+//        runCodeFromMemory(bt2, 0, env);
+//        freeAllCode(bt2);
+//        printf("\n");
+//    }
+//
+//    {  // 测试类前缀调用
+//        printf("TAG D: [parentheses-call]\n");
+//        af_Code *bt1 = makeElementCode("func-normal", 0, 1, "Tagd.aun");
+//        af_Code *bt2 = makeBlockCode(parentheses, NULL, 0, 1, NULL, NULL);
+//        pushCode(&bt1, bt2);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//
+//    {  // 测试顺序执行 $[xxx]
+//        printf("TAG F: [ex-first]\n");
+//        af_Code *bt3 = makeElementCode("data2", 0, 0, NULL);
+//        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
+//
+//        pushCode(&bt3, bt4);
+//
+//        af_Code *bt5 = makeBlockCode(brackets, bt3, '$', 1, "Tagf.aun", NULL);
+//
+//        runCodeFromMemory(bt5, 0, env);
+//        freeAllCode(bt5);
+//        printf("\n");
+//    }
+//
+//
+//    {  // 双层尾调用优化 （函数内调用函数）
+//        printf("TAG I: [Double tail test]\n");
+//        af_Code *bt1 = makeElementCode("func-tail", 0, 1, NULL);
+//        af_Code *bt2 = makeBlockCode(curly, bt1, 0, 1, "Tagi.aun", NULL);
+//        af_Code *bt3 = makeBlockCode(parentheses, bt2, '\'', 1, "Tagi.aun", NULL);
+//
+//        runCodeFromMemory(bt3, 0, env);
+//        freeAllCode(bt3);
+//        printf("\n");
+//    }
+//
+//    {  // 对象函数的调用
+//        printf("TAG J: [object]\n");
+//        af_Code *bt1 = makeElementCode("func-obj", 0, 1, "Tagj.aun");
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 变量引用调用
+//        printf("TAG K: [not object]\n");
+//        af_Code *bt1 = makeElementCode("func-obj", '\'', 1, "Tagk.aun");
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 对象函数的调用 (尾调用优化)
+//        printf("TAG L: [pbject-tail]\n");
+//        af_Code *bt1 = makeElementCode("func-obj", 0, 1, "Tagl.aun");
+//        af_Code *bt2 = makeBlockCode(parentheses, bt1, '\'', 1, "Tagi.aun", NULL);
+//
+//        runCodeFromMemory(bt2, 0, env);
+//        freeAllCode(bt2);
+//        printf("\n");
+//    }
+//
+//
+//    {  // gc测试
+//        printf("TAG N: [gc-test]\n");
+//
+//        af_Code *bt2 = makeElementCode("func-gc", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tagn.aun", NULL);
+//        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
+//        af_Code *bt4 = makeElementCode("global", 0, 1, NULL);
+//
+//        pushCode(&bt1, bt3);
+//        pushCode(&bt3, bt4);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // func_body_dynamic 测试
+//        printf("TAG O: [func body dynamic]\n");
+//
+//        af_Code *bt2 = makeElementCode("func-body-dynamic", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tago.aun", NULL);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 中缀调用测试
+//        printf("TAG P: [infix-call]\n");
+//
+//        af_Code *bt2 = makeElementCode("func-brackets", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(brackets, bt2, 0, 1, "Tagp.aun", NULL);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // func_body_import 测试
+//        printf("TAG Q: [import]\n");
+//
+//        af_Code *bt2 = makeElementCode("func-import", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tagq.aun", NULL);
+//        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
+//
+//        pushCode(&bt1, bt3);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 导入式运行
+//        printf("TAG R: [import-Tagr]\n");
+//        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagr.aun");
+//        af_Code *bt2 = makeElementCode("data", 0, 0, NULL);
+//        pushCode(&bt1, bt2);
+//
+//        af_Code *bt3 = makeElementCode("func-normal", 0, 1, NULL);
+//        af_Code *bt5 = makeBlockCode(curly, bt3, 0, 1, NULL, NULL);
+//        pushCode(&bt2, bt5);
+//
+//        af_Code *bt6 = makeElementCode("global", 0, 1, NULL);
+//        pushCode(&bt5, bt6);
+//
+//        runCodeFromMemory(bt1, 1, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {
+//        printf("TAG S: [string]\n");
+//        int exit_code = runCodeFromString("str\ndata\n{func-normal}\nglobal\n", "Tags-string.aun", 1, env);
+//        printf("exit code = %d\n\n", exit_code);
+//    }
+//
+//
+//    {
+//        DLC_SYMBOL(GuardianFunc) func = MAKE_SYMBOL(gd_func, GuardianFunc);
+//        DLC_SYMBOL(GuardianDestruct) des = MAKE_SYMBOL(gd_destruct, GuardianDestruct);
+//        struct GDData *data = NULL;
+//        addGuardian("test", false, true, sizeof(struct GDData), func, des, (void **) &data, env);
+//        data->func = af_func;
+//        gc_addReference(af_func, env);
+//        FREE_SYMBOL(func);
+//        FREE_SYMBOL(des);
+//
+//        printf("TAG U: [guardian]\n");
+//        af_Code *bt1 = makeElementCode("func-normal", 0, 1, "TagU.aun");
+//        af_Code *bt2 = makeElementCode("global", 0, 1, "TagU.aun");
+//        af_Code *bt3 = makeElementCode("global", 0, 1, "TagU.aun");
+//
+//        pushCode(&bt1, bt2);
+//        pushCode(&bt2, bt3);
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//
+//        bool re = popGuardian("test", env);
+//        printf("popGuardian: %d\n\n", re);
+//    }
+//
+//    {
+//        printf("TAG V: [Thread]\n");
+//        af_Code *bt1 = makeElementCode("object", 0, 1, "Tagv.aun");
+//
+//        startRunThread(env, NULL, bt1, false, true, true, true, true);
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    /* 错误用例 */
+//
+//    {  // 中缀调用测试
+//        printf("TAG a: ERROR\n");
+//
+//        af_Code *bt2 = makeElementCode("func-normal", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(brackets, bt2, 0, 1, "Taga-error.aun", NULL);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 测试错误 (无函数指定)
+//        printf("TAG b: ERROR\n");
+//        af_Code *bt1 = makeBlockCode(curly, NULL, 0, 1, "Tagb-error.aun", NULL);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 测试错误 (object2 Var not found)
+//        printf("TAG c: ERROR\n");
+//        af_Code *bt1 = makeElementCode("object2", 0, 1, "Tagc-error.aun");
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 中缀保护测试
+//        printf("TAG d: ERROR\n");
+//
+//        af_Code *bt1 = makeElementCode("global", 0, 1, "Tagd-error.aun");
+//        af_Code *bt2 = makeElementCode("func-brackets", 0, 2, NULL);
+//
+//        pushCode(&bt1, bt2);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
+//
+//    {  // 错误回溯测试
+//        printf("TAG e: ERROR\n");
+//
+//        af_Code *bt2 = makeElementCode("func-no-var", 0, 1, NULL);
+//        af_Code *bt1 = makeBlockCode(curly, bt2, 0, 1, "Tage-error.aun", NULL);
+//
+//        af_Code *bt3 = makeElementCode("global", 0, 1, NULL);
+//        pushCode(&bt1, bt3);
+//
+//        runCodeFromMemory(bt1, 0, env);
+//        freeAllCode(bt1);
+//        printf("\n");
+//    }
 
     printf("freeEnvironment:\n");
     destructAFunEnvironment(env);