feat: 添加var和object模块

include/bytecode.h

@@ -12,7 +12,7 @@ af_ByteCode *makeLiteralByteCode(char *literal_data, char *func, char prefix, Fi
 af_ByteCode *makeVariableByteCode(char *var, char prefix, FileLine line, FilePath path);
 af_ByteCode *makeBlockByteCode(enum af_BlockType type, af_ByteCode *element, char prefix, FileLine line, FilePath path, af_ByteCode **next);
 af_ByteCode *connectByteCode(af_ByteCode **base, af_ByteCode *next);
-af_ByteCode *CopyByteCode(af_ByteCode *base, FilePath *path);
+af_ByteCode *copyByteCode(af_ByteCode *base, FilePath *path);
 af_ByteCode *freeByteCode(af_ByteCode *bt);
 bool freeByteCodeWithElement(af_ByteCode *bt, af_ByteCode **next);
 void freeAllByteCode(af_ByteCode *bt);

include/gc.h

@@ -3,7 +3,6 @@
 #include "object.h"
 #include "var.h"
 
-void gc_addObjectData(af_ObjectData *obj, af_Core *core);
 void gc_addObject(af_Object *obj, af_Core *core);
 void gc_addVar(af_Var *obj, af_Core *core);
 void gc_addVarSpace(af_VarSpace *obj, af_Core *core);

include/object.h

@@ -1,7 +1,20 @@
 #ifndef AFUN__OBJECT_H_PUBLIC
 #define AFUN__OBJECT_H_PUBLIC
+#include "env.h"
+#include "tool.h"
 
 typedef struct af_Object af_Object;
-typedef struct af_ObjectData af_ObjectData;
+typedef struct af_Inherit af_Inherit;
 
+af_Object *makeObject(char *id, size_t data_size, bool inherit_api, bool allow_iherit,
+                      af_Inherit *inherit, af_Environment *env);
+void freeObject(af_Object *obj);
+
+af_Inherit *makenIherit(af_Object *obj);
+af_Inherit *freeIherit(af_Inherit *ih);
+void freeAllIherit(af_Inherit *ih);
+
+void *findObjectAPI(char *api_name, af_Object *obj);
+int addAPIToObject(DlcHandle *dlc, char *func_name, char *api_name,
+                   af_Object *obj);
 #endif //AFUN__OBJECT_H_PUBLIC

include/tool.h

@@ -102,12 +102,12 @@ void safeSleep(double ms);
  * freeLibary: 释放动态库
  * dlcExit: 释放所有动态库
  */
-#define NEW_DLC_SYMBOL(TYPE, NAME) struct DLC##NAME##SYMBOL { \
+#define NEW_DLC_SYMBOL(TYPE, NAME) typedef struct DLC##NAME##SYMBOL { \
 TYPE *symbol; \
 struct DlcHandle *dlc; \
-}
+} DLC##NAME##SYMBOL, *pDLC##NAME##SYMBOL
 
-#define DLC_SYMBOL(NAME) struct DLC##NAME##SYMBOL
+#define DLC_SYMBOL(NAME) pDLC##NAME##SYMBOL
 #define GET_SYMBOL(SYMBOL) (*((SYMBOL)->symbol))
 #define MAKE_SYMBOL(symbol, TYPE) ((struct DLC##TYPE##SYMBOL *) (makeSymbol_(symbol)))
 #define COPY_SYMBOL(ds, TYPE) ((struct DLC##TYPE##SYMBOL *) (copySymbol_((DlcSymbol_ *)(ds))))

include/var.h

@@ -1,8 +1,31 @@
 #ifndef AFUN__VAR_H_PUBLIC
 #define AFUN__VAR_H_PUBLIC
 #include "macro.h"
+#include "object.h"
 
 typedef struct af_Var af_Var;
 typedef struct af_VarSpace af_VarSpace;
