feat: gc机制使用API

include/gc.h

@@ -3,6 +3,14 @@
 #include "object.h"
 #include "var.h"
 
+typedef struct af_GcList af_GcList;
+enum af_GcListType {
+    glt_obj = 1,
+    glt_vs,
+    glt_var,
+    glt_vsl,
+};
+
 /* gc 引用计数管理函数 */
 #define gc_addReference(obj) ((_Generic((obj), \
                                af_Object *:gc_addObjectReference, \
@@ -14,6 +22,9 @@
                                af_Var *: gc_delVarReference, \
                                af_VarSpace *: gc_delVarSpaceReference))(obj))
 
+/* GcList 操作函数 */
+af_GcList *pushGcList(enum af_GcListType type, void *data, af_GcList *base);
+
 /* gc 对象新增函数 */
 void gc_addObject(af_Object *obj, af_Environment *env);
 void gc_addVar(af_Var *obj, af_Environment *env);

include/obj_api.h

@@ -11,6 +11,7 @@
 #include "object.h"
 #include "var.h"
 #include "func.h"
+#include "gc.h"
 
 /* 定义一些函数原型 */
 /* API函数 */
@@ -25,8 +26,8 @@ typedef void callFuncBody(void *mark, af_Environment *env);  // 位于env.h
 /* 定义Object的函数签名 */
 /* Object void *data 管理 */
 typedef size_t obj_getDataSize(void);  // 获取data的大小
-typedef void obj_initData(void *data);  // 初始化data
-typedef void obj_freeData(void *data);  // 释放data的内容 (但不释放void *data)指针
+typedef void obj_initData(void *data, af_Environment *env);  // 初始化data
+typedef void obj_freeData(void *data, af_Environment *env);  // 释放data的内容 (但不释放void *data)指针
 
 /* Object 函数调用 */
 typedef bool obj_funcGetArgCodeList(af_ArgCodeList **acl, af_Object *obj, af_Code *code, void **mark, af_Environment *env);  // 获取参数计算表
@@ -39,6 +40,9 @@ typedef void obj_funcFreeMask(void *mark);  // 释放mask的函数
 typedef void obj_literalSetting(char *str, void *data, af_Object *obj, af_Environment *env);
 
 /* Object 变量专项 */
-typedef bool is_obj_func(af_Object *obj);  // 是否对象函数
+typedef bool obj_isObjFunc(af_Object *obj);  // 是否对象函数
+
+/* Object gc管理 */
+typedef af_GcList *obj_getGcList(void *data);  // 是否对象函数
 
 #endif //AFUN__OBJ_API_H

include/object.h

@@ -19,6 +19,7 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
 void freeObject(af_Object *obj, af_Environment *env);
 
 /* 对象属性获取函数 */
+void *getObjectData(af_Object *obj);
 af_Object *getBelongObject(af_Object *object, af_Environment *env);
 
 /* 对象继承关系函数 */

include/var.h

@@ -39,6 +39,9 @@ af_VarSpaceListNode *freeVarSpaceList(af_VarSpaceListNode *vsl);
 void freeAllVarSpaceList(af_VarSpaceListNode *vsl);
 bool freeVarSpaceListCount(size_t count, af_VarSpaceListNode *vsl);
 
+/* 变量空间链属性获取 */
+af_VarSpace *getVarSpaceFromList(af_VarSpaceListNode *vsl);
+
 /* 变量空间链管理 */
 af_VarSpaceListNode *pushNewVarList(af_VarSpaceListNode *base, af_Environment *env);
 af_VarSpaceListNode *popLastVarList(af_VarSpaceListNode *base);

src/core/__gc.h

