refactor: 重构iterCode函数

将iterCode函数拆分为多个函数
减少代码冗余

include/env.h

@@ -28,7 +28,6 @@ char setPrefix(size_t name, char prefix, af_Environment *env);
 af_Environment *makeEnvironment(enum GcRunTime grt);
 bool enableEnvironment(af_Environment *env);
 void freeEnvironment(af_Environment *env);
-void checkRunGC(af_Environment *env);
 
 /* 保护空间管理函数 */
 bool addVarToProtectVarSpace(af_Var *var, af_Environment *env);

src/core/env.c

@@ -439,13 +439,6 @@ void freeEnvironment(af_Environment *env) {
     free(env);
 }
 
-void checkRunGC(af_Environment *env) {
-    if (env->core->gc_run == grt_always ||
-        env->core->gc_run == grt_count && env->core->gc_count >= env->core->gc_count_max) {
-        gc_RunGC(env);
-    }
-}
-
 bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
     return addVarToVarSpace(var, env->core->protect);
 }

src/core/run.c

@@ -3,14 +3,124 @@
 #include "run.h"
 #include "__env.h"
 
+/* 工具函数: 初始化类型 */
+static bool iterCodeInit(af_Code *code, af_Environment *env);
+
+/* 工具函数: 运行函数 */
+static void setRunVarSpaceList(af_Environment *env);
+static bool runCodeBase(af_Environment *env);
+static bool runCode(af_Message **msg, bool *run_code, af_Environment *env);
+static void processMsg(af_Message *msg, bool run_code, af_Environment *env);
+
+/* 工具函数: Message类函数 */
+static af_Message *getTopMsg(af_Environment *env);
+
+/* 工具函数: 检查类型 */
+static bool checkInMsgType(char *type, af_Environment *env);
+static bool checkLiteral(af_Message **msg, af_Environment *env);
+static bool checkMacro(af_Message *msg, af_Environment *env);
+static bool checkRunGC(af_Environment *env);
+static int checkMsg(af_Message *msg, af_Environment *env);
+bool checkNormalEnd(af_Message *msg, af_Environment *env);
+static bool checkGetArgEnd(af_Message *msg, af_Environment *env);
+
 /* Code 执行函数 */
 static bool codeVariable(af_Code *code, af_Environment *env);
 static bool codeLiteral(af_Code *code, af_Environment *env);
 static bool codeBlock(af_Code *code, af_Environment *env);
 
-/* 工具函数 */
-static bool checkInMsgType(char *type, af_Environment *env);
+/*
+ * 函数名: checkInMsgType
+ * 目标: 检查type是否在对应的msg_type中 (检查该activity是否可以处理该信息)
+ */
+static bool checkInMsgType(char *type, af_Environment *env) {
+    if (env->activity->body_next == NULL || env->activity->body_next->msg_type == NULL)
+        return false;
+    for (char *msg_type_node = *env->activity->body_next->msg_type; msg_type_node != NULL; msg_type_node++) {
+        if (EQ_STR(type, msg_type_node))
+            return true;
+    }
+    return false;
+}
+
+/*
+ * 函数名: checkLiteral
+ * 目标: 检查是否字面量调用, 若是则返回true并调用API, 否则返回false不做修改
+ */
+static bool checkLiteral(af_Message **msg, af_Environment *env) {
+    if (!env->activity->is_literal)  // 非字面量
+        return true;
+    if ((*msg) == NULL || !EQ_STR((*msg)->type, "NORMAL"))  // (*msg)非正常值
+        return false;
+
+    af_Object *obj = *(af_Object **)((*msg)->msg);
+    obj_literalSetting *func = findAPI("obj_literalSetting", obj->data->api);
+    if (func == NULL) {
+        gc_delReference(obj);
+        freeMessage(*msg);
+        *msg = makeMessage("ERROR-STR", 0);
+        return false;
+    }
+
+    for (af_LiteralDataList *ld = env->activity->ld; ld != NULL; ld = ld->next)
+        func(ld->literal_data, obj->data->data, obj, env);
+
+    freeAllLiteralData(env->activity->ld);
+    env->activity->ld = NULL;
+    env->activity->is_literal = false;
+    printf("Literal %p\n", obj);
+    return true;
+}
+
+/*
+ * 函数名: checkMacro
+ * 目标: 检查是否宏函数调用, 若是则返回true并修改activity隐式调用(activity继续执行时则会执行该调用), 否则返回false不做修改
+ */
+static bool checkMacro(af_Message *msg, af_Environment *env) {
+    if (env->activity->fi == NULL || !env->activity->fi->is_macro)  // 非宏函数
+        return false;
+    if (msg == NULL || !EQ_STR(msg->type, "NORMAL"))  // msg非正常值
+        return false;
+
+    af_Object *obj = *(af_Object **)(msg->msg);
+    pushMacroFuncActivity(obj, env);
+    gc_delReference(obj);
+    freeMessage(msg);
+    return true;
+}
 
