feat: Core和Enviroment合并

src/core/__env.h

@@ -3,7 +3,6 @@
 #include "tool.h"
 #include "pthread.h"
 
-typedef struct af_Core af_Core;
 typedef struct af_Activity af_Activity;
 typedef struct af_ActivityTrackBack af_ActivityTrackBack;
 typedef struct af_EnvVarSpace af_EnvVarSpace;
@@ -27,37 +26,6 @@ typedef struct af_ErrorBacktracking af_ErrorBacktracking;
 #define ENV_VAR_HASH_SIZE (8)
 typedef uint16_t ActivityCount;
 
-struct af_Core {  // 解释器核心
-    enum af_CoreStatus {
-        core_creat = 0,
-        core_init,  // 执行初始化程序
-        core_normal,  // 正常执行
-        core_stop,  // 当前运算退出
-        core_exit,  // 解释器退出
-    } status;
-
-    /* GC基本信息 */
-    struct af_ObjectData *gc_ObjectData;
-    struct af_Object *gc_Object;
-    struct af_Var *gc_Var;
-    struct af_VarSpace *gc_VarSpace;
-
-    /* 基本对象信息 */
-    struct af_Object *global;  // 顶级属对象
-
-    /* 字面量基本信息 */
-    af_LiteralRegex *lr;
-
-    /* 数据 */
-    af_EnvVar *gc_count;
-    af_EnvVar *gc_max;
-    af_EnvVar *gc_runtime;
-    af_EnvVar *prefix;
-    af_EnvVar *exit_code_;  // 退出代码
-    af_EnvVar *argc;  // 参数个数
-    af_EnvVar *error_std;  // Error输出的位置 0-stdout 其他-stderr
-};
-
 struct af_Message {
     char *type;  // 消息类型
     void *msg;  // 信息内容
@@ -227,10 +195,37 @@ struct af_EnvVarSpace {  // 环境变量
 };
 
 struct af_Environment {  // 运行环境
+    enum af_CoreStatus {
+        core_creat = 0,
+        core_init,  // 执行初始化程序
+        core_normal,  // 正常执行
+        core_stop,  // 当前运算退出
+        core_exit,  // 解释器退出
+    } status;
+
     /* 保护空间 */
     struct af_VarSpace *protect;  // 顶级保护变量空间
 
-    struct af_Core *core;
+    /* 数据 */
+    af_EnvVar *gc_count;
+    af_EnvVar *gc_max;
+    af_EnvVar *gc_runtime;
+    af_EnvVar *prefix;
+    af_EnvVar *exit_code_;  // 退出代码
+    af_EnvVar *argc;  // 参数个数
+    af_EnvVar *error_std;  // Error输出的位置 0-stdout 其他-stderr
+
+    /* 基本对象信息 */
+    struct af_Object *global;  // 顶级属对象
+
+    /* 字面量基本信息 */
+    af_LiteralRegex *lr;
+
+    struct af_ObjectData *gc_ObjectData;
+    struct af_Object *gc_Object;
+    struct af_Var *gc_Var;
+    struct af_VarSpace *gc_VarSpace;
+
     struct af_EnvVarSpace *esv;
     struct af_Activity *activity;
     struct af_TopMsgProcess *process;
@@ -265,8 +260,8 @@ struct af_ImportInfo {
 };
 
 /* Core 管理函数 */
-void GcCountAdd1(af_Environment *env);
-void GcCountToZero(af_Environment *env);
+AFUN_CORE_NO_EXPORT void GcCountAdd1(af_Environment *env);
+AFUN_CORE_NO_EXPORT void GcCountToZero(af_Environment *env);
 
 
 /* 运行时Activity设置函数 (新增Activity) */

src/core/__gc.h

@@ -9,9 +9,9 @@ typedef struct GC_ObjectData GC_ObjectData;
 typedef struct af_GcList af_GcList;
 typedef struct gc_Analyzed gc_Analyzed, **pgc_Analyzed;
 
-#define GC_FREE_EXCHANGE(obj, Type, Core) do { \
+#define GC_FREE_EXCHANGE(obj, Type, Env) do { \
 {if ((obj)->gc.prev != NULL) {(obj)->gc.prev->gc.next = (obj)->gc.next;} \
- else {(Core)->gc_##Type = (obj)->gc.next;}} \
+ else {(Env)->gc_##Type = (obj)->gc.next;}} \
 {if ((obj)->gc.next != NULL) {(obj)->gc.next->gc.prev = (obj)->gc.prev;}}} while(0)
 
 #define GC_CHAIN(type) struct type *next, *prev
@@ -97,7 +97,6 @@ AFUN_CORE_NO_EXPORT void gc_addObject(af_Object *obj, af_Environment *env);
 AFUN_CORE_NO_EXPORT void gc_addVar(af_Var *obj, af_Environment *env);
 AFUN_CORE_NO_EXPORT void gc_addVarSpace(af_VarSpace *obj, af_Environment *env);
 AFUN_CORE_NO_EXPORT void gc_addObjectData(struct af_ObjectData *obj, af_Environment *env);
-AFUN_CORE_NO_EXPORT void gc_addVarSpaceByCore(struct af_VarSpace *obj, af_Core *core);
 
 /* gc Reference 管理函数 : 涉及af_ObjectData 不对外公开 */
 AFUN_CORE_NO_EXPORT void gc_addObjectDataReference(af_ObjectData *obj);
@@ -111,7 +110,7 @@ AFUN_CORE_NO_EXPORT void gc_freeAllValueData(af_Environment *env);
 AFUN_CORE_NO_EXPORT void gc_freeAllValue(af_Environment *env);
 
 /* gc 信息函数 */
-AFUN_CORE_NO_EXPORT void printGCByCore(af_Core *core);
+AFUN_CORE_NO_EXPORT void printGCByCore(af_Environment *env);
 
 /* gc 运行时函数 */
 AFUN_CORE_NO_EXPORT void resetGC(af_Environment *env);

src/core/__object.h

@@ -70,7 +70,4 @@ AFUN_CORE_NO_EXPORT af_Object *findObjectAttributesByObjectData(char *name, af_O
 AFUN_CORE_NO_EXPORT void freeObjectDataData(af_ObjectData *od, af_Environment *env);
 AFUN_CORE_NO_EXPORT void freeObjectData(af_ObjectData *od, af_Environment *env);
 
-/* Object 释放函数 */
-AFUN_CORE_NO_EXPORT void freeObjectByCore(af_Object *obj, af_Core *core);
-
 #endif //AFUN_OBJECT_H_

src/core/__var.h

@@ -45,10 +45,8 @@ struct af_VarSpaceListNode {  // 变量链
 
 /* 变量空间创建与释放 */
 AFUN_CORE_NO_EXPORT void freeVarSpace(af_VarSpace *vs, af_Environment *env);
-AFUN_CORE_NO_EXPORT void freeVarSpaceByCore(af_VarSpace *vs, af_Core *core);
 
 /* 变量创建与释放 */
 AFUN_CORE_NO_EXPORT void freeVar(af_Var *var, af_Environment *env);
-AFUN_CORE_NO_EXPORT void freeVarByCore(af_Var *var, af_Core *core);
 
 #endif //AFUN_VAR_H_

src/core/env.c

@@ -4,10 +4,6 @@
 #include "__run.h"
 #include "__sig.h"
 
-/* Core 创建和释放 */
-static af_Core *makeCore(enum GcRunTime grt, af_Environment *env);
-static void freeCore(af_Environment *env);
-
 /* Activity 创建和释放 */
 static af_Activity *makeActivity(af_Message *msg_up, af_VarSpaceListNode *vsl, af_Object *belong);
 static af_Activity *makeFuncActivity(af_Code *bt_top, af_Code *bt_start, bool return_first, af_Message *msg_up,
@@ -91,44 +87,12 @@ static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, a
 /* 变量检查函数 */
 static bool isInfixFunc(af_Code *code, af_Environment *env);
 
-static af_Core *makeCore(enum GcRunTime grt, af_Environment *env) {
-    af_Core *core = calloc(1, sizeof(af_Core));
-
-    /* 设置默认prefix */
-    char prefix[PREFIX_SIZE + 1] = "";
-    prefix[E_QUOTE] = '\'';
-    prefix[B_EXEC] = '\'';
-    prefix[B_EXEC_FIRST] = '$';
-    core->prefix = setEnvVarData_(ev_sys_prefix, prefix, env);
-    core->gc_runtime = setEnvVarNumber_(ev_grt, grt, env);
-    core->gc_max = setEnvVarNumber_(ev_gcmax, DEFAULT_GC_COUNT_MAX, env);
-    core->gc_count = setEnvVarNumber_(ev_gccount, 0, env);
-    core->exit_code_ = setEnvVarNumber_(ev_exit_code, 0, env);
-    core->argc = setEnvVarNumber_(ev_argc, 0, env);
-    core->error_std = setEnvVarNumber_(ev_error_std, 0, env);
-    core->status = core_creat;
-    return core;
-}
-
-/*
- * 函数名: freeCore
- * 目标: 释放Core
- * 因为gc_freeAllValue需要env作为参数, 故使用env作为freeCore的参数
- */
-static void freeCore(af_Environment *env) {
-    freeAllLiteralRegex(env->core->lr);
-    gc_freeAllValueData(env);  // 先释放ObjectData的void *data
-    printGCByCore(env->core);
-    gc_freeAllValue(env);  // 再完全释放Object
-    free(env->core);
-}
-
 char setPrefix(size_t name, char prefix, af_Environment *env) {
     if (name >= PREFIX_SIZE)
         return '-';  // 表示未获取到prefix (NUL在Code中表示无prefix)
 
     pthread_rwlock_wrlock(&env->esv->lock);
-    char *prefix_ = env->core->prefix->data;
+    char *prefix_ = env->prefix->data;
     if (prefix_ == NULL || strlen(prefix_) < PREFIX_SIZE) {
         pthread_rwlock_unlock(&env->esv->lock);
         return '-';
@@ -158,7 +122,7 @@ char getPrefix(size_t name, af_Environment *env) {
         return '-';  // 表示未获取到prefix (NUL在Code中表示无prefix)
 
     pthread_rwlock_rdlock(&env->esv->lock);
-    char *prefix = env->core->prefix->data;
+    char *prefix = env->prefix->data;
     pthread_rwlock_unlock(&env->esv->lock);
     if (prefix == NULL || strlen(prefix) < PREFIX_SIZE)
         return '-';
@@ -182,24 +146,24 @@ af_Object *getBaseObject(char *name, af_Environment *env) {
 }
 
 void setCoreStop(af_Environment *env) {
-    if (env->core->status != core_exit)
-        env->core->status = core_stop;
+    if (env->status != core_exit)
+        env->status = core_stop;
 }
 
 void setCoreExit(int exit_code, af_Environment *env) {
-    env->core->status = core_exit;
+    env->status = core_exit;
 
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->exit_code_->num = exit_code;
+    env->exit_code_->num = exit_code;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 void setCoreNormal(af_Environment *env) {
-    if (env->core->status == core_exit || env->core->status == core_stop) {
-        env->core->status = core_normal;
+    if (env->status == core_exit || env->status == core_stop) {
+        env->status = core_normal;
 
         pthread_rwlock_wrlock(&env->esv->lock);
-        env->core->exit_code_->num = 0;
+        env->exit_code_->num = 0;
         pthread_rwlock_unlock(&env->esv->lock);
     }
 }
@@ -255,7 +219,7 @@ static af_Activity *makeTopImportActivity(af_Code *bt_top, af_Code *bt_start, af
 }
 
 static af_Activity *makeGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env) {
-    af_Activity *activity = makeActivity(NULL, NULL, env->core->global);
+    af_Activity *activity = makeActivity(NULL, NULL, env->global);
     activity->type = act_guardian;
 
     activity->var_list = makeVarSpaceList(getProtectVarSpace(env));
@@ -851,12 +815,26 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
     pthread_mutex_init(&env->in_run, &attr);  // 检测锁
 
     env->esv = makeEnvVarSpace();
-    env->core = makeCore(grt, env);
+
+    /* 设置默认prefix */
+    char prefix[PREFIX_SIZE + 1] = "";
+    prefix[E_QUOTE] = '\'';
+    prefix[B_EXEC] = '\'';
+    prefix[B_EXEC_FIRST] = '$';
+    env->prefix = setEnvVarData_(ev_sys_prefix, prefix, env);
+    env->gc_runtime = setEnvVarNumber_(ev_grt, grt, env);
+    env->gc_max = setEnvVarNumber_(ev_gcmax, DEFAULT_GC_COUNT_MAX, env);
+    env->gc_count = setEnvVarNumber_(ev_gccount, 0, env);
+    env->exit_code_ = setEnvVarNumber_(ev_exit_code, 0, env);
+    env->argc = setEnvVarNumber_(ev_argc, 0, env);
+    env->error_std = setEnvVarNumber_(ev_error_std, 0, env);
+
+    /* 创建保护空间 */
     env->protect = makeVarSpace(NULL, 3, 3, 3, env);
 
     /* 生成global对象 */
-    env->core->global = makeGlobalObject(env);
-    addVarToProtectVarSpace(makeVar("global", 3, 3, 3, env->core->global, env), env);
+    env->global = makeGlobalObject(env);
+    addVarToProtectVarSpace(makeVar("global", 3, 3, 3, env->global, env), env);
 
     /* 设置NORMAL顶级处理器 */
     DLC_SYMBOL(TopMsgProcessFunc) func1 = MAKE_SYMBOL(mp_NORMAL, TopMsgProcessFunc);
@@ -880,19 +858,19 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
     addGuardian("GC", true, 0, func5, NULL, NULL, env);
     FREE_SYMBOL(func5);
 
-    env->core->status = core_init;
-    env->activity = makeTopActivity(NULL, NULL, env->protect, env->core->global);
+    env->status = core_init;
+    env->activity = makeTopActivity(NULL, NULL, env->protect, env->global);
     return env;
 }
 
 void enableEnvironment(af_Environment *env) {
     env->protect->is_protect = true;
-    env->core->status = core_normal;
+    env->status = core_normal;
 }
 
 void freeEnvironment(af_Environment *env) {
     bool res = true;
-    if (env->core->status != core_creat)
+    if (env->status != core_creat)
         res = iterDestruct(10, env);
 
     freeAllActivity(env->activity);
@@ -901,7 +879,10 @@ void freeEnvironment(af_Environment *env) {
     freeAllGuardian(env->guardian, env);
 
     pthread_mutex_destroy(&env->in_run);
-    freeCore(env);  // core最后释放, 因为Object等需要最后释放
+    freeAllLiteralRegex(env->lr);
+    gc_freeAllValueData(env);  // 先释放ObjectData的void *data
+    printGCByCore(env);
+    gc_freeAllValue(env);  // 再完全释放Object
 
     if (!res)
         writeErrorLog(aFunCoreLogger, "Run iterDestruct error.");
@@ -1200,7 +1181,7 @@ bool pushImportActivity(af_Code *bt, af_Object **obj, char *mark, af_Environment
 bool pushGuadianFuncActivity(af_GuardianList *gl, af_Environment *env) {
     env->activity->gl_next = gl->next;
 
-    af_Object *belong = gl->obj != NULL ? gl->obj : env->core->global;
+    af_Object *belong = gl->obj != NULL ? gl->obj : env->global;
     /* 隐式调用不设置 bt_top */
     af_Activity *activity = makeFuncActivity(NULL, NULL, false, env->activity->msg_up,
                                              env->activity->var_list, belong, NULL);
@@ -1543,8 +1524,8 @@ bool pushLiteralRegex(char *pattern, char *func, bool in_protect, af_Environment
     af_LiteralRegex *lr = makeLiteralRegex(pattern, func, in_protect);
     if (lr == NULL)
         return false;
-    lr->next = env->core->lr;
-    env->core->lr = lr;
+    lr->next = env->lr;
+    env->lr = lr;
     return true;
 }
 
@@ -1554,7 +1535,7 @@ bool pushLiteralRegex(char *pattern, char *func, bool in_protect, af_Environment
  * 注意: func被写入函数名, 但不是复制式写入
  */
 bool checkLiteralCode(char *literal, char **func, bool *in_protect, af_Environment *env) {
-    for (af_LiteralRegex *lr = env->core->lr; lr != NULL; lr = lr->next) {
+    for (af_LiteralRegex *lr = env->lr; lr != NULL; lr = lr->next) {
         if (matchRegex(literal, lr->rg, NULL) == 1) {
             if (func != NULL)
                 *func = lr->func;  // 不使用复制
@@ -1850,63 +1831,63 @@ af_GuardianList **contectGuardianList(af_GuardianList *new, af_GuardianList **ba
 
 void setGcMax(int32_t max, af_Environment *env) {
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->gc_max->num = max;
+    env->gc_max->num = max;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 void setGcRun(enum GcRunTime grt, af_Environment *env) {
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->gc_runtime->num = grt;
+    env->gc_runtime->num = grt;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 int32_t getGcCount(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    int32_t res = env->core->gc_count->num;
+    int32_t res = env->gc_count->num;
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }
 
 void GcCountAdd1(af_Environment *env) {
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->gc_count->num++;
+    env->gc_count->num++;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 void GcCountToZero(af_Environment *env) {
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->gc_count->num = 0;
+    env->gc_count->num = 0;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 void setArgc(int argc, af_Environment *env) {
     pthread_rwlock_wrlock(&env->esv->lock);
-    env->core->argc->num = argc;
+    env->argc->num = argc;
     pthread_rwlock_unlock(&env->esv->lock);
 }
 
 int32_t getGcMax(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    int32_t res = env->core->gc_max->num;
+    int32_t res = env->gc_max->num;
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }
 
 enum GcRunTime getGcRun(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    enum GcRunTime res = env->core->gc_runtime->num;
+    enum GcRunTime res = env->gc_runtime->num;
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }
 int getArgc(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    int res = env->core->argc->num;
+    int res = env->argc->num;
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }
 
 af_Object *getCoreGlobal(af_Environment *env) {
-    return env->core->global;
+    return env->global;
 }
 
 af_Object *getGlobal(af_Environment *env) {
@@ -1915,7 +1896,7 @@ af_Object *getGlobal(af_Environment *env) {
         if (activity->type == act_top || activity->type == act_top_import)
             return activity->belong;
     }
-    return env->core->global;
+    return env->global;
 }
 
 af_Object *getBelong(af_Environment *env) {
@@ -1988,23 +1969,23 @@ af_VarSpaceListNode *getRunVarSpaceList(af_Environment *env) {
 }
 
 int isCoreExit(af_Environment *env) {
-    if (env->core->status == core_exit)
+    if (env->status == core_exit)
         return 1;
-    else if (env->core->status == core_stop)
+    else if (env->status == core_stop)
         return -1;
     return 0;
 }
 
 bool getErrorStd(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    bool res = env->core->error_std->num != 0;  // true-stderr, false-stdout
+    bool res = env->error_std->num != 0;  // true-stderr, false-stdout
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }
 
 int32_t getCoreExitCode(af_Environment *env) {
     pthread_rwlock_rdlock(&env->esv->lock);
-    int res = env->core->exit_code_->num;
+    int res = env->exit_code_->num;
     pthread_rwlock_unlock(&env->esv->lock);
     return res;
 }

src/core/gc.c

@@ -8,10 +8,10 @@
 
 void gc_addObjectData(af_ObjectData *obj, af_Environment *env){
     obj->gc.prev = ((void *) 0);
-    if (env->core->gc_ObjectData != ((void *) 0))
-        env->core->gc_ObjectData->gc.prev = obj;
-    obj->gc.next = env->core->gc_ObjectData;
-    env->core->gc_ObjectData = obj;
+    if (env->gc_ObjectData != ((void *) 0))
+        env->gc_ObjectData->gc.prev = obj;
+    obj->gc.next = env->gc_ObjectData;
+    env->gc_ObjectData = obj;
     GcCountAdd1(env);
 }
 
@@ -29,10 +29,10 @@ GcCount gc_getObjectDataReference(af_ObjectData *obj){
 
 void gc_addObject(af_Object *obj, af_Environment *env){
     obj->gc.prev = ((void *) 0);
-    if (env->core->gc_Object != ((void *) 0))
-        env->core->gc_Object->gc.prev = obj;
-    obj->gc.next = env->core->gc_Object;
-    env->core->gc_Object = obj;
+    if (env->gc_Object != ((void *) 0))
+        env->gc_Object->gc.prev = obj;
+    obj->gc.next = env->gc_Object;
+    env->gc_Object = obj;
     GcCountAdd1(env);
 }
 
@@ -50,10 +50,10 @@ GcCount gc_getObjectReference(af_Object *obj){
 
 void gc_addVar(af_Var *obj, af_Environment *env) {
     obj->gc.prev = ((void *) 0);
-    if (env->core->gc_Var != ((void *) 0))
-        env->core->gc_Var->gc.prev = obj;
-    obj->gc.next = env->core->gc_Var;
-    env->core->gc_Var = obj;
+    if (env->gc_Var != ((void *) 0))
+        env->gc_Var->gc.prev = obj;
+    obj->gc.next = env->gc_Var;
+    env->gc_Var = obj;
     GcCountAdd1(env);
 }
 
@@ -71,9 +71,9 @@ GcCount gc_getVarReference(af_Var *obj) {
 
 void gc_addVarSpace(af_VarSpace *obj, af_Environment *env){
     obj->gc.prev = ((void *) 0);
-    if (env->core->gc_VarSpace != ((void *) 0)) { env->core->gc_VarSpace->gc.prev = obj; }
-    obj->gc.next = env->core->gc_VarSpace;
-    env->core->gc_VarSpace = obj;
+    if (env->gc_VarSpace != ((void *) 0)) { env->gc_VarSpace->gc.prev = obj; }
+    obj->gc.next = env->gc_VarSpace;
+    env->gc_VarSpace = obj;
     GcCountAdd1(env);
 }
 
@@ -256,25 +256,25 @@ static pgc_Analyzed reachableVarSpaceList(struct af_VarSpaceListNode *vsl, pgc_A
 
 static pgc_Analyzed iterLinker(af_Environment *env, pgc_Analyzed plist) {
     plist = reachableVarSpace(env->protect, plist);
-    if (env->core->global != NULL)
-        plist = reachableObject(env->core->global, plist);
+    if (env->global != NULL)
+        plist = reachableObject(env->global, plist);
 
-    for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (!od->gc.info.reachable && (od->gc.info.reference > 0 || od->gc.info.not_clear))
             plist = reachableObjectData(od, plist);
     }
 
-    for (af_Object *obj = env->core->gc_Object; obj != NULL; obj = obj->gc.next) {
+    for (af_Object *obj = env->gc_Object; obj != NULL; obj = obj->gc.next) {
         if (!obj->gc.info.reachable && (obj->gc.info.reference > 0 || obj->gc.info.not_clear))
             plist = reachableObject(obj, plist);
     }
 
-    for (af_VarSpace *vs = env->core->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
+    for (af_VarSpace *vs = env->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
         if (!vs->gc.info.reachable && (vs->gc.info.reference > 0 || vs->gc.info.not_clear))
             plist = reachableVarSpace(vs, plist);
     }
 
-    for (af_Var *var = env->core->gc_Var; var != NULL; var = var->gc.next) {
+    for (af_Var *var = env->gc_Var; var != NULL; var = var->gc.next) {
         if (!var->gc.info.reachable && (var->gc.info.reference > 0 || var->gc.info.not_clear))
             plist = reachableVar(var, plist);
     }
@@ -313,21 +313,21 @@ static pgc_Analyzed checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed plist) {
 }
 
 void resetGC(af_Environment *env) {
-    for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next)
+    for (af_ObjectData *od = env->gc_ObjectData; od != NULL; od = od->gc.next)
         od->gc.info.reachable = false;
 
-    for (af_Object *obj = env->core->gc_Object; obj != NULL; obj = obj->gc.next)
+    for (af_Object *obj = env->gc_Object; obj != NULL; obj = obj->gc.next)
         obj->gc.info.reachable = false;
 
-    for (af_VarSpace *vs = env->core->gc_VarSpace; vs != NULL; vs = vs->gc.next)
+    for (af_VarSpace *vs = env->gc_VarSpace; vs != NULL; vs = vs->gc.next)
         vs->gc.info.reachable = false;
 
-    for (af_Var *var = env->core->gc_Var; var != NULL; var = var->gc.next)
+    for (af_Var *var = env->gc_Var; var != NULL; var = var->gc.next)
         var->gc.info.reachable = false;
 }
 
 static void freeValue(af_Environment *env) {
-    for (af_ObjectData *od = env->core->gc_ObjectData, *next; od != NULL; od = next) {
+    for (af_ObjectData *od = env->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
         if (!od->gc.info.reachable) {
             writeTrackLog(aFunCoreLogger, "ObjectData: %p", od);
@@ -335,33 +335,33 @@ static void freeValue(af_Environment *env) {
         }
     }
 
-    for (af_Object *obj = env->core->gc_Object, *next; obj != NULL; obj = next) {
+    for (af_Object *obj = env->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
         if (!obj->gc.info.reachable) {
             writeTrackLog(aFunCoreLogger, "Object: %p", obj);
-            freeObjectByCore(obj, env->core);
+            freeObject(obj, env);
         }
     }
 
-    for (af_VarSpace *vs = env->core->gc_VarSpace, *next; vs != NULL; vs = next) {
+    for (af_VarSpace *vs = env->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
         if (!vs->gc.info.reachable) {
             writeTrackLog(aFunCoreLogger, "VarSpace: %p", vs);
-            freeVarSpaceByCore(vs, env->core);
+            freeVarSpace(vs, env);
         }
     }
 
-    for (af_Var *var = env->core->gc_Var, *next; var != NULL; var = next) {
+    for (af_Var *var = env->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
         if (!var->gc.info.reachable) {
             writeTrackLog(aFunCoreLogger, "Var: %p", var);
-            freeVarByCore(var, env->core);
+            freeVar(var, env);
         }
     }
 }
 
 static pgc_Analyzed checkDestruct(af_Environment *env, paf_GuardianList *pgl, pgc_Analyzed plist) {
-    for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (!od->gc.info.reachable && !od->gc.done_destruct) {
             af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, NULL, od);
             if (func == NULL)
@@ -394,7 +394,7 @@ af_GuardianList *gc_RunGC(af_Environment *env) {
 }
 
 paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
-    for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->gc_ObjectData; od != NULL; od = od->gc.next) {
         if (!od->gc.done_destruct) {
             af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, NULL, od);
             if (func == NULL)
@@ -407,36 +407,36 @@ paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
 }
 
 void gc_freeAllValueData(af_Environment *env) {
-    for (af_ObjectData *od = env->core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->gc_ObjectData; od != NULL; od = od->gc.next) {
         freeObjectDataData(od, env);
     }
 }
 
 void gc_freeAllValue(af_Environment *env) {
-    for (af_ObjectData *od = env->core->gc_ObjectData, *next; od != NULL; od = next) {
+    for (af_ObjectData *od = env->gc_ObjectData, *next; od != NULL; od = next) {
         next = od->gc.next;
         freeObjectData(od, env);
     }
 
-    for (af_Object *obj = env->core->gc_Object, *next; obj != NULL; obj = next) {
+    for (af_Object *obj = env->gc_Object, *next; obj != NULL; obj = next) {
         next = obj->gc.next;
-        freeObjectByCore(obj, env->core);
+        freeObject(obj, env);
     }
 
-    for (af_VarSpace *vs = env->core->gc_VarSpace, *next; vs != NULL; vs = next) {
+    for (af_VarSpace *vs = env->gc_VarSpace, *next; vs != NULL; vs = next) {
         next = vs->gc.next;
-        freeVarSpaceByCore(vs, env->core);
+        freeVarSpace(vs, env);
     }
 
-    for (af_Var *var = env->core->gc_Var, *next; var != NULL; var = next) {
+    for (af_Var *var = env->gc_Var, *next; var != NULL; var = next) {
         next = var->gc.next;
-        freeVarByCore(var, env->core);
+        freeVar(var, env);
     }
 }
 
-void printGCByCore(af_Core *core) {
+void printGCByCore(af_Environment *env) {
     bool success = true;
-    for (af_ObjectData *od = core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->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);
             success = false;
@@ -444,7 +444,7 @@ void printGCByCore(af_Core *core) {
             writeTrackLog(aFunCoreLogger, "af_ObjectData(%p) Reference: %d", od, od->gc.info.reference);
     }
 
-    for (af_Object *obj = core->gc_Object; obj != NULL; obj = obj->gc.next) {
+    for (af_Object *obj = env->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);
             success = false;
@@ -452,7 +452,7 @@ void printGCByCore(af_Core *core) {
             writeTrackLog(aFunCoreLogger, "af_Object(%p->%p) Reference: %d", obj, obj->data, obj->gc.info.reference);
     }
 
-    for (af_VarSpace *vs = core->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
+    for (af_VarSpace *vs = env->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);
             success = false;
@@ -460,7 +460,7 @@ void printGCByCore(af_Core *core) {
             writeTrackLog(aFunCoreLogger, "af_VarSpace(%p) Reference: %d", vs, vs->gc.info.reference);
     }
 
-    for (af_Var *var = core->gc_Var; var != NULL; var = var->gc.next) {
+    for (af_Var *var = env->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);
             success = false;

src/core/object.c

@@ -74,17 +74,17 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
     af_Inherit *ih = NULL;
     if (inherit != NULL)
         ih = inherit;
-    else if (env->core->global != NULL)  // init模式生成: global
-        ih = makeInherit(env->core->global);
-    else if (env->core->status != core_creat)
+    else if (env->global != NULL)  // init模式生成: global
+        ih = makeInherit(env->global);
+    else if (env->status != core_creat)
         return NULL;
 
     if (belong == NULL) {
         if (env->activity != NULL)
             belong = env->activity->belong;
-        else if (env->core->status == core_init)  // init模式生成: global
-            belong = env->core->global;
-        else if (env->core->status != core_creat)  // 只有creat可以使用belong=NULL
+        else if (env->status == core_init)  // init模式生成: global
+            belong = env->global;
+        else if (env->status != core_creat)  // 只有creat可以使用belong=NULL
             return NULL;
     }
 
@@ -127,17 +127,12 @@ void freeObjectData(af_ObjectData *od, af_Environment *env) {
     if (od->free_api)
         freeObjectAPI(od->api);
     freeAllInherit(od->inherit);
-    GC_FREE_EXCHANGE(od, ObjectData, env->core);
+    GC_FREE_EXCHANGE(od, ObjectData, env);
     free(od);
 }
 
 void freeObject(af_Object *obj, af_Environment *env) {
-    GC_FREE_EXCHANGE(obj, Object, env->core);
-    free(obj);
-}
-
-void freeObjectByCore(af_Object *obj, af_Core *core) {
-    GC_FREE_EXCHANGE(obj, Object, core);
+    GC_FREE_EXCHANGE(obj, Object, env);
     free(obj);
 }
 

src/core/run.c

@@ -102,13 +102,13 @@ static int checkMacro(af_Message *msg, af_Environment *env) {
 static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
     if (env == NULL || pthread_mutex_trylock(&env->in_run) != 0)
         return false;
-    if (env->core == NULL || env->activity == NULL || env->core->status == core_exit) {
+    if (env->activity == NULL || env->status == core_exit) {
         pthread_mutex_unlock(&env->in_run);
         return false;
     }
 
-    if (env->core->status == core_stop)
-        env->core->status = core_normal;
+    if (env->status == core_stop)
+        env->status = core_normal;
 
     switch (mode) {
         case 0:
@@ -333,7 +333,7 @@ static bool checkGetArgEnd(af_Message *msg, af_Environment *env) {
 }
 
 static bool checkStop(af_Environment *env) {
-    if (env->core->status == core_stop || env->core->status == core_exit) {
+    if (env->status == core_stop || env->status == core_exit) {
         while (env->activity->type != act_top || env->activity->prev != NULL)
             popActivity(false, NULL, env);  // is_normal=false, 非正常退出, 释放mark
         popActivity(false, NULL, env);  // 再释放 act_top

src/core/var.c

@@ -56,14 +56,7 @@ af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_O
 void freeVar(af_Var *var, af_Environment *env){
     freeAllVarNode(var->vn);
     free(var->name);
-    GC_FREE_EXCHANGE(var, Var, env->core);
-    free(var);
-}
-
-void freeVarByCore(af_Var *var, af_Core *core) {
-    freeAllVarNode(var->vn);
-    free(var->name);
-    GC_FREE_EXCHANGE(var, Var, core);
+    GC_FREE_EXCHANGE(var, Var, env);
     free(var);
 }
 
@@ -111,7 +104,7 @@ 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 (env->core->status != core_creat && belong == NULL)
+    if (env->status != core_creat && belong == NULL)
         return NULL;
 
     af_VarSpace *vs = calloc(1, sizeof(af_VarSpace));
@@ -126,14 +119,7 @@ af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char
 void freeVarSpace(af_VarSpace *vs, af_Environment *env) {
     for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
         freeAllVarCup(vs->var[i]);
-    GC_FREE_EXCHANGE(vs, VarSpace, env->core);
-    free(vs);
-}
-
-void freeVarSpaceByCore(af_VarSpace *vs, af_Core *core) {
-    for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
-        freeAllVarCup(vs->var[i]);
-    GC_FREE_EXCHANGE(vs, VarSpace, core);
+    GC_FREE_EXCHANGE(vs, VarSpace, env);
     free(vs);
 }