@@ -48,6 +48,20 @@ struct GC_VarSpace {
 #include "__env.h"  // 这部分内容依赖上面的定义
 #include "gc.h"
 
+struct af_GcList {
+    enum af_GcListType type;
+
+    union {
+        void *data;
+        struct af_Object *obj;
+        struct af_VarSpace *vs;
+        struct af_Var *var;
+        struct af_VarSpaceListNode *vsl;
+    };
+
+    struct af_GcList *next;
+};
+
 /* 重新定义包括af_ObjectData的 gc Reference 函数 */
 #undef gc_addReference
 #undef gc_delReference
@@ -78,7 +92,7 @@ void gc_addVarSpaceByCore(struct af_VarSpace *obj, af_Core *core);
 
 /* gc 操控函数 : gc的启动由解释器完全管理 */
 void gc_RunGC(af_Environment *env);
-void gc_freeAllValue(af_Core *core);
+void gc_freeAllValue(af_Environment *env);
 
 /* gc 信息函数 */
 void printGCByCode(af_Core *core);

src/core/__object.h

@@ -61,7 +61,7 @@ struct af_Inherit {
 };
 
 /* ObjectData的释放函数 */
-void freeObjectDataByCore(af_ObjectData *od, af_Core *core);
+void freeObjectData(af_ObjectData *od, af_Environment *env);
 
 /* Object释放函数 */
 void freeObjectByCore(af_Object *obj, af_Core *core);

src/core/env.c

@@ -2,7 +2,7 @@
 
 /* Core 创建和释放 */
 static af_Core *makeCore(enum GcRunTime grt);
-static void freeCore(af_Core *core);
+static void freeCore(af_Environment *env);
 
 /* Core 初始化 */
 static bool enableCore(af_Core *core);
@@ -52,10 +52,15 @@ static af_Core *makeCore(enum GcRunTime grt) {
     return core;
 }
 
-static void freeCore(af_Core *core) {
-    printGCByCode(core);
-    gc_freeAllValue(core);
-    free(core);
+/*
+ * 函数名: freeCore
+ * 目标: 释放Core
+ * 因为gc_freeAllValue需要env作为参数, 故使用env作为freeCore的参数
+ */
+static void freeCore(af_Environment *env) {
+    printGCByCode(env->core);
+    gc_freeAllValue(env);
+    free(env->core);
 }
 
 char setPrefix(size_t name, char prefix, af_Environment *env) {
@@ -425,7 +430,7 @@ bool enableEnvironment(af_Environment *env) {
 }
 
 void freeEnvironment(af_Environment *env) {
-    freeCore(env->core);
+    freeCore(env);
     freeAllActivity(env->activity);
     freeEnvVarSpace(env->esv);
     freeAllTopMsgProcess(env->process);

src/core/gc.c

@@ -4,6 +4,36 @@
 #include "__gc.h"
 #include "__env.h"
 
+/* gcList 函数 */
+static af_GcList *makeGcList(enum af_GcListType type, void *data);
+static af_GcList *freeGcList(af_GcList *gl);
+static void freeAllGcList(af_GcList *gl);
+
+static af_GcList *makeGcList(enum af_GcListType type, void *data) {
+    af_GcList *gl = calloc(sizeof(af_GcList), 1);
+    gl->type = type;
+    gl->data = data;
+    return gl;
+}
+
+static af_GcList *freeGcList(af_GcList *gl) {
+    af_GcList *next = gl->next;
+    free(gl);
+    return next;
+}
+
+static void freeAllGcList(af_GcList *gl) {
+    while (gl != NULL)
+        gl = freeGcList(gl);
+}
+
+af_GcList *pushGcList(enum af_GcListType type, void *data, af_GcList *base) {
+    af_GcList *next = makeGcList(type, data);
+    next->next = base;
+    return next;
+}
+
+/* gc 运行时函数 */
 typedef struct gc_Analyzed gc_Analyzed, **pgc_Analyzed;
 struct gc_Analyzed {
     enum gc_AnalyzedType {
@@ -37,11 +67,12 @@ static pgc_Analyzed newVarSpaceAnalyzed(struct af_VarSpace *vs, pgc_Analyzed pli
 /* 可达性分析函数 */
 static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist);
 static pgc_Analyzed reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed plist);
+static pgc_Analyzed reachableVarSpaceList(struct af_VarSpaceListNode *vsl, pgc_Analyzed plist);
 static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed plist);
 static pgc_Analyzed reachableObject(struct af_Object *od, pgc_Analyzed plist);
 
 /* gc运行函数 */
-static void freeValue(af_Core *core);
+static void freeValue(af_Environment *env);
 static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist);
 static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist);
 static void freeAllAnalyzed(gc_Analyzed *base);
@@ -122,6 +153,30 @@ static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed p
             plist = newObjectAnalyzed(ih->obj, plist);
     }
 
+    obj_getGcList *func = findAPI("obj_getGcList", od->api);
+    if (func != NULL) {
+        af_GcList *gl = func(od->data);
+        for (af_GcList *tmp = gl; tmp != NULL; tmp = tmp->next) {
+            switch (tmp->type) {
+                case glt_obj:
+                    if (!tmp->obj->gc.info.reachable)
+                        plist = newObjectAnalyzed(od->base, plist);
+                    break;
+                case glt_var:
+                    plist = reachableVar(tmp->var, plist);
+                    break;
+                case glt_vs:
+                    plist = reachableVarSpace(tmp->vs, plist);
+                    break;
+                case glt_vsl:
+                    plist = reachableVarSpaceList(tmp->vsl, plist);
+                    break;
+                default:
+                    break;
+            }
+        }
+        freeAllGcList(gl);
+    }
     return plist;
 }
 
