feat: 环境变量新增互斥锁

include/core/env.h

@@ -58,6 +58,7 @@ AFUN_CORE_EXPORT char setPrefix(size_t name, char prefix, af_Environment *env);
 AFUN_CORE_EXPORT void setCoreStop(af_Environment *env);
 AFUN_CORE_EXPORT void setCoreExit(int exit_code, af_Environment *env);
 AFUN_CORE_EXPORT void setCoreNormal(af_Environment *env);
+AFUN_CORE_EXPORT void setArgc(int argc, af_Environment *env);
 
 /* 消息 相关操作 */
 AFUN_CORE_EXPORT void pushMessageUp(af_Message *msg, af_Environment *env);
@@ -104,6 +105,7 @@ AFUN_CORE_EXPORT af_VarSpace *getProtectVarSpace(af_Environment *env);
 AFUN_CORE_EXPORT int32_t getGcCount(af_Environment *env);
 AFUN_CORE_EXPORT int32_t getGcMax(af_Environment *env);
 AFUN_CORE_EXPORT enum GcRunTime getGcRun(af_Environment *env);
+AFUN_CORE_EXPORT int getArgc(af_Environment *env);
 AFUN_CORE_EXPORT af_Object *getCoreGlobal(af_Environment *env);
 AFUN_CORE_EXPORT af_Object *getGlobal(af_Environment *env);
 AFUN_CORE_EXPORT af_Object *getBelong(af_Environment *env);

src/core/__env.h