+typedef struct af_VarSpaceListNode af_VarSpaceListNode;
+
+af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_Object *obj);
+void freeVar(af_Var *var);
+void addVarNode(af_Var var, af_Object *obj, char *id);
+
+af_VarSpace *makeVarSpace(void);
+void freeVarSpace(af_VarSpace *vs);
+
+af_VarSpaceListNode *makeVarSpaceList(af_VarSpace *vs);
+af_VarSpaceListNode *freeVarSpaceList(af_VarSpaceListNode *vsl);
+void freeAllVarSpaceList(af_VarSpaceListNode *vsl);
+
+void addVarSpaceGC(af_VarSpace *vs, af_Core *core);
+void addVarGC(af_Var *var, af_Core *core);
+
+bool addVarToVarSpace(af_Var *var, af_VarSpace *vs);
+bool makeVarToVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
+                       af_VarSpace *vs);
+
+af_Var *findVarFromVarSpace(char *name, af_VarSpace *vs);
+af_Var *findVarFromVarList(char *name, af_VarSpaceListNode *vsl);
 
 #endif //AFUN__VAR_H_PUBLIC

src/core/__env.h

@@ -16,7 +16,7 @@ struct af_Core {  // 解释器核心
 
     // 基本量信息
     struct af_Object *global;  // 顶级属对象
-    struct af_Object *belong;  // 顶级继承对象
+    struct af_Object *object;  // 顶级继承对象
 
     // 保护空间
     bool in_init;  // 是否在初始化模式
@@ -31,6 +31,8 @@ struct af_Activity {  // 活动记录器
 
     struct af_VarSpaceListNode *var_list;  // 变量空间
     bool var_free;  // 是否需要释放变量空间
+
+    af_Object *belong;  // 属对象
 };
 
 struct af_Environment {  // 运行环境

src/core/__gc.h

@@ -4,7 +4,16 @@
 #include "env.h"
 #include "gc.h"
 
-#define GC_CHAIN(type) struct type *next, *prev;
+typedef struct GC_Var GC_Var;
+typedef struct GC_VarSpace GC_VarSpace;
+typedef struct GC_Object GC_Object;
+typedef struct GC_ObjectData GC_ObjectData;
+
+#define GC_FREE_EXCHANGE(obj) do { \
+if ((obj)->gc.prev != NULL) (obj)->gc.prev->gc.next = (obj)->gc.next; \
+if ((obj)->gc.next != NULL) (obj)->gc.next->gc.prev = (obj)->gc.prev; } while(0)
+
+#define GC_CHAIN(type) struct type *next, *prev
 typedef uint32_t GcCount;
 
 struct gc_info {
@@ -14,26 +23,23 @@ struct gc_info {
     bool reachable;  // 可达标记 [同时标识已迭代]
 };
 
-typedef struct GC_ObjectData GC_ObjectData;
 struct GC_ObjectData {
     struct gc_info info;
     GC_CHAIN(af_ObjectData);
     bool done_del;  // 是否已析构
 };
 
-typedef struct GC_Object GC_Object;
 struct GC_Object {
     struct gc_info info;
     GC_CHAIN(af_Object);
 };
 
-typedef struct GC_Var GC_Var;
 struct GC_Var {
     struct gc_info info;
     GC_CHAIN(af_Var);
 };
 
-typedef struct GC_VarSpace GC_VarSpace;
+
 struct GC_VarSpace {
     struct gc_info info;
     GC_CHAIN(af_VarSpace);
@@ -42,5 +48,6 @@ struct GC_VarSpace {
 #undef GC_CHAIN
 
 bool gc_RunGC(af_Environment *env);
+void gc_addObjectData(struct af_ObjectData *obj, af_Core *core);  // af_ObjectData 不对外公开
 
 #endif //AFUN_GC_H

src/core/__object.h

@@ -5,6 +5,12 @@
 
 #ifndef AFUN__OBJECT_H
 #define AFUN__OBJECT_H
+
+// 这些typedef可能会被下面include的文件使用
+typedef struct af_ObjectData af_ObjectData;
+typedef struct af_ObjectAPINode af_ObjectAPINode;
+typedef struct af_ObjectAPI af_ObjectAPI;
+
 #include "macro.h"
 #include "tool.h"
 #include "object.h"
@@ -12,22 +18,18 @@
 
 #define API_HASHTABLE_SIZE (8)
 
-typedef struct af_Inherit af_Inherit;
-typedef struct af_ObjectAPINode af_ObjectAPINode;
-typedef struct af_ObjectAPI af_ObjectAPI;
-
 typedef void pValueAPI();
 NEW_DLC_SYMBOL(pValueAPI, pAPIFUNC);
 
 struct af_ObjectAPINode {
-    char *api_name;  // api名字
+    char *name;  // api名字
     DLC_SYMBOL(pAPIFUNC) api;  // api函数
     struct af_ObjectAPINode *next;
 };
 
 struct af_ObjectAPI {
     uint32_t count;  // api个数记录
-    struct af_ObjectAPINode (*node)[API_HASHTABLE_SIZE];
+    struct af_ObjectAPINode *(node[API_HASHTABLE_SIZE]);
 };
 
 struct af_ObjectData {
@@ -58,4 +60,9 @@ struct af_Inherit {
     struct af_Inherit *next;
 };
 
+void freeObjectData(af_ObjectData *od);  // gc使用
+int addAPIToObjectData(DlcHandle *dlc, char *func_name, char *api_name,
+                       af_ObjectData *od);
+af_ObjectAPINode *findObjectDataAPINode(char *api_name, af_ObjectData *od);
+
 #endif //AFUN__OBJECT_H

src/core/__var.h

@@ -1,18 +1,18 @@
 #ifndef AFUN__VAR_H
 #define AFUN__VAR_H
+
+// 这些typedef可能会被下面include的文件使用
+typedef struct af_VarNode af_VarNode;
+typedef struct af_VarCup af_VarCup;
+
 #include "macro.h"
 #include "var.h"
 #include "__gc.h"
 
 #define VAR_HASHTABLE_SIZE (8)
 
-typedef struct af_VarNode af_VarNode;
-typedef struct af_VarSpaceListNode af_VarSpaceListNode;
-typedef struct af_VarCup af_VarCup;
-
 struct af_VarNode {
     char *id;  // 变量存储值的id为NULL
-    char permissions[3];  // 读-1 写-2 读且写-3 不读不写-0 [自己权限 后代权限 外部权限]
     struct af_Object *obj;
     struct af_VarNode *next;
 };
@@ -20,6 +20,7 @@ struct af_VarNode {
 struct af_Var {
     char *name;
     struct af_VarNode *vn;
+    char permissions[3];  // 读-1 写-2 读且写-3 不读不写-0 [自己权限 后代权限 外部权限]
     GC_Var gc;
 };
 
@@ -30,7 +31,7 @@ struct af_VarCup {
 
 struct af_VarSpace {
     bool is_protect;  // 是否为保护变量空间
-    struct af_VarCup (*var)[VAR_HASHTABLE_SIZE];
+    struct af_VarCup *(var[VAR_HASHTABLE_SIZE]);
     GC_VarSpace gc;
 };
 
@@ -39,4 +40,5 @@ struct af_VarSpaceListNode {  // 变量链
     struct af_VarSpaceListNode *next;
 };
 
+
 #endif //AFUN__VAR_H

src/core/bytecode.c

@@ -85,7 +85,7 @@ af_ByteCode *connectByteCode(af_ByteCode **base, af_ByteCode *next) {
     return next;
 }
 
-af_ByteCode *CopyByteCode(af_ByteCode *base, FilePath *path) {
+af_ByteCode *copyByteCode(af_ByteCode *base, FilePath *path) {
     af_ByteCode *dest = NULL;
     af_ByteCode **pdest = &dest;
 

src/core/gc.c

@@ -152,7 +152,7 @@ static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
 
 static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist) {
     plist = reachableVarSpace(core->protect, plist);
-    plist = reachableObject(core->belong, plist);
+    plist = reachableObject(core->object, plist);
     plist = reachableObject(core->global, plist);
 
     for (af_ObjectData *od = core->gc_ObjectData; od != NULL; od = od->gc.next) {
@@ -209,45 +209,32 @@ bool resetGC(af_Core *core) {
     return true;
 }
 
-#define FREE_EXCHANGE(obj) do { \
-if ((obj)->gc.prev != NULL) (obj)->gc.prev->gc.next = (obj)->gc.next; \
-if ((obj)->gc.next != NULL) (obj)->gc.next->gc.prev = (obj)->gc.prev; } while(0)
-
 static void freeValue(af_Core *core) {
     for (af_ObjectData *od = core->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
-        if (!od->gc.info.reachable) {  // 暂时不考虑析构函数
-            FREE_EXCHANGE(od);
-            // 释放函数
-        }
+        if (!od->gc.info.reachable)  // 暂时不考虑析构函数
+            freeObjectData(od);
     }
 
     for (af_Object *obj = core->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
-        if (!obj->gc.info.reachable) {
-            FREE_EXCHANGE(obj);
-            // 释放函数
-        }
+        if (!obj->gc.info.reachable)
+            freeObject(obj);
     }
 
     for (af_VarSpace *vs = core->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
-        if (!vs->gc.info.reachable) {
-            FREE_EXCHANGE(vs);
-            // 释放函数
-        }
+        if (!vs->gc.info.reachable)
+            freeVarSpace(vs);
     }
 
     for (af_Var *var = core->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
-        if (!var->gc.info.reachable) {
-            FREE_EXCHANGE(var);
-            // 释放函数
-        }
+        if (!var->gc.info.reachable)
+            freeVar(var);
     }
 }
 
-#undef FREE_EXCHANGE
 
 #define GC_ADD_FUNC_DEFINED(type) \
 void gc_add##type(af_##type *obj, af_Core *core) { \

src/core/object.c

@@ -0,0 +1,195 @@
+#include "__object.h"
+#include "__env.h"
+#include "tool.h"
+
+static af_ObjectData *makeObjectData_Pri(char *id, size_t data_size, bool inherit_api, bool allow_iherit);
+static af_Object *makeObject_Pri(char *id, size_t data_size, bool inherit_api, bool allow_iherit);
+
+static af_ObjectAPINode *makeObjectAPINode(DlcHandle *dlc, char *func_name, char *api_name);
+static af_ObjectAPINode *freeObjectAPINode(af_ObjectAPINode *apin);
+static void freeAllObjectAPINode(af_ObjectAPINode *apin);
+static af_ObjectAPI *makeObjectAPI(void);
+static void freeObjectAPI(af_ObjectAPI *api);
+
+
+static af_ObjectData *makeObjectData_Pri(char *id, size_t data_size, bool inherit_api, bool allow_iherit) {
+    af_ObjectData *od = calloc(sizeof(af_ObjectData), 1);
+    od->id = strCopy(id == NULL ? "Unknow" : id);
+
+    if (data_size != 0)
+        od->data = calloc(data_size, 1);
+    od->size = data_size;
+
+    if (inherit_api)
+        od->api = NULL;
+    else
+        od->api = makeObjectAPI();
+
+    od->allow_inherit = allow_iherit;
+    od->inherit_api = inherit_api;
+
+    od->var_space = makeVarSpace();
+    od->iherit = NULL;
+
+    od->base = NULL;
+    return od;
+}
+
+static af_Object *makeObject_Pri(char *id, size_t data_size, bool inherit_api, bool allow_iherit) {
+    af_Object *obj = calloc(sizeof(af_Object), 1);
+    obj->belong = NULL;
+    obj->data = makeObjectData_Pri(id, data_size, inherit_api, allow_iherit);
+    obj->data->base = obj;
+    return obj;
+}
+
+/*
+ * 函数名: 创建一个object
+ * 目标: 生成Object和ObjectData, 并且添加到gc链表中
+ * 若处于初始化模式, 则belong, inherit等可以设置为NULL, 由后期统一填上
+ */
+af_Object *makeObject(char *id, size_t data_size, bool inherit_api, bool allow_iherit,
+                      af_Inherit *inherit, af_Environment *env) {
+    af_Object *obj = makeObject_Pri(id, data_size, inherit_api, allow_iherit);
+    if (!env->core->in_init && env->activity->belong == NULL)
+        obj->belong = env->core->global;
+    else
+        obj->belong = env->activity->belong;
+
+    if (!env->core->in_init && inherit == NULL) {
+        obj->data->iherit = makenIherit(env->core->object);
+    } else
+        obj->data->iherit = inherit;
+
+    if (!env->core->in_init && inherit_api)
+        obj->data->api = obj->data->iherit->obj->data->api;
+
+    gc_addObjectData(obj->data, env->core);
+    gc_addObject(obj, env->core);
+    return obj;
+}
+
+/*
+ * 函数名: freeObjectData
+ * 目标: 释放ObjectData, 仅GC和freeObject函数可用
+ * 对外API中, 创建对象的基本单位都是af_Object, 无法直接操控af_ObjectData
+ */
+void freeObjectData(af_ObjectData *od) {
+    free(od->id);
+    free(od->data);
+    if (!od->inherit_api)
+        freeObjectAPI(od->api);
+    if (!od->var_space->gc.info.start_gc)
+        freeVarSpace(od->var_space);
+    freeAllIherit(od->iherit);
+    GC_FREE_EXCHANGE(od);
+    free(od);
+}
+
+void freeObject(af_Object *obj) {
+    freeObjectData(obj->data);
+    GC_FREE_EXCHANGE(obj);
+    free(obj);
+}
+
+af_Inherit *makenIherit(af_Object *obj) {
+    af_Inherit *ih = calloc(sizeof(af_Inherit), 1);
+    ih->obj = obj;
+    return ih;
+}
+
+af_Inherit *freeIherit(af_Inherit *ih) {
+    af_Inherit *next = ih->next;
+    free(ih);
+    return next;
+}
+
+void freeAllIherit(af_Inherit *ih) {
+    while (ih != NULL)
+        ih = freeIherit(ih);
+}
+
+static af_ObjectAPINode *makeObjectAPINode(DlcHandle *dlc, char *func_name, char *api_name) {
+    DLC_SYMBOL(pAPIFUNC) func = READ_SYMBOL(dlc, func_name, pAPIFUNC);
+    if (func == NULL)
+        return NULL;
+
+    af_ObjectAPINode *apin = calloc(sizeof(af_ObjectAPINode), 1);
+    apin->api = func;
+    apin->name = strCopy(api_name);
+    return apin;
+}
+
+static af_ObjectAPINode *freeObjectAPINode(af_ObjectAPINode *apin) {
+    af_ObjectAPINode *next = apin->next;
+    FREE_SYMBOL(apin->api);
+    free(apin->name);
+    free(apin);
+    return next;
+}
+
+static void freeAllObjectAPINode(af_ObjectAPINode *apin) {
+    while (apin != NULL)
+        apin = freeObjectAPINode(apin);
+}
+
+static af_ObjectAPI *makeObjectAPI(void) {
+    af_ObjectAPI *api = calloc(sizeof(af_ObjectAPI), 1);
+    return api;
+}
+
+static void freeObjectAPI(af_ObjectAPI *api) {
+    for (int i = 0; i < API_HASHTABLE_SIZE; i++)
+        freeAllObjectAPINode(api->node[i]);
+    free(api);
+}
+
+/*
+ * 函数名: addAPIToObjectData
+ * 目标: 从DLC中获取函数并写入api
+ * 若已存在api则返回0且不作修改
+ * 若dlc中不存在指定函数则返回-1且不作修改
+ * 操作成功返回1
+ */
+int addAPIToObjectData(DlcHandle *dlc, char *func_name, char *api_name,
+                        af_ObjectData *od) {
+    time33_t index = time33(api_name);
+    af_ObjectAPINode **pNode = &od->api->node[index];
+
+    for (NULL; *pNode != NULL; pNode = &((*pNode)->next)) {
+        if (EQ_STR((*pNode)->name, api_name))
+            return 0;
+    }
+
+    *pNode = makeObjectAPINode(dlc, func_name, api_name);
+    return *pNode == NULL ? -1 : 1;
+}
+
+af_ObjectAPINode *findObjectDataAPINode(char *api_name, af_ObjectData *od) {
+    time33_t index = time33(api_name);
+    for (af_ObjectAPINode *node = od->api->node[index]; node != NULL; node = node->next) {
+        if (EQ_STR(node->name, api_name))
+            return node;
+    }
+    return NULL;
+}
+
+/*
+ * 函数名: findObjectDataAPINode
+ * 目标: 从DLC中获取函数并写入Object的API
+ */
+int addAPIToObject(DlcHandle *dlc, char *func_name, char *api_name,
+                   af_Object *obj) {
+    return addAPIToObjectData(dlc, func_name, api_name, obj->data);
+}
+
+/*
+ * 函数名: findObjectAPI
+ * 目标: 从Object中获取指定api的函数指针
+ */
+void *findObjectAPI(char *api_name, af_Object *obj) {
+    af_ObjectAPINode *node = findObjectDataAPINode(api_name, obj->data);
+    if (node == NULL)
+        return NULL;
+    return GET_SYMBOL(node->api);
+}

src/core/var.c

@@ -0,0 +1,192 @@
+#include "__var.h"
+#include "tool.h"
+
+static af_VarNode *makeVarNode(af_Object *obj, char *id);
+static af_VarNode *freeVarNode(af_VarNode *vn);
+static void freeAllVarNode(af_VarNode *vn);
+
+static af_VarCup *makeVarCup(af_Var *var);
+static af_VarCup *freeVarCup(af_VarCup *vp);
+static void freeAllVarCup(af_VarCup *vp);
+static af_Var *findVarFromVarSpaceByIndex(time33_t index, char *name, af_VarSpace *vs);
+
+static af_VarNode *makeVarNode(af_Object *obj, char *id) {
+    af_VarNode *vn = calloc(sizeof(af_VarNode), 1);
+    if (id != NULL)
+        vn->id = strCopy(id);
+    vn->obj = obj;
+    return vn;
+}
+
+static af_VarNode *freeVarNode(af_VarNode *vn) {
+    af_VarNode *next = vn->next;
+    free(next->id);
+    free(vn);
+    return next;
+}
+
+static void freeAllVarNode(af_VarNode *vn) {
+    while (vn != NULL)
+        vn = freeVarNode(vn);
+}
+
+af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_Object *obj) {
+    af_VarNode *vn = makeVarNode(obj, NULL);
+    af_Var *var = calloc(sizeof(af_Var), 1);
+    var->name = strCopy(name);
+    var->vn = vn;
+    var->permissions[0] = p_self;
+    var->permissions[1] = p_posterity;
+    var->permissions[2] = p_external;
+    return var;
+}
+
+void freeVar(af_Var *var) {
+    freeAllVarNode(var->vn);
+    free(var->name);
+    if (var->gc.info.start_gc) {
+        GC_FREE_EXCHANGE(var);
+    }
+    free(var);
+}
+
+void addVarNode(af_Var var, af_Object *obj, char *id) {
+    af_VarNode *vn = makeVarNode(obj, id);
+    vn->next = var.vn->next;  // 第一个 vn 必须表示返回值
+    var.vn->next = vn;
+}
+
+static af_VarCup *makeVarCup(af_Var *var) {
+    af_VarCup *vp = calloc(sizeof(af_VarCup), 1);
+    vp->var = var;
+    return vp;
+}
+
+static af_VarCup *freeVarCup(af_VarCup *vp) {
+    af_VarCup *next = vp->next;
+    if (!vp->var->gc.info.start_gc)
+        freeVar(vp->var);
+    free(vp);
+    return next;
+}
+
+static void freeAllVarCup(af_VarCup *vp) {
+    while (vp != NULL)
+        vp = freeVarCup(vp);
+}
+
+af_VarSpace *makeVarSpace(void) {
+    af_VarSpace *vs = calloc(sizeof(af_VarSpace), 1);
+    return vs;
+}
+
+void freeVarSpace(af_VarSpace *vs) {
+    for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
+        freeAllVarCup(vs->var[i]);
+    if (vs->gc.info.start_gc) {
+        GC_FREE_EXCHANGE(vs);
+    }
+    free(vs);
+}
+
+af_VarSpaceListNode *makeVarSpaceList(af_VarSpace *vs) {
+    af_VarSpaceListNode *vsl = calloc(sizeof(af_VarSpaceListNode), 1);
+    vsl->vs = vs;
+    return vsl;
+}
+
+af_VarSpaceListNode *freeVarSpaceList(af_VarSpaceListNode *vsl) {
+    af_VarSpaceListNode *next = vsl->next;
+    if (!vsl->vs->gc.info.start_gc)
+        freeVarSpace(vsl->vs);
+    free(vsl);
+    return next;
+}
+
+void freeAllVarSpaceList(af_VarSpaceListNode *vsl) {
+    while (vsl != NULL)
+        vsl = freeVarSpaceList(vsl);
+}
+
+void addVarSpaceGC(af_VarSpace *vs, af_Core *core) {
+    if (vs->gc.info.start_gc)
+        return;
+
+    vs->gc.info.start_gc = true;
+    gc_addVarSpace(vs, core);
+}
+
+void addVarGC(af_Var *var, af_Core *core) {
+    if (var->gc.info.start_gc)
+        return;
+
+    var->gc.info.start_gc = true;
+    gc_addVar(var, core);
+}
+
+/*
+ * 函数名: addVarToVarSpace
+ * 目标: 把var添加到VarSpace中
+ * 若已存在同名Var则返回false不作修改
+ * 否则返回true
+ */
+bool addVarToVarSpace(af_Var *var, af_VarSpace *vs) {
+    time33_t index = time33(var->name);
+    af_VarCup **pCup = &vs->var[index];
+
+    for (NULL; *pCup != NULL; pCup = &((*pCup)->next)) {
+        if (EQ_STR((*pCup)->var->name, var->name))
+            return false;
+    }
+
+    *pCup = makeVarCup(var);
+    return true;
+}
+
+/*
+ * 函数名: makeVarToVarSpace
+ * 目标: 创建一个新的var添加到VarSpace中
+ * 若已存在同名Var则返回false不作修改
+ * 否则返回true
+ */
+bool makeVarToVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
+                       af_VarSpace *vs) {
+    return addVarToVarSpace(makeVar(name, p_self, p_posterity, p_external, obj), vs);
+}
+
+/*
+ * 函数名: findVarFromVarSpaceByIndex
+ * 目标: 根据指定的index, 在VarSpace中搜索var
+ */
+static af_Var *findVarFromVarSpaceByIndex(time33_t index, char *name, af_VarSpace *vs) {
+    for (af_VarCup *cup = vs->var[index]; cup != NULL; cup = cup->next) {
+        if (EQ_STR(cup->var->name, name))
+            return cup->var;
+    }
+    return NULL;
+}
+
+/*
+ * 函数名: findVarFromVarSpace
+ * 目标: 在VarSpace中搜索var
+ */
+af_Var *findVarFromVarSpace(char *name, af_VarSpace *vs) {
+    return findVarFromVarSpaceByIndex(time33(name), name, vs);
+}
+
+/*
+ * 函数名: findVarFromVarList
+ * 目标: 在VarSpaceListNode中搜索var
+ */
+af_Var *findVarFromVarList(char *name, af_VarSpaceListNode *vsl) {
+    time33_t index = time33(name);
+    af_Var *var = NULL;
+
+    for (NULL; vsl != NULL; vsl = vsl->next) {
+        var = findVarFromVarSpaceByIndex(index, name, vsl->vs);
+        if (var != NULL)
+            return var;
+    }
+
+    return NULL;
+}

test/test_dlc.c

@@ -15,8 +15,8 @@ int main() {
     NEW_DLC_SYMBOL(int, INT);
     NEW_DLC_SYMBOL(func, FUNC);
 
-    DLC_SYMBOL(INT) *a;
-    DLC_SYMBOL(FUNC) *fun;
+    DLC_SYMBOL(INT) a;
+    DLC_SYMBOL(FUNC) fun;
 
     a = READ_SYMBOL(dlc, "num", INT);
     fun = READ_SYMBOL(dlc, "test", FUNC);