@@ -151,6 +206,14 @@ static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
     return plist;
 }
 
+static pgc_Analyzed reachableVarSpaceList(struct af_VarSpaceListNode *vsl, pgc_Analyzed plist) {
+    for (NULL; vsl != NULL; vsl = vsl->next) {
+        if (!vsl->vs->gc.info.reachable)
+            plist = reachableVarSpace(vsl->vs, plist);
+    }
+    return plist;
+}
+
 static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist) {
     plist = reachableVarSpace(core->protect, plist);
     if (core->object != NULL)
@@ -194,21 +257,9 @@ static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist) {
         if (activity->parentheses_call != NULL)
             plist = reachableObject(activity->parentheses_call, plist);
 
-        for (af_VarSpaceListNode *vsn = activity->var_list; vsn != NULL; vsn = vsn->next) {
-            if (!vsn->vs->gc.info.reachable)
-                plist = reachableVarSpace(vsn->vs, plist);
-        }
-
-        for (af_VarSpaceListNode *vsn = activity->func_var_list; vsn != NULL; vsn = vsn->next) {
-            if (!vsn->vs->gc.info.reachable)
-                plist = reachableVarSpace(vsn->vs, plist);
-        }
-
-        for (af_VarSpaceListNode *vsn = activity->macro_vsl; vsn != NULL; vsn = vsn->next) {
-            if (!vsn->vs->gc.info.reachable)
-                plist = reachableVarSpace(vsn->vs, plist);
-        }
-
+        plist = reachableVarSpaceList(activity->var_list, plist);
+        plist = reachableVarSpaceList(activity->func_var_list, plist);
+        plist = reachableVarSpaceList(activity->macro_vsl, plist);
     }
     return plist;
 }
@@ -227,36 +278,36 @@ void resetGC(af_Environment *env) {
         var->gc.info.reachable = false;
 }
 