@@ -45,9 +45,6 @@ struct af_Core {  // 解释器核心
     /* 基本对象信息 */
     struct af_Object *global;  // 顶级属对象
 
-    /* 保护空间 */
-    struct af_VarSpace *protect;  // 顶级保护变量空间
-
     /* 字面量基本信息 */
     af_LiteralRegex *lr;
 
@@ -226,9 +223,13 @@ struct af_EnvVar {  // 环境变量
 struct af_EnvVarSpace {  // 环境变量
     size_t count;
     struct af_EnvVar *(var[ENV_VAR_HASH_SIZE]);
+    pthread_rwlock_t lock;
 };
 
 struct af_Environment {  // 运行环境
+    /* 保护空间 */
+    struct af_VarSpace *protect;  // 顶级保护变量空间
+
     struct af_Core *core;
     struct af_EnvVarSpace *esv;
     struct af_Activity *activity;
@@ -264,7 +265,9 @@ struct af_ImportInfo {
 };
 
 /* Core 管理函数 */
-AFUN_CORE_NO_EXPORT af_Object *getBaseObjectFromCore(char *name, af_Core *core);
+void GcCountAdd1(af_Environment *env);
+void GcCountToZero(af_Environment *env);
+
 
 /* 运行时Activity设置函数 (新增Activity) */
 AFUN_CORE_NO_EXPORT bool pushExecutionActivity(af_Code *bt, bool return_first, af_Environment *env);

src/core/__gc.h

@@ -97,9 +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_addObjectDataByCore(struct af_ObjectData *obj, af_Core *core);
-AFUN_CORE_NO_EXPORT void gc_addObjectByCore(struct af_Object *obj, af_Core *core);
-AFUN_CORE_NO_EXPORT void gc_addVarByCore(struct af_Var *obj, af_Core *core);
 AFUN_CORE_NO_EXPORT void gc_addVarSpaceByCore(struct af_VarSpace *obj, af_Core *core);
 
 /* gc Reference 管理函数 : 涉及af_ObjectData 不对外公开 */

src/core/__var.h

@@ -44,12 +44,10 @@ struct af_VarSpaceListNode {  // 变量链
 
 
 /* 变量空间创建与释放 */
-AFUN_CORE_NO_EXPORT af_VarSpace *makeVarSpaceByCore(af_Object *belong, char p_self, char p_posterity, char p_external, af_Core *core);
 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 af_Var *makeVarByCore(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, 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);
 

src/core/env.c

@@ -106,9 +106,7 @@ static af_Core *makeCore(enum GcRunTime grt, af_Environment *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;
-    core->protect = makeVarSpaceByCore(NULL, 3, 3, 3, core);
     return core;
 }
 
@@ -128,9 +126,14 @@ static void freeCore(af_Environment *env) {
 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;
-    if (prefix_ == NULL || strlen(prefix_) < PREFIX_SIZE)
+    if (prefix_ == NULL || strlen(prefix_) < PREFIX_SIZE) {
+        pthread_rwlock_unlock(&env->esv->lock);
         return '-';
+    }
+
     switch (name) {
         case E_QUOTE:
             if (prefix == NUL && strchr(E_PREFIX, prefix) == NULL)
@@ -146,6 +149,7 @@ char setPrefix(size_t name, char prefix, af_Environment *env) {
     }
     char old = prefix_[name];
     prefix_[name] = prefix;
+    pthread_rwlock_unlock(&env->esv->lock);
     return old;
 }
 
@@ -153,34 +157,28 @@ char getPrefix(size_t name, af_Environment *env) {
     if (name >= PREFIX_SIZE)
         return '-';  // 表示未获取到prefix (NUL在Code中表示无prefix)
 
+    pthread_rwlock_rdlock(&env->esv->lock);
     char *prefix = env->core->prefix->data;
+    pthread_rwlock_unlock(&env->esv->lock);
     if (prefix == NULL || strlen(prefix) < PREFIX_SIZE)
         return '-';
     return prefix[name];
 }
 
 af_VarSpace *getProtectVarSpace(af_Environment *env) {
-    return env->core->protect;
+    return env->protect;
 }
 
-/*
- * 函数名: getBaseObjectFromCore
- * 目标: 从VarSpace中获取一个量
- * 作用: 用于init初始化时在保护空间获得一些初始化对象
- */
-af_Object *getBaseObjectFromCore(char *name, af_Core *core) {
-    af_Var *var = findVarFromVarSpace(name, NULL, core->protect);
-    if (var != NULL)
-        return var->vn->obj;
-    return NULL;
-}
 
 /*
  * 函数名: getBaseObject
  * 目标: getBaseObjectFromCore的对外接口
  */
 af_Object *getBaseObject(char *name, af_Environment *env) {
-    return getBaseObjectFromCore(name, env->core);
+    af_Var *var = findVarFromVarSpace(name, NULL, env->protect);
+    if (var != NULL)
+        return var->vn->obj;
+    return NULL;
 }
 
 void setCoreStop(af_Environment *env) {
@@ -190,13 +188,19 @@ void setCoreStop(af_Environment *env) {
 
 void setCoreExit(int exit_code, af_Environment *env) {
     env->core->status = core_exit;
+
+    pthread_rwlock_wrlock(&env->esv->lock);
     env->core->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;
+
+        pthread_rwlock_wrlock(&env->esv->lock);
         env->core->exit_code_->num = 0;
+        pthread_rwlock_unlock(&env->esv->lock);
     }
 }
 
@@ -634,47 +638,57 @@ static void freeAllEnvVar(af_EnvVar *var) {
 }
 
 static af_EnvVarSpace *makeEnvVarSpace(void) {
-    af_EnvVarSpace *esv = calloc(1, sizeof(af_EnvVarSpace));
-    return esv;
+    af_EnvVarSpace *evs = calloc(1, sizeof(af_EnvVarSpace));
+    pthread_rwlock_init(&evs->lock, NULL);
+    return evs;
 }
 
 static void freeEnvVarSpace(af_EnvVarSpace *evs) {
     for (int i = 0; i < ENV_VAR_HASH_SIZE; i++)
         freeAllEnvVar(evs->var[i]);
+    pthread_rwlock_destroy(&evs->lock);
     free(evs);
 }
 
 af_EnvVar *setEnvVarData_(char *name, char *data, af_Environment *env) {
     time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
+    pthread_rwlock_wrlock(&env->esv->lock);
+
     af_EnvVar **pvar = &env->esv->var[index];
     env->esv->count++;
     for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
         if (EQ_STR((*pvar)->name, name)) {
             free((*pvar)->data);
             (*pvar)->data = strCopy(data);
+            pthread_rwlock_unlock(&env->esv->lock);
             return *pvar;
         }
     }
 
     *pvar = makeEnvVar(name);
     (*pvar)->data = strCopy(data);
+    pthread_rwlock_unlock(&env->esv->lock);
     return *pvar;
 }
 
 af_EnvVar *setEnvVarNumber_(char *name, int32_t data, af_Environment *env) {
     time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
+    pthread_rwlock_wrlock(&env->esv->lock);
+
     af_EnvVar **pvar = &env->esv->var[index];
     env->esv->count++;
     for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
         if (EQ_STR((*pvar)->name, name)) {
             free((*pvar)->data);
             (*pvar)->num = data;
+            pthread_rwlock_unlock(&env->esv->lock);
             return *pvar;
         }
     }
 
     *pvar = makeEnvVar(name);
     (*pvar)->num = data;
+    pthread_rwlock_unlock(&env->esv->lock);
     return *pvar;
 }
 
@@ -688,25 +702,35 @@ void setEnvVarNumber(char *name, int32_t data, af_Environment *env) {
 
 char *findEnvVarData(char *name, af_Environment *env) {
     time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    af_EnvVar **pvar = &env->esv->var[index];
+    pthread_rwlock_rdlock(&env->esv->lock);
 
+    af_EnvVar **pvar = &env->esv->var[index];
     for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name))
-            return (*pvar)->data;
+        if (EQ_STR((*pvar)->name, name)) {
+            char *data = (*pvar)->data;
+            pthread_rwlock_unlock(&env->esv->lock);
+            return data;
+        }
     }
 
+    pthread_rwlock_unlock(&env->esv->lock);
     return NULL;
 }
 
 int32_t *findEnvVarNumber(char *name, af_Environment *env) {
     time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    af_EnvVar **pvar = &env->esv->var[index];
+    pthread_rwlock_rdlock(&env->esv->lock);
 
+    af_EnvVar **pvar = &env->esv->var[index];
     for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name))
-            return &(*pvar)->num;  // 返回指针, NULL表示没找到
+        if (EQ_STR((*pvar)->name, name)) {
+            int32_t *data = &(*pvar)->num;  // 返回指针, NULL表示没找到
+            pthread_rwlock_unlock(&env->esv->lock);
+            return data;
+        }
     }
 