+/*
+ * 函数名: checkRunGC
+ * 目标: 检查是否该运行gc, 若是则返回true并运行gc, 否则返回false
+ */
+static bool checkRunGC(af_Environment *env) {
+    if (env->core->gc_run == grt_always ||
+        env->core->gc_run == grt_count && env->core->gc_count >= env->core->gc_count_max) {
+        gc_RunGC(env);
+        return true;
+    }
+    return false;
+}
+
+/*
+ * 函数名: iterCodeInit
+ * 目标: 初始化activity和environment (若environment中未存在activity则通过code新增一个TopActivity, 否则沿用原activity)
+ */
+static bool iterCodeInit(af_Code *code, af_Environment *env) {
+    env->process_msg_first = false;  // 优先处理msg而不是运行代码
+    if (env->activity == NULL && code == NULL || env->activity != NULL && code != NULL)
+        return false;
+    if (code != NULL && !addTopActivity(code, env))  // 初始化环境
+        return false;
+    return true;
+}
+
+/*
+ * 函数名: codeVariable
+ * 目标: 执行变量访问代码 (设置bt_next)
+ * 返回-false 表示执行失败, 或执行成功得到一个变量值      (msg_down中写入消息)
+ * 返回-true  表示执行成功, 得到一个对象函数, 并且隐式调用 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
+ */
 static bool codeVariable(af_Code *code, af_Environment *env) {
     af_Var *var = findVarFromVarList(code->variable.name, env->activity->vsl);
 
@@ -33,6 +143,12 @@ static bool codeVariable(af_Code *code, af_Environment *env) {
     return pushVariableActivity(code, var->vn->obj, env);
 }
 
+/*
+ * 函数名: codeLiteral
+ * 目标: 执行字面量生成代码 (设置bt_next)
+ * 返回-false 表示执行错误 (msg_down中写入消息)
+ * 返回-true  表示执行成功 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
+ */
 static bool codeLiteral(af_Code *code, af_Environment *env) {
     af_Var *var;
     if (code->literal.in_protect)
@@ -49,6 +165,12 @@ static bool codeLiteral(af_Code *code, af_Environment *env) {
     return pushLiteralActivity(code, var->vn->obj, env);
 }
 
+/*
+ * 函数名: codeBlock
+ * 目标: 执行括号语法 (顺序执行, 函数调用)
+ * 返回-false 表示执行错误 (msg_down中写入消息)
+ * 返回-true  表示执行成功 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
+ */
 static bool codeBlock(af_Code *code, af_Environment *env) {
     if (code->prefix == env->core->prefix[B_EXEC] && code->block.type == parentheses)  // 顺序执行, 返回尾项
         return pushExecutionActivity(code, false, env);
@@ -58,177 +180,224 @@ static bool codeBlock(af_Code *code, af_Environment *env) {
         return pushFuncActivity(env->activity->bt_next, env);
 }
 
-static bool checkInMsgType(char *type, af_Environment *env) {
-    if (env->activity->body_next == NULL || env->activity->body_next->msg_type == NULL)
-        return false;
-    for (char *msg_type_node = *env->activity->body_next->msg_type; msg_type_node != NULL; msg_type_node++) {
-        if (EQ_STR(type, msg_type_node))
-            return true;
+/*
+ * 函数名: setRunVarSpaceList
+ * 目标: 设置运行的变量空间
+ * 仅在act_arg模式下, 允许运行变量空间设置为函数变量空间 (参数计算)
+ */
+static void setRunVarSpaceList(af_Environment *env) {
+    if (env->activity->status == act_arg && env->activity->run_in_func && env->activity->func_var_list != NULL)
+        env->activity->vsl = env->activity->func_var_list;
+    else
+        env->activity->vsl = env->activity->var_list;
+}
+
+/*
+ * 函数名: runCodeBase
+ * 目标: 获取代码类型, 调用(codeLiteral, codeVariable, codeBlock)运行代码
+ * 返回true- 表示执行无消息写入 msg_down (通常是无实质性代码运算)
+ * 返回false-表示有消息写入 msg_down
+ */
+static bool runCodeBase(af_Environment *env) {
+    switch (env->activity->bt_next->type) {
+        case literal:
+            if (codeLiteral(env->activity->bt_next, env))
+                return true;  // 若运行成功则跳转到下一次运行, 该步骤仅为设置Activity
+            break;
+        case variable:
+            if (codeVariable(env->activity->bt_next, env))
+                return true;
+            break;
+        case block:
+            if (codeBlock(env->activity->bt_next, env))
+                return true;  // 若运行成功则跳转到下一次运行, 该步骤仅为设置Activity
+        default:
+            break;  // 错误
     }
     return false;
 }
 
-static bool checkLiteral(af_Message **msg, af_Environment *env) {
-    if (!env->activity->is_literal)
-        return true;
+/*
+ * 函数名: getTopMsg
+ * 目标: 获取msg_down顶层信息, 若没有则产生错误
+ */
+static af_Message *getTopMsg(af_Environment *env) {
+    if (env->activity->msg_down == NULL)  // 若未获得 msg
+        return makeMessage("ERROR-STR", 0);
+    else
+        return getFirstMessage(env);
+}
 
-    af_Object *obj = *(af_Object **)((*msg)->msg);
-    obj_literalSetting *func = findAPI("obj_literalSetting", obj->data->api);
-    if (func == NULL) {
-        gc_delReference(obj);
-        freeMessage(*msg);
-        *msg = makeMessage("ERROR-STR", 0);
+/*
+ * 函数名: checkMsg
+ * 目标: 检查msg是否为NORMAL, 并且检查该信号是否可被处理
+ * 返回- (1) 正常
+ * 返回- (0) 不可处理的信号
+ * 返回-(-1) 非正常但通过msg_type判断为可被处理的信号
+ */
+static int checkMsg(af_Message *msg, af_Environment *env) {
+    if (EQ_STR(msg->type, "NORMAL"))
+        return 1;  // 正常
+
+    pushMessageDown(msg, env);  // msg不弹出
+    if (env->activity->status != act_normal || !checkInMsgType(msg->type, env)) {  // 非normal模式, 或normal模式下msg_type不匹配该msg
+        env->activity->return_first = false;
+        env->activity->return_obj = NULL;
+        return 0;
+    }
+
+    return -1;  // 遇到非normal, 但继续运行
+}
+
+/*
+ * 函数名: runCode
+ * 目标: 执行代码
+ * *msg - 写入获取的执行信息
+ * *run_code - 写入是否有代码运行
+ * 返回-true  表示未获得msg (未进行实质性运算)
+ * 返回-false 表示获得msg  (进行实质性运算)
+ */
+static bool runCode(af_Message **msg, bool *run_code, af_Environment *env) {
+    bool process_msg_first = env->process_msg_first;
+    env->process_msg_first = false;
+
+    if (env->activity->bt_next == NULL && !process_msg_first) {
+        *run_code = false;
+        *msg = NULL;
         return false;
     }
 
-    for (af_LiteralDataList *ld = env->activity->ld; ld != NULL; ld = ld->next)
-        func(ld->literal_data, obj->data->data, obj, env);
+    *run_code = true;
+    if (env->activity->bt_next != NULL && !process_msg_first && runCodeBase(env)) { // runCode返回true, 则代表需要 continue
+        *msg = NULL;
+        return true;  // (该步骤仅为设置Activity, 无实际运算)
+    } else
+        (*msg) = getTopMsg(env);
 
-    freeAllLiteralData(env->activity->ld);
-    env->activity->ld = NULL;
-    env->activity->is_literal = false;
-    printf("Literal %p\n", obj);
-    return true;
+    switch (checkMsg((*msg), env)) {
+        case 0:
+            *msg = NULL;
+            popActivity(NULL, env);  // 跳出当前activity
+            return true;
+        case -1:
+            (*msg) = NULL;
+            break;
+        case 1:
+            if (env->activity->return_first && env->activity->return_obj == NULL)  // 设置return_first
+                env->activity->return_obj = *(af_Object **)(*msg)->msg;
+            break;
+        default:
+            break;
+    }
+    return false;
 }
 
-static bool checkMacro(af_Message *msg, af_Environment *env) {
-    if (env->activity->fi == NULL || !env->activity->fi->is_macro)  // 非宏函数
-        return false;
+/*
+ * 函数名: checkNormalEnd
+ * 目标: 检查act_normal是否运行到结尾 (若运行到结尾则返回true, 否则返回false)
+ */
+bool checkNormalEnd(af_Message *msg, af_Environment *env) {
+    if (env->activity->bt_next == NULL) {
+        switch (setFuncActivityToNormal(env)) {
+            case -1:  // 已经没有下一步了 (原msg不释放)
+                if (checkMacro(msg, env))  // 检查是否宏函数
+                    break;  // 继续执行
+                checkLiteral(&msg, env);  // 检查是否字面量
+                pushMessageDown(msg, env);
+                return true;
+            case 0:  // 已经没有下一步了 (但原msg释放)
+                gc_delReference(*(af_Object **) (msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
+                freeMessage(msg);
 
-    af_Object *obj = *(af_Object **)(msg->msg);
-    pushMacroFuncActivity(obj, env);
-    gc_delReference(obj);
+                msg = getTopMsg(env);
+                if (checkMacro(msg, env))  // 检查是否宏函数
+                    break;  // 继续执行
+                checkLiteral(&msg, env);  // 检查是否字面量
+                pushMessageDown(msg, env);
+                return true;
+            default:
+            case 1:  // 继续运行
+                gc_delReference(*(af_Object **) (msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
+                freeMessage(msg);
+                break;
+        }
+    } else {
+        if (env->activity->bt_next->type == block && env->activity->bt_next->block.type == parentheses &&
+            env->activity->bt_next->prefix != env->core->prefix[B_EXEC]) {
+            env->activity->parentheses_call = *(af_Object **) (msg->msg);  // 类前缀调用
+        }
+        gc_delReference(*(af_Object **)(msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
+        freeMessage(msg);
+    }
+    return false;
+}
+
+/*
+ * 函数名: checkGetArgEnd
+ * 目标: 检查act_arg是否运行到结尾 (若运行到结尾则返回true, 否则返回false)
+ */
+static bool checkGetArgEnd(af_Message *msg, af_Environment *env) {
+    env->activity->acl_done->result = *(af_Object **)(msg->msg);
     freeMessage(msg);
-    return true;
+    if (env->activity->acl_done->next == NULL) // 参数设定结束
+        return true;
+    env->activity->acl_done = env->activity->acl_done->next;
+    env->activity->bt_next = env->activity->acl_done->code;
+    return false;
+}
+
+/*
+ * 函数名: processMsg
+ * 目标: 处理msg
+ */
+static void processMsg(af_Message *msg, bool run_code, af_Environment *env) {
+    switch (env->activity->status) {
+        case act_normal:
+            if (!run_code)
+                popActivity(makeMessage("ERROR-STR", 0), env);
+            else if (checkNormalEnd(msg, env))
+                popActivity(NULL, env);
+            break;
+        case act_func:
+            if (!run_code)
+                popActivity(makeMessage("ERROR-STR", 0), env);
+            else {
+                af_Object *func = *(af_Object **)(msg->msg);  // func仍保留了msg的gc计数
+                gc_delReference(func);  // 释放计数
+                freeMessage(msg);
+                if (!setFuncActivityToArg(func, env))
+                    popActivity(NULL, env);
+            }
+            break;
+        case act_arg: {
+            if (!run_code || checkGetArgEnd(msg, env)) {  // 无参数设定或参数设定完成
+                if (!setFuncActivityAddVar(env))
+                    popActivity(NULL, env);
+            }
+            break;
+        }
+        default:
+            break;
+    }
 }
 
+/*
+ * 函数名: iterCode
+ * 目标: 运行代码 (代码可通过code参数传入, 或通过env->activity传入)
+ */
 bool iterCode(af_Code *code, af_Environment *env) {
-    env->process_msg_first = false;  // 优先处理msg而不是运行代码
-    if (!addTopActivity(code, env))
+    if (!iterCodeInit(code, env))
         return false;
 
     for (NULL; env->activity != NULL; checkRunGC(env)) {
         af_Message *msg = NULL;
         bool run_code = false;
 
-        if (env->activity->status == act_arg && env->activity->run_in_func && env->activity->func_var_list != NULL)
-            env->activity->vsl = env->activity->func_var_list;
-        else
-            env->activity->vsl = env->activity->var_list;
-
-        if (env->activity->bt_next != NULL || env->process_msg_first) {
-            run_code = true;
-            if (!env->process_msg_first) {
-                switch (env->activity->bt_next->type) {
-                    case literal:
-                        if (codeLiteral(env->activity->bt_next, env))
-                            continue;  // 若运行成功则跳转到下一次运行, 该步骤仅为设置Activity
-                        break;
-                    case variable:
-                        if (codeVariable(env->activity->bt_next, env))
-                            continue;
-                        break;
-                    case block:
-                        if (codeBlock(env->activity->bt_next, env))
-                            continue;  // 若运行成功则跳转到下一次运行, 该步骤仅为设置Activity
-                    default:
-                        break;  // 错误
-                }
-            } else
-                env->process_msg_first = false;
-
-            if (env->activity->msg_down == NULL)  // 若未获得 msg
-                msg = makeMessage("ERROR-STR", 0);
-            else
-                msg = getFirstMessage(env);
-
-            if (!EQ_STR(msg->type, "NORMAL")) {  // 若msg为非正常值
-                pushMessageDown(msg, env);  // msg不弹出
-                if (env->activity->status != act_normal || !checkInMsgType(msg->type, env)) {  // 非normal模式, 或normal模式不匹配该msg
-                    env->activity->return_first = false;
-                    env->activity->return_obj = NULL;
-                    popActivity(NULL, env);  // msg 已经 push进去了
-                    continue;
-                }
-            } else if (env->activity->return_first && env->activity->return_obj == NULL)  // 设置return_first
-                env->activity->return_obj = *(af_Object **)msg->msg;
-        }
-
-        switch (env->activity->status) {
-            case act_normal:
-                if (!run_code)
-                    popActivity(makeMessage("ERROR-STR", 0), env);
-                else if (env->activity->bt_next == NULL) { // 执行完成
-                    switch (setFuncActivityToNormal(env)) {
-                        case -1:  // 已经没有下一步了 (原msg不释放)
-                            if (checkMacro(msg, env))  // 检查是否宏函数
-                                break;  // 继续执行
-                            checkLiteral(&msg, env);  // 检查是否字面量
-                            popActivity(msg, env);
-                            break;
-                        case 0:  // 已经没有下一步了 (但原msg释放)
-                            gc_delReference(*(af_Object **)(msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
-                            freeMessage(msg);
-
-                            if (env->activity->msg_down == NULL)  // 检查是否有msg
-                                msg = makeMessage("ERROR-STR", 0);
-                            else {
-                                msg = getFirstMessage(env);
-                                if (checkMacro(msg, env))  // 检查是否宏函数
-                                    break;  // 继续执行
-                                checkLiteral(&msg, env);  // 检查是否字面量
-                            }
-
-                            popActivity(msg, env);
-                            break;
-                        default:
-                        case 1:  // 继续运行
-                            gc_delReference(*(af_Object **)(msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
-                            freeMessage(msg);
-                            break;
-                    }
-                } else {  // 继续运行
-                    if (env->activity->bt_next->type == block && env->activity->bt_next->block.type == parentheses &&
-                           env->activity->bt_next->prefix != env->core->prefix[B_EXEC])
-                        env->activity->parentheses_call = *(af_Object **)(msg->msg);  // 类前缀调用
-                    gc_delReference(*(af_Object **)(msg->msg));  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
-                    freeMessage(msg);
-                }
-                break;
-            case act_func: {
-                if (!run_code)
-                    popActivity(makeMessage("ERROR-STR", 0), env);
-                else {
-                    af_Object *func = *(af_Object **)(msg->msg);  // func仍保留了msg的gc计数
-                    gc_delReference(func);  // 释放计数
-                    freeMessage(msg);
-                    if (!setFuncActivityToArg(func, env))  // 该函数会设定bt_next到arg计算的bt上
-                        popActivity(NULL, env);  // setFuncActivityToArg中已设置msg
-                }
-                break;
-            }
-            case act_arg: {
-                if (!run_code) {  // 无参数设定
-                    if (!setFuncActivityAddVar(env))
-                        popActivity(NULL, env);
-                } else {
-                    env->activity->acl_done->result = *(af_Object **)(msg->msg);
-                    freeMessage(msg);
-                    if (env->activity->acl_done->next == NULL) { // 参数设定结束
-                        if (!setFuncActivityAddVar(env))
-                            popActivity(NULL, env);
-                    } else {
-                        env->activity->acl_done = env->activity->acl_done->next;
-                        env->activity->bt_next = env->activity->acl_done->code;
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
+        setRunVarSpaceList(env);
+        if (runCode(&msg, &run_code, env))
+            continue;  // 若未获得msg (未进行实质性运算) 则再次运算
 
+        processMsg(msg, run_code, env);
     }
-
     return true;
 }