-static void freeValue(af_Core *core) {
-    for (af_ObjectData *od = core->gc_ObjectData, *next; od != NULL; od = next) {
+static void freeValue(af_Environment *env) {
+    for (af_ObjectData *od = env->core->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
         if (!od->gc.info.reachable) { // 暂时不考虑析构函数
             printf("- gc free ObjectData: %p\n", od);
-            freeObjectDataByCore(od, core);
+            freeObjectData(od, env);
         }
     }
 
-    for (af_Object *obj = core->gc_Object, *next; obj != NULL; obj = next) {
+    for (af_Object *obj = env->core->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
         if (!obj->gc.info.reachable) {
             printf("- gc free Object: %p\n", obj);
-            freeObjectByCore(obj, core);
+            freeObjectByCore(obj, env->core);
         }
     }
 
-    for (af_VarSpace *vs = core->gc_VarSpace, *next; vs != NULL; vs = next) {
+    for (af_VarSpace *vs = env->core->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
         if (!vs->gc.info.reachable) {
             printf("- gc free VarSpace: %p\n", vs);
-            freeVarSpaceByCore(vs, core);
+            freeVarSpaceByCore(vs, env->core);
         }
     }
 
-    for (af_Var *var = core->gc_Var, *next; var != NULL; var = next) {
+    for (af_Var *var = env->core->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
         if (!var->gc.info.reachable) {
             printf("- gc free Var: %p\n", var);
-            freeVarByCore(var, core);
+            freeVarByCore(var, env->core);
         }
     }
 }
@@ -317,29 +368,29 @@ void gc_RunGC(af_Environment *env) {
         }
     }
 
-    freeValue(env->core);
+    freeValue(env);
     freeAllAnalyzed(analyzed);
 }
 
-void gc_freeAllValue(af_Core *core) {
-    for (af_ObjectData *od = core->gc_ObjectData, *next; od != NULL; od = next) {
+void gc_freeAllValue(af_Environment *env) {
+    for (af_ObjectData *od = env->core->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
-        freeObjectDataByCore(od, core);  // 暂时不考虑析构函数
+        freeObjectData(od, env);  // 暂时不考虑析构函数
     }
 
-    for (af_Object *obj = core->gc_Object, *next; obj != NULL; obj = next) {
+    for (af_Object *obj = env->core->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
-        freeObjectByCore(obj, core);
+        freeObjectByCore(obj, env->core);
     }
 
-    for (af_VarSpace *vs = core->gc_VarSpace, *next; vs != NULL; vs = next) {
+    for (af_VarSpace *vs = env->core->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
-        freeVarSpaceByCore(vs, core);
+        freeVarSpaceByCore(vs, env->core);
     }
 
-    for (af_Var *var = core->gc_Var, *next; var != NULL; var = next) {
+    for (af_Var *var = env->core->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
-        freeVarByCore(var, core);
+        freeVarByCore(var, env->core);
     }
 }
 

src/core/object.c

@@ -37,7 +37,7 @@ static af_ObjectData * makeObjectData_Pri(char *id, bool free_api, af_ObjectAPI
     if (od->size != 0) {
         od->data = calloc(od->size, 1);
         if (init != NULL)
-            init(od->data);
+            init(od->data, env);
     }
 
     od->api = api;
@@ -97,13 +97,12 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
  * 函数名: freeObjectDataByCore
  * 目标: 释放ObjectData, 仅GC函数可用
  * 对外API中, 创建对象的基本单位都是af_Object, 无法直接操控af_ObjectData
- * af_ObjectData对外不可见, 因此无使用env的freeObjectData函数
  */
-void freeObjectDataByCore(af_ObjectData *od, af_Core *core) {
+void freeObjectData(af_ObjectData *od, af_Environment *env) {
     if (od->size != 0) {
         obj_freeData *func = findAPI("obj_freeData", od->api);
         if (func != NULL)
-            func(od->data);
+            func(od->data, env);
     }
 
     free(od->id);
@@ -111,7 +110,7 @@ void freeObjectDataByCore(af_ObjectData *od, af_Core *core) {
     if (od->free_api)
         freeObjectAPI(od->api);
     freeAllInherit(od->inherit);
-    GC_FREE_EXCHANGE(od, ObjectData, core);
+    GC_FREE_EXCHANGE(od, ObjectData, env->core);
     free(od);
 }
 
@@ -125,6 +124,10 @@ void freeObjectByCore(af_Object *obj, af_Core *core) {
     free(obj);
 }
 
+void *getObjectData(af_Object *obj) {
+    return obj->data->data;
+}
+
 af_Object *getBelongObject(af_Object *object, af_Environment *env) {
     if (object->belong == NULL)
         return object;

src/core/run.c

@@ -21,9 +21,9 @@ static bool codeVariable(af_Code *code, af_Environment *env) {
     }
 
     af_Object *obj = var->vn->obj;
-    is_obj_func *func;
+    obj_isObjFunc *func;
     if (code->prefix == env->core->prefix[V_QUOTE] ||
-        (func = findAPI("is_obj_func", obj->data->api)) == NULL || !func(obj)) {  // 非对象函数 或 引用调用
+        (func = findAPI("obj_isObjFunc", obj->data->api)) == NULL || !func(obj)) {  // 非对象函数 或 引用调用
         pushMessageDown(makeNORMALMessage(obj), env);
         env->activity->bt_next = env->activity->bt_next->next;
         printf("Get Variable %s : %p\n", code->variable.name, obj);

src/core/var.c

@@ -137,6 +137,12 @@ void freeAllVarSpaceList(af_VarSpaceListNode *vsl){
         vsl = freeVarSpaceList(vsl);
 }
 
+af_VarSpace *getVarSpaceFromList(af_VarSpaceListNode *vsl) {
+    if (vsl != NULL)
+        return vsl->vs;
+    return NULL;
+}
+
 bool freeVarSpaceListCount(size_t count, af_VarSpaceListNode *vsl) {
     for (size_t i = count; i > 0; i--) {
         if (vsl == NULL)  // 发生了错误

src/main.c

@@ -14,16 +14,29 @@ size_t getSize(void) {
     return sizeof(int *);
 }
 
-void initData(int **data) {
+void initData(int **data, af_Environment *env) {
     *data = calloc(sizeof(int), 1);
     **data = 100;
 }
 
-void freeData(int **data) {
+void freeData(int **data, af_Environment *env) {
     printf("freeData(): **data = %d\n", **data);
     free(*data);
 }
 
+size_t getSize2(void) {
+    return sizeof(af_VarSpaceListNode *);
+}
+
+void initData2(af_VarSpaceListNode **data, af_Environment *env) {
+    *data = makeVarSpaceList(getProtectVarSpace(env));
+}
+
+void freeData2(af_VarSpaceListNode **data, af_Environment *env) {
+    printf("freeData2(): vsl = %p\n", *data);
+    freeAllVarSpaceList(*data);
+}
+
 bool getAcl(af_ArgCodeList **acl, af_Object *obj, af_Code *code, int **mark, af_Environment *env) {
     *acl = makeArgCodeList(makeVariableCode("object", NUL, 0, "Unknown"), 0, true, false);
     *mark = calloc(sizeof(int), 1);
@@ -31,12 +44,16 @@ bool getAcl(af_ArgCodeList **acl, af_Object *obj, af_Code *code, int **mark, af_
     return true;
 }
 
-bool getVsl(af_VarSpaceListNode **vsl, af_Object *obj, void *mark, af_Environment *env) {  // [桩]
-    *vsl = makeVarSpaceList(getProtectVarSpace(env));
-    pushNewVarList(*vsl, env);
+bool getVsl(af_VarSpaceListNode **vsl, af_Object *obj, void *mark, af_Environment *env) {
+    *vsl = *(af_VarSpaceListNode **)getObjectData(obj);
     return true;
 }
 
+af_GcList *getGcList(void *data) {
+    af_GcList *gl = pushGcList(glt_vsl, *(af_VarSpaceListNode **)data, NULL);
+    return gl;
+}
+
 bool getAl(af_ArgList **al, af_Object *obj, af_ArgCodeList *acl, void *mark, af_Environment *env) {
     *al = makeArgList("test", getArgCodeListResult(acl));
     return true;
@@ -88,6 +105,16 @@ void testFunc2(int *mark, af_Environment *env) {  // 测试用函数
         DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfo, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData2, objectAPIFunc);
+        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+            return;
+        if (addAPI(initData_2, "obj_initData", api) != 1)
+            return;
+        if (addAPI(freeData_2, "obj_freeData", api) != 1)
+            return;
         if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
             return;
         if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
@@ -98,13 +125,19 @@ void testFunc2(int *mark, af_Environment *env) {  // 测试用函数
             return;
         if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
             return;
+        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+            return;
 
         obj = makeObject("func", true, api, true, NULL, NULL, env);
+        FREE_SYMBOL(getSize_2);
+        FREE_SYMBOL(initData_2);
+        FREE_SYMBOL(freeData_2);
         FREE_SYMBOL(get_alc);
         FREE_SYMBOL(get_vsl);
         FREE_SYMBOL(get_al);
         FREE_SYMBOL(get_info);
         FREE_SYMBOL(free_mark);
+        FREE_SYMBOL(get_gl);
     }
 
     pushMessageDown(makeNORMALMessage(obj), env);
@@ -188,6 +221,16 @@ int main() {
         DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfo, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData2, objectAPIFunc);
+        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+            return 2;
+        if (addAPI(initData_2, "obj_initData", api) != 1)
+            return 2;
+        if (addAPI(freeData_2, "obj_freeData", api) != 1)
+            return 2;
         if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
             return 2;
         if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
@@ -198,6 +241,8 @@ int main() {
             return 2;
         if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
             return 2;
+        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+            return 2;
 
         addVarToProtectVarSpace(makeVar("func", 3, 3,
                                         (obj = makeObject("func", true, api, true, NULL, NULL, env)), env),
@@ -207,6 +252,10 @@ int main() {
         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);
         printf("func(%p)\n", obj);
     }
 
@@ -218,6 +267,18 @@ int main() {
         DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) get_info2 = MAKE_SYMBOL(getInfo2, objectAPIFunc);  // 宏函数
         DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData2, objectAPIFunc);
+        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+            return 2;
+        if (addAPI(initData_2, "obj_initData", api) != 1)
+            return 2;
+        if (addAPI(freeData_2, "obj_freeData", api) != 1)
+            return 2;
+        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+            return 2;
         if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
             return 2;
         if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
@@ -237,6 +298,10 @@ int main() {
         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("func2(%p)\n", obj);
     }
 
@@ -248,6 +313,18 @@ int main() {
         DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAl, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) get_info3 = MAKE_SYMBOL(getInfo3, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData2, objectAPIFunc);
+        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+            return 2;
+        if (addAPI(initData_2, "obj_initData", api) != 1)
+            return 2;
+        if (addAPI(freeData_2, "obj_freeData", api) != 1)
+            return 2;
+        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+            return 2;
         if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
             return 2;
         if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
@@ -267,6 +344,10 @@ int main() {
         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("func3(%p)\n", obj);
     }
 
@@ -279,6 +360,18 @@ int main() {
         DLC_SYMBOL(objectAPIFunc) get_info4 = MAKE_SYMBOL(getInfo4, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMark, objectAPIFunc);
         DLC_SYMBOL(objectAPIFunc) obj_func = MAKE_SYMBOL(objFunc, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) getSize_2 = MAKE_SYMBOL(getSize2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) initData_2 = MAKE_SYMBOL(initData2, objectAPIFunc);
+        DLC_SYMBOL(objectAPIFunc) freeData_2 = MAKE_SYMBOL(freeData2, objectAPIFunc);
+        if (addAPI(getSize_2, "obj_getDataSize", api) != 1)
+            return 2;
+        if (addAPI(initData_2, "obj_initData", api) != 1)
+            return 2;
+        if (addAPI(freeData_2, "obj_freeData", api) != 1)
+            return 2;
+        if (addAPI(get_gl, "obj_getGcList", api) != 1)
+            return 2;
         if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
             return 2;
         if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
@@ -289,7 +382,7 @@ int main() {
             return 2;
         if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
             return 2;
-        if (addAPI(obj_func, "is_obj_func", api) != 1)
+        if (addAPI(obj_func, "obj_isObjFunc", api) != 1)
             return 2;
 
         addVarToProtectVarSpace(makeVar("func4", 3, 3,
@@ -301,6 +394,10 @@ int main() {
         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("func4(%p)\n", obj);
     }