+    pthread_rwlock_unlock(&env->esv->lock);
     return NULL;
 }
 
@@ -726,7 +750,7 @@ static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env) {
         return;
     }
     if (is_top) {
-        if (env->core->error_std->num == 0)
+        if (getErrorStd(env) == 0)
             fprintfErrorInfoStdout(*(af_ErrorInfo **) msg->msg);
         else
             fprintfErrorInfoStderr(*(af_ErrorInfo **) msg->msg);
@@ -780,9 +804,9 @@ static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char
  */
 static af_GuardianList *guardian_GC(char *type, bool is_guard, void *data, af_Environment *env) {
     af_GuardianList *gl = NULL;
-    if (env->core->gc_runtime->num == grt_always ||
-        env->core->gc_runtime->num == grt_count && env->core->gc_count->num >= env->core->gc_max->num) {
-        env->core->gc_count->num = 0;  // 清零
+    enum GcRunTime grt = getGcRun(env);
+    if (grt == grt_always || grt == grt_count && getGcCount(env) >= getGcMax(env)) {
+        GcCountToZero(env);  // 清零
         gl = gc_RunGC(env);
         if (gl != NULL)
             writeDebugLog(aFunCoreLogger, "GC destruct");
@@ -828,6 +852,8 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
 
     env->esv = makeEnvVarSpace();
     env->core = makeCore(grt, 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);
@@ -855,12 +881,12 @@ af_Environment *makeEnvironment(enum GcRunTime grt) {
     FREE_SYMBOL(func5);
 
     env->core->status = core_init;
-    env->activity = makeTopActivity(NULL, NULL, env->core->protect, env->core->global);
+    env->activity = makeTopActivity(NULL, NULL, env->protect, env->core->global);
     return env;
 }
 
 void enableEnvironment(af_Environment *env) {
-    env->core->protect->is_protect = true;
+    env->protect->is_protect = true;
     env->core->status = core_normal;
 }
 
@@ -1166,7 +1192,7 @@ bool pushImportActivity(af_Code *bt, af_Object **obj, char *mark, af_Environment
     if (*obj == NULL)
         return false;
 
-    af_Activity *activity = makeTopImportActivity(bt, bt, env->core->protect, *obj, mark);
+    af_Activity *activity = makeTopImportActivity(bt, bt, env->protect, *obj, mark);
     pushActivity(activity, env);
     return true;
 }
@@ -1260,7 +1286,7 @@ bool setFuncActivityAddVar(af_Environment *env){
         if (fi->scope == normal_scope)  // 使用函数变量空间
             env->activity->var_list = env->activity->func_var_list;
         else if (fi->scope == pure_scope) {  // 纯函数只有 protect 变量空间
-            env->activity->var_list = makeVarSpaceList(env->core->protect);
+            env->activity->var_list = makeVarSpaceList(env->protect);
             env->activity->new_vs_count = 1;
         } else if (fi->scope == super_pure_scope)  // 超纯函数没有变量空间, 因此不得为超内嵌函数(否则var_list就为NULL了)
             env->activity->var_list = NULL;
@@ -1823,23 +1849,60 @@ 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;
+    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;
+    pthread_rwlock_unlock(&env->esv->lock);
 }
 
 int32_t getGcCount(af_Environment *env) {
-    return env->core->gc_count->num;
+    pthread_rwlock_rdlock(&env->esv->lock);
+    int32_t res = env->core->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++;
+    pthread_rwlock_unlock(&env->esv->lock);
+}
+
+void GcCountToZero(af_Environment *env) {
+    pthread_rwlock_wrlock(&env->esv->lock);
+    env->core->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;
+    pthread_rwlock_unlock(&env->esv->lock);
 }
 
 int32_t getGcMax(af_Environment *env) {
-    return env->core->gc_max->num;
+    pthread_rwlock_rdlock(&env->esv->lock);
+    int32_t res = env->core->gc_max->num;
+    pthread_rwlock_unlock(&env->esv->lock);
+    return res;
 }
 
 enum GcRunTime getGcRun(af_Environment *env) {
-    return env->core->gc_runtime->num;
+    pthread_rwlock_rdlock(&env->esv->lock);
+    enum GcRunTime res = env->core->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;
+    pthread_rwlock_unlock(&env->esv->lock);
+    return res;
 }
 
 af_Object *getCoreGlobal(af_Environment *env) {
@@ -1933,9 +1996,15 @@ int isCoreExit(af_Environment *env) {
 }
 
 bool getErrorStd(af_Environment *env) {
-    return env->core->error_std->num;  // true-stderr, false-stdout
+    pthread_rwlock_rdlock(&env->esv->lock);
+    bool res = env->core->error_std->num != 0;  // true-stderr, false-stdout
+    pthread_rwlock_unlock(&env->esv->lock);
+    return res;
 }
 
 int32_t getCoreExitCode(af_Environment *env) {
-    return env->core->exit_code_->num;
+    pthread_rwlock_rdlock(&env->esv->lock);
+    int res = env->core->exit_code_->num;
+    pthread_rwlock_unlock(&env->esv->lock);
+    return res;
 }

src/core/gc.c

@@ -12,16 +12,7 @@ void gc_addObjectData(af_ObjectData *obj, af_Environment *env){
         env->core->gc_ObjectData->gc.prev = obj;
     obj->gc.next = env->core->gc_ObjectData;
     env->core->gc_ObjectData = obj;
-    env->core->gc_count->num++;
-}
-
-void gc_addObjectDataByCore(af_ObjectData *obj, af_Core *core){
-    if (obj->gc.next != ((void *) 0) || obj->gc.prev != ((void *) 0))
-        return;
-    obj->gc.prev = ((void *) 0);
-    obj->gc.next = core->gc_ObjectData;
-    core->gc_ObjectData = obj;
-    core->gc_count->num++;
+    GcCountAdd1(env);
 }
 
 void gc_addObjectDataReference(af_ObjectData *obj){
@@ -42,16 +33,7 @@ void gc_addObject(af_Object *obj, af_Environment *env){
         env->core->gc_Object->gc.prev = obj;
     obj->gc.next = env->core->gc_Object;
     env->core->gc_Object = obj;
-    env->core->gc_count->num++;
-}
-
-void gc_addObjectByCore(af_Object *obj, af_Core *core){
-    if (obj->gc.next != ((void *) 0) || obj->gc.prev != ((void *) 0))
-        return;
-    obj->gc.prev = ((void *) 0);
-    obj->gc.next = core->gc_Object;
-    core->gc_Object = obj;
-    core->gc_count->num++;
+    GcCountAdd1(env);
 }
 
 void gc_addObjectReference(af_Object *obj){
@@ -72,16 +54,7 @@ void gc_addVar(af_Var *obj, af_Environment *env) {
         env->core->gc_Var->gc.prev = obj;
     obj->gc.next = env->core->gc_Var;
     env->core->gc_Var = obj;
-    env->core->gc_count->num++;
-}
-
-void gc_addVarByCore(af_Var *obj, af_Core *core) {
-    if (obj->gc.next != ((void *) 0) || obj->gc.prev != ((void *) 0))
-        return;
-    obj->gc.prev = ((void *) 0);
-    obj->gc.next = core->gc_Var;
-    core->gc_Var = obj;
-    core->gc_count->num++;
+    GcCountAdd1(env);
 }
 
 void gc_addVarReference(af_Var *obj) {
@@ -101,16 +74,7 @@ void gc_addVarSpace(af_VarSpace *obj, af_Environment *env){
     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;
-    env->core->gc_count->num++;
-}
-
-void gc_addVarSpaceByCore(af_VarSpace *obj, af_Core *core) {
-    if (obj->gc.next != ((void *) 0) || obj->gc.prev != ((void *) 0))
-        return;
-    obj->gc.prev = ((void *) 0);
-    obj->gc.next = core->gc_VarSpace;
-    core->gc_VarSpace = obj;
-    core->gc_count->num++;
+    GcCountAdd1(env);
 }
 
 void gc_addVarSpaceReference(af_VarSpace *obj) {
@@ -191,7 +155,7 @@ static pgc_Analyzed reachableObject(struct af_Object *od, pgc_Analyzed plist);
 /* gc运行函数 */
 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 pgc_Analyzed iterLinker(af_Environment *core, pgc_Analyzed plist);
 static pgc_Analyzed checkDestruct(af_Environment *env, paf_GuardianList *pdl, pgc_Analyzed plist);
 static pgc_Analyzed checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed plist);
 
@@ -290,27 +254,27 @@ static pgc_Analyzed reachableVarSpaceList(struct af_VarSpaceListNode *vsl, pgc_A
     return plist;
 }
 
-static pgc_Analyzed iterLinker(af_Core *core, pgc_Analyzed plist) {
-    plist = reachableVarSpace(core->protect, plist);
-    if (core->global != NULL)
-        plist = reachableObject(core->global, plist);
+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);
 
-    for (af_ObjectData *od = core->gc_ObjectData; od != NULL; od = od->gc.next) {
+    for (af_ObjectData *od = env->core->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 = core->gc_Object; obj != NULL; obj = obj->gc.next) {
+    for (af_Object *obj = env->core->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 = core->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
+    for (af_VarSpace *vs = env->core->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 = core->gc_Var; var != NULL; var = var->gc.next) {
+    for (af_Var *var = env->core->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);
     }
@@ -418,7 +382,7 @@ af_GuardianList *gc_RunGC(af_Environment *env) {
     paf_GuardianList pgl = ≷
     resetGC(env);
 
-    plist = iterLinker(env->core, plist);  // 临时量分析 (临时量都是通过reference标记的)
+    plist = iterLinker(env, plist);  // 临时量分析 (临时量都是通过reference标记的)
     plist = reachable(env->activity, plist);
     plist = checkAnalyzed(analyzed, plist);  // 先处理剩余的Object
     plist = checkDestruct(env, &pgl, plist);  // 在检查析构

src/core/run.c

@@ -164,7 +164,7 @@ static bool codeElement(af_Code *code, af_Environment *env) {
     if (checkLiteralCode(code->element.data, &func, &in_protect, env)) {
         /* 字面量执行 */
         if (in_protect)
-            var = findVarFromVarSpace(func, env->activity->belong, env->core->protect);
+            var = findVarFromVarSpace(func, env->activity->belong, env->protect);
         else
             var = findVarFromVarList(func, env->activity->belong, env->activity->vsl);
 

src/core/var.c

@@ -53,18 +53,6 @@ af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_O
     return var;
 }
 
-af_Var *makeVarByCore(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Core *core){
-    af_VarNode *vn = makeVarNode(obj, NULL);
-    af_Var *var = calloc(1, sizeof(af_Var));
-    var->name = strCopy(name);
-    var->vn = vn;
-    var->permissions[0] = p_self;
-    var->permissions[1] = p_posterity;
-    var->permissions[1] = p_external;
-    gc_addVarByCore(var, core);
-    return var;
-}
-
 void freeVar(af_Var *var, af_Environment *env){
     freeAllVarNode(var->vn);
     free(var->name);
@@ -135,19 +123,6 @@ af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char
     return vs;
 }
 
-af_VarSpace *makeVarSpaceByCore(af_Object *belong, char p_self, char p_posterity, char p_external, af_Core *core) {
-    if (core->status != core_creat && belong == NULL)
-        return NULL;
-
-    af_VarSpace *vs = calloc(1, sizeof(af_VarSpace));
-    vs->belong = belong;
-    vs->permissions[0] = p_self;
-    vs->permissions[1] = p_posterity;
-    vs->permissions[2] = p_external;
-    gc_addVarSpaceByCore(vs, core);
-    return vs;
-}
-
 void freeVarSpace(af_VarSpace *vs, af_Environment *env) {
     for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
         freeAllVarCup(vs->var[i]);
@@ -283,9 +258,9 @@ bool makeVarToVarSpaceList(char *name, char p_self, char p_posterity, char p_ext
  * 调用 addVarToVarSpace
  */
 bool makeVarToProtectVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env){
-    env->core->protect->is_protect = false;
-    bool re = addVarToVarSpace(makeVar(name, p_self, p_posterity, p_external, obj, env), env->activity->belong, env->core->protect);
-    env->core->protect->is_protect = true;
+    env->protect->is_protect = false;
+    bool re = addVarToVarSpace(makeVar(name, p_self, p_posterity, p_external, obj, env), env->activity->belong, env->protect);
+    env->protect->is_protect = true;
     return re;
 }
 
@@ -297,10 +272,10 @@ bool makeVarToProtectVarSpace(char *name, char p_self, char p_posterity, char p_
  * 调用 addVarToVarSpace
  */
 bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
-    bool is_protect = env->core->protect->is_protect;
-    env->core->protect->is_protect = false;
-    bool re = addVarToVarSpace(var, NULL, env->core->protect);
-    env->core->protect->is_protect = is_protect;
+    bool is_protect = env->protect->is_protect;
+    env->protect->is_protect = false;
+    bool re = addVarToVarSpace(var, NULL, env->protect);
+    env->protect->is_protect = is_protect;
     return re;
 }
 

src/runtime/aFunlang.c

@@ -71,14 +71,14 @@ af_Environment *creatAFunEnvironment(int argc, char **argv){
     for(int i = 0; i < argc; i++)
         writeTrackLog(aFunCoreLogger, "[aFunlang] Env-arg %d. %s", i, argv[i]);
 
-    env->core->argc->num = argc;
+    setArgc(argc, env);
     for (int i = 0; i < argc; i++) {
         char tmp[512] = {0};
         snprintf(tmp, 512, ev_argvx_prefix "%d", i);
         setEnvVarData(tmp, argv[i], env);
     }
 
-    runtimeTool("base", &code, NULL, env->core->protect, env);
+    runtimeTool("base", &code, NULL, env->protect, env);
 
     if (code != NULL) {
         bool res = iterCode(code, 0, env);
@@ -118,7 +118,7 @@ static int runCode_(af_Parser *parser, int mode, FilePath save_path, af_Environm
     bool res = iterCode(bt_code, mode, env);
     freeAllCode(bt_code);
     if (!res)
-        return env->core->exit_code_->num;
+        return getCoreExitCode(env);
     return 0;
 }
 
@@ -194,7 +194,7 @@ int runCodeFromMemory(af_Code *code, int mode, af_Environment *env){
 
     bool res = iterCode(code, mode, env);
     if (!res)
-        return env->core->exit_code_->num;
+        return getCoreExitCode(env);
     return 0;
 }
 

src/runtime/base/quit.c

@@ -34,8 +34,7 @@ static bool funcVarList(char *id, af_Object *obj, af_VarSpaceListNode **vsl, voi
 }
 
 static af_FuncBody *funcBody(af_CallFuncInfo *cfi, af_Environment *env) {
-    env->core->exit_code_->num = 0;
-    env->core->status = core_exit;
+    setCoreExit(0, env);
     pushMessageDown(makeNORMALMessage(getGlobal(env)), env);
     return NULL;
 }