refactor & style: 函数返回值修改为ResultType

执行函数的返回值统一返回ResultType
执行函数原返回值Result通过参数传入的指针进行赋值
operation部分的函数读取left和right进行了优化
执行函数不再对result进行freeResult的初始化
使用for循环替代了部分的while循环

include/__macro.h

@@ -3,20 +3,22 @@
 #include "macro.h"
 
 // PASS语句的定义
-#define PASS do{}while(0)
+#define PASS
 
 #define NUMBER_TYPE long int
 #define NUMBER_FORMAT "ld"
 #define HASH_INDEX unsigned int
 
 #define INTER_FUNCTIONSIG_CORE struct Inter *inter, struct VarList *var_list
-#define INTER_FUNCTIONSIG Statement *st, INTER_FUNCTIONSIG_CORE
+#define INTER_FUNCTIONSIG struct Result *result, struct Statement *st, INTER_FUNCTIONSIG_CORE
+#define INTER_FUNCTIONSIG_NOT_ST struct Result *result, INTER_FUNCTIONSIG_CORE
+
 #define CALL_INTER_FUNCTIONSIG_CORE(var_list) inter, var_list
-#define CALL_INTER_FUNCTIONSIG(st, var_list) st, CALL_INTER_FUNCTIONSIG_CORE(var_list)
+#define CALL_INTER_FUNCTIONSIG(st, var_list, result) result, st, CALL_INTER_FUNCTIONSIG_CORE(var_list)
+#define CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result) result, CALL_INTER_FUNCTIONSIG_CORE(var_list)
 
-#define run_continue(result) (result.type == not_return || result.type == operation_return)
-#define run_continue_(result) (result->type == not_return || result->type == operation_return)
-#define is_error(result) (result.type == error_return)
+#define run_continue_type(result) (type == not_return || type == operation_return)
+#define run_continue(result) (result->type == not_return || result->type == operation_return)
 
 #define freeBase(element, return_) do{ \
 if (element == NULL){ \

include/parameter.h

@@ -63,17 +63,14 @@ void freeParameter(Parameter *pt, bool free_st);
 Argument *listToArgument(LinkValue *list_value, INTER_FUNCTIONSIG_CORE);
 Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE);
 
-Result setParameterCore(Argument *call, Parameter *function_base, VarList *function_var, struct Statement *base,
-                        struct Inter *inter, struct VarList *var_list);
-Result setParameter(Parameter *call_base, Parameter *function_base, VarList *function_var, struct Statement *base,
-                    struct Inter *inter, struct VarList *var_list);
-Result iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_CORE);
+ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *function_var, struct Statement *base, INTER_FUNCTIONSIG_NOT_ST);
+ResultType setParameter(Parameter *call_base, Parameter *function_base, VarList *function_var, struct Statement *base, INTER_FUNCTIONSIG_NOT_ST);
+ResultType iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_NOT_ST);
 Argument *getArgument(Parameter *call, Result *result, INTER_FUNCTIONSIG_CORE);
 
-Result defaultParameter(Parameter **function_ad, Inter *inter, VarList *var_list, int *num);
-Result
-argumentToVar(Argument **call_ad, struct Inter *inter, struct VarList *var_list, NUMBER_TYPE *num);
-Result parameterFromVar(Parameter **function_ad, VarList *function_var, struct Inter *inter, struct VarList *var_list,
-                        NUMBER_TYPE *num, NUMBER_TYPE max, bool *status);
-Result argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList *function_var, INTER_FUNCTIONSIG_CORE);
+ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST);
+ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST);
+ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMBER_TYPE *num, NUMBER_TYPE max, bool *status,
+                        INTER_FUNCTIONSIG_NOT_ST);
+ResultType argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList *function_var, INTER_FUNCTIONSIG_NOT_ST);
 #endif //VIRTUALMATH_PARAMETER_H

include/run.h

@@ -2,41 +2,49 @@
 #define VIRTUALMATH_RUN_H
 #include "__macro.h"
 
-typedef Result (*VarInfo)(char **name, int *times, INTER_FUNCTIONSIG);
-
-Result globalIterStatement(Inter *inter);
-bool operationSafeInterStatement(Result *result, INTER_FUNCTIONSIG);
-bool ifBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG);
-bool functionSafeInterStatement(Result *result, INTER_FUNCTIONSIG);
-bool cycleBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG);
-bool tryBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG);
-
-Result operationStatement(INTER_FUNCTIONSIG);
-Result setFunction(INTER_FUNCTIONSIG);
-Result callFunction(INTER_FUNCTIONSIG);
-Result getVar(INTER_FUNCTIONSIG, VarInfo var_info);
-Result getBaseValue(INTER_FUNCTIONSIG);
-Result getList(INTER_FUNCTIONSIG);
-Result getDict(INTER_FUNCTIONSIG);
-Result ifBranch(INTER_FUNCTIONSIG);
-Result whileBranch(INTER_FUNCTIONSIG);
-Result tryBranch(INTER_FUNCTIONSIG);
-Result breakCycle(INTER_FUNCTIONSIG);
-Result continueCycle(INTER_FUNCTIONSIG);
-Result regoIf(INTER_FUNCTIONSIG);
-Result restartCode(INTER_FUNCTIONSIG);
-Result returnCode(INTER_FUNCTIONSIG);
-Result raiseCode(INTER_FUNCTIONSIG);
-
-Result includeFile(INTER_FUNCTIONSIG);
-
-Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE);
+typedef struct Result Result;
+typedef enum ResultType ResultType;
+typedef struct LinkValue LinkValue;
+typedef struct Value Value;
+typedef struct Statement Statement;
+typedef struct Inter Inter;
+typedef struct VarList VarList;
+
+typedef ResultType (*VarInfo)(char **name, int *times, INTER_FUNCTIONSIG);
+
+ResultType globalIterStatement(Inter *inter, Result *result);
+bool operationSafeInterStatement(INTER_FUNCTIONSIG);
+bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG);
+bool functionSafeInterStatement(INTER_FUNCTIONSIG);
+bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG);
+bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG);
+
+ResultType operationStatement(INTER_FUNCTIONSIG);
+ResultType setFunction(INTER_FUNCTIONSIG);
+ResultType callFunction(INTER_FUNCTIONSIG);
+ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info);
+ResultType getBaseValue(INTER_FUNCTIONSIG);
+ResultType getList(INTER_FUNCTIONSIG);
+ResultType getDict(INTER_FUNCTIONSIG);
+ResultType ifBranch(INTER_FUNCTIONSIG);
+ResultType whileBranch(INTER_FUNCTIONSIG);
+ResultType tryBranch(INTER_FUNCTIONSIG);
+ResultType breakCycle(INTER_FUNCTIONSIG);
+ResultType continueCycle(INTER_FUNCTIONSIG);
+ResultType regoIf(INTER_FUNCTIONSIG);
+ResultType restartCode(INTER_FUNCTIONSIG);
+ResultType returnCode(INTER_FUNCTIONSIG);
+ResultType raiseCode(INTER_FUNCTIONSIG);
+
+ResultType includeFile(INTER_FUNCTIONSIG);
+
+ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST);
 
 char *setStrVarName(char *old, bool free_old, INTER_FUNCTIONSIG_CORE);
 char *setNumVarName(NUMBER_TYPE num, INTER_FUNCTIONSIG_CORE);
 char *getNameFromValue(Value *value, INTER_FUNCTIONSIG_CORE);
-Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
-Result getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
-Result getVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
+ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
+ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
+ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
 
 #endif //VIRTUALMATH_RUN_H

include/value.h

@@ -81,6 +81,7 @@ typedef struct Value Value;
 typedef struct LinkValue LinkValue;
 typedef struct Result Result;
 typedef struct Error Error;
+typedef enum ResultType ResultType;
 
 Value *makeValue(Inter *inter);
 Value * freeValue(Value *value, Inter *inter);
@@ -100,6 +101,7 @@ void setResultOperationNone(Result *ru, Inter *inter);
 void setResultOperation(Result *ru, LinkValue *value, Inter *inter);
 void setResultOperationBase(Result *ru, LinkValue *value, Inter *inter);
 void freeResult(Result *ru);
+void freeResultSave(Result *ru);
 
 Error *makeError(char *type, char *message, long int line, char *file);
 void freeError(Result *base);

parser/__grammar.c

@@ -223,8 +223,11 @@ bool callChildToken(PASERSSIGNATURE, PasersFunction callBack, int type, Token **
     if (!call_success(pm))
         return false;
     if (readBackToken(pm) != type) {
-        if (message != NULL)
-            syntaxError(pm, error_type, (*tmp)->line, 1, message);
+        if (message != NULL) {
+            *tmp = popAheadToken(pm);
+            syntaxError(pm, error_type, (*tmp)->line, 1, message);  // TODO-szh 设置tmp
+            backToken_(pm ,(*tmp));
+        }
         return false;
     }
     *tmp = popAheadToken(pm);

parser/grammar.c

@@ -83,9 +83,9 @@ void parserCommandList(PASERSSIGNATURE, bool global, Statement *st) {
                 delToken(pm);
             else  if(stop != MATHER_EOF){
                 if (global) {
-                    freeToken(command_token, true, true);
                     printf("stop = %d\n", stop);
                     syntaxError(pm, command_list_error, command_token->line, 1, "ERROR from parserCommand list(get stop)");
+                    freeToken(command_token, true, true);
                 }
                 else{
                     connectStatement(st, command_token->data.st);
@@ -172,6 +172,7 @@ void parserCommand(PASERSSIGNATURE){
         case MATHER_STRING:
         case MATHER_NUMBER:
         case MATHER_VAR:
+        case MATHER_SVAR:
         case MATHER_LC:
         case MATHER_LB:
         case MATHER_LP:

src/__run.c

@@ -1,11 +1,7 @@
 #include "__run.h"
 
-Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
-    Result result;
-    Result times_tmp;
+ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     LinkValue *value;
-    setResultCore(&result);
-    setResultCore(&times_tmp);
 
     *name = setStrVarName(st->u.base_var.name, false, inter, var_list);
     *times = 0;
@@ -13,68 +9,60 @@ Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
         *times = 0;
         goto not_times;
     }
-    if (operationSafeInterStatement(&times_tmp, CALL_INTER_FUNCTIONSIG(st->u.base_var.times, var_list)))
-        return times_tmp;
-    if (!isType(times_tmp.value->value, number)){
-        freeResult(&times_tmp);
-        setResultError(&result, inter, "TypeException", "Don't get a number value", st, true);
-        goto return_;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_var.times, var_list, result)))
+        return result->type;
+    if (!isType(result->value->value, number)){
+        setResultError(result, inter, "TypeException", "Don't get a number value", st, true);
+        return result->type;
     }
-    *times = (int)times_tmp.value->value->data.num.num;
-    freeResult(&times_tmp);
+    *times = (int)result->value->value->data.num.num;
+    freeResult(result);
 
     not_times:
     value = makeLinkValue(makeStringValue(st->u.base_var.name, inter), NULL, inter);
-    setResultOperation(&result, value, inter);
+    setResultOperation(result, value, inter);
 
-    return_:
-    freeResult(&times_tmp);
-    return result;
+    return result->type;
 }
 
-Result getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
-    Result result;
-    Result times_tmp;
-    setResultCore(&result);
-    setResultCore(&times_tmp);
-
-    if (operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list)))
-        return result;
-    *name = getNameFromValue(result.value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
+    freeResult(result);
 
     if (st->u.base_svar.times == NULL){
         *times = 0;
         goto not_times;
     }
-    if (operationSafeInterStatement(&times_tmp, CALL_INTER_FUNCTIONSIG(st->u.base_svar.times, var_list)))
-        return times_tmp;
-    if (!isType(times_tmp.value->value, number)){
-        freeResult(&times_tmp);
-        setResultError(&result, inter, "TypeException", "Don't get a number value", st, true);
-        return result;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.times, var_list, result)))
+        return result->type;
+    if (!isType(result->value->value, number)){
+        setResultError(result, inter, "TypeException", "Don't get a number value", st, true);
+        return result->type;
     }
-    *times = (int)times_tmp.value->value->data.num.num;
+    *times = (int)result->value->value->data.num.num;
 
+    freeResult(result);
     not_times:
-    result.type = operation_return;  // 执行 operationSafeInterStatement 的时候已经初始化 result
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list, result)))
+        return result->type;
+
+    *name = getNameFromValue(result->value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    result->type = operation_return;  // 执行 operationSafeInterStatement 的时候已经初始化 result
 
-    return result;
+    return result->type;
 }
 
-Result getVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
-    Result result;
-    setResultCore(&result);
+ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     if (st->type == base_var)
-        result = getBaseVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list));
+        getBaseVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
     else if (st->type == base_svar)
-        result = getBaseSVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list));
+        getBaseSVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
     else{
-        if (operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(st, var_list)))
-            return result;
-        *name = getNameFromValue(result.value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+            return result->type;
+        *name = getNameFromValue(result->value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
         *times = 0;
     }
-    return result;
+    return result->type;
 }
 
 char *setStrVarName(char *old, bool free_old, INTER_FUNCTIONSIG_CORE) {

src/inter.c

@@ -9,6 +9,7 @@ Inter *runBaseInter(char *code_file, char *debug_dir, int *status) {
 Inter *newInter(char *code_file, char *debug_dir, Result *global_result, int *status) {
     Inter *global_inter = NULL;
     ParserMessage *pm = NULL;
+    ResultType type;
     *status = 0;
 
     if (checkFile(code_file) != 1){
@@ -28,8 +29,8 @@ Inter *newInter(char *code_file, char *debug_dir, Result *global_result, int *st
         goto return_;
     }
 
-    *global_result = globalIterStatement(global_inter);
-    if (global_result->type == error_return)
+    type = globalIterStatement(global_inter, global_result);
+    if (type == error_return)
         printError(global_result, global_inter, true);
 
     return_:

src/parameter.c

@@ -21,7 +21,6 @@ Argument *makeValueArgument(LinkValue *value){
     Argument *tmp = makeArgument();
     tmp->data.value = value;
     gcAddTmp(&value->gc_status);
-
     return tmp;
 }
 
@@ -47,11 +46,11 @@ Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *na
 }
 
 Argument *connectArgument(Argument *new, Argument *base){
+    Argument *tmp = base;
     if (base == NULL)
         return new;
-    Argument *tmp = base;
-    while (base->next != NULL)
-        base = base->next;
+    for (PASS; base->next != NULL; base = base->next)
+        PASS;
     base->next = new;
     return tmp;
 }
@@ -72,7 +71,8 @@ Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, char
 }
 
 void freeArgument(Argument *at, bool free_st) {
-    while (at != NULL){
+    for (Argument *tmp=NULL; at != NULL;at = tmp){
+        tmp = at->next;
         if (free_st)
             freeStatement(at->data.name);
         memFree(at->data.name_);
@@ -82,9 +82,7 @@ void freeArgument(Argument *at, bool free_st) {
         if (at->data.value != NULL)
             gcFreeTmpLink(&at->data.value->gc_status);
 
-        Argument *tmp = at->next;
         memFree(at);
-        at = tmp;
     }
 }
 
@@ -97,26 +95,26 @@ Parameter *makeParameter(void){
     return tmp;
 }
 
+Parameter *copyenOneParameter(Parameter *base){
+    Parameter *tmp = makeParameter();
+    tmp->data.value = copyStatement(base->data.value);
+    tmp->data.name = copyStatement(base->data.name);
+    tmp->type = base->type;
+    return tmp;
+}
+
 Parameter *copyParameter(Parameter *base){
+    Parameter *tmp = NULL;
+    Parameter *base_tmp = NULL;
+
     if (base == NULL)
         return NULL;
 
-    Parameter *tmp = NULL;
-    Parameter *base_tmp = NULL;
-    tmp = makeParameter();
+    tmp = copyenOneParameter(base);
     base_tmp = tmp;
+    for (; base->next != NULL; tmp = tmp->next,base = base->next)
+        tmp->next = copyenOneParameter(base->next);
 
-    tmp->data.value = copyStatement(base->data.value);
-    tmp->data.name = copyStatement(base->data.name);
-    tmp->type = base->type;
-    while (base->next != NULL){
-        tmp->next = makeParameter();
-        tmp = tmp->next;
-        base = base->next;
-        tmp->data.value = copyStatement(base->data.value);
-        tmp->data.name = copyStatement(base->data.name);
-        tmp->type = base->type;
-    }
     return base_tmp;
 }
 
@@ -179,14 +177,13 @@ Parameter *connectKwargsParameter(Statement *st, Parameter *base){
 }
 
 void freeParameter(Parameter *pt, bool free_st) {
-    while (pt != NULL){
+    for (Parameter *tmp=NULL;pt != NULL;pt = tmp){
+        tmp = pt->next;
         if (free_st) {
             freeStatement(pt->data.value);
             freeStatement(pt->data.name);
         }
-        Parameter *tmp = pt->next;
         memFree(pt);
-        pt = tmp;
     }
 }
 
@@ -199,13 +196,10 @@ Argument *listToArgument(LinkValue *list_value, INTER_FUNCTIONSIG_CORE){
 
 Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE){
     Argument *at = NULL;
-    for (int i = 0; i < MAX_SIZE; i++) {
-        Var *tmp = dict_value->value->data.dict.dict->hashtable[i];
-        while (tmp != NULL) {
+    Var *tmp = NULL;
+    for (int i = 0; i < MAX_SIZE; i++)
+        for (tmp = dict_value->value->data.dict.dict->hashtable[i]; tmp != NULL; tmp = tmp->next)
             at = connectCharNameArgument(tmp->value, tmp->name_, tmp->name, at);
-            tmp = tmp->next;
-        }
-    }
     return at;
 }
 
@@ -218,31 +212,26 @@ Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE){
  * @param num
  * @return
  */
-Result defaultParameter(Parameter **function_ad, Inter *inter, VarList *var_list, int *num) {
+ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST) {
     Parameter *function = *function_ad;
-    Result result;
-    setResultCore(&result);
+    setResultCore(result);
 
-    *num = 0;
-    while (function != NULL && function->type == name_par){
+    for (*num = 0; function != NULL && function->type == name_par; (*num)++, function = function->next){
         LinkValue *value = NULL;
-        if(operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(function->data.value, var_list)))
+        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result)))
             goto return_;
 
-        value = result.value;
-        freeResult(&result);
-        result = assCore(function->data.name, value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        value = result->value;
+        freeResult(result);
+        assCore(function->data.name, value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
         if (!run_continue(result))
             goto return_;
-
-        (*num)++;
-        function = function->next;
     }
-    setResult(&result, inter);
+    setResult(result, inter);
 
     return_:
     *function_ad = function;
-    return result;
+    return result->type;
 }
 
 /**
@@ -253,31 +242,25 @@ Result defaultParameter(Parameter **function_ad, Inter *inter, VarList *var_list
  * @param num
  * @return
  */
-Result argumentToVar(Argument **call_ad, struct Inter *inter, struct VarList *var_list, NUMBER_TYPE *num) {
+ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST) {
     Argument *call = *call_ad;
-    Result result;
-    setResultCore(&result);
+    setResultCore(result);
 
-    *num = 0;
-    while (call != NULL && call->type == name_arg){
+    for (*num = 0; call != NULL && call->type == name_arg; (*num)++, call = call->next){
         if (call->name_type == name_char){
             addFromVarList(call->data.name_, var_list, 0, call->data.value, call->data.name_value);
-            goto next;
+            continue;
         }
-        freeResult(&result);
-        result = assCore(call->data.name, call->data.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        freeResult(result);
+        assCore(call->data.name, call->data.value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
         if (!run_continue(result))
             goto return_;
-
-        next:
-        (*num)++;
-        call = call->next;
     }
-    setResult(&result, inter);
+    setResult(result, inter);
 
     return_:
     *call_ad = call;
-    return result;
+    return result->type;
 }
 
 /**
@@ -289,21 +272,17 @@ Result argumentToVar(Argument **call_ad, struct Inter *inter, struct VarList *va
  * @param num
  * @return
  */
-Result parameterFromVar(Parameter **function_ad, VarList *function_var, struct Inter *inter, struct VarList *var_list,
-                        NUMBER_TYPE *num, NUMBER_TYPE max, bool *status) {
+ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMBER_TYPE *num, NUMBER_TYPE max, bool *status,
+                        INTER_FUNCTIONSIG_NOT_ST) {
     Parameter *function = *function_ad;
-    Result result;
-    setResultCore(&result);
+    bool get = true;
+    setResultCore(result);
 
-    bool get;
-    *num = 0;
-    *status = false;
-    while (function != NULL){
+    for (*num = 0, *status = false; function != NULL; function = function->next){
         int int_times;
         char *str_name = NULL;
         Statement *name = function->type == name_par ? function->data.name : function->data.value;
         LinkValue *value = NULL;
-
         get = true;
 
         if (function->type == kwargs_par){
@@ -314,45 +293,47 @@ Result parameterFromVar(Parameter **function_ad, VarList *function_var, struct I
             goto not_return;
         }
 
-        freeResult(&result);
-        result = getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list));
+        freeResult(result);
+        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result));
         if (!run_continue(result)) {
             memFree(str_name);
-            return result;
+            *function_ad = function;
+            return result->type;
         }
-        freeResult(&result);
+
+        freeResult(result);
         value = findFromVarList(str_name, var_list, int_times, true);
         memFree(str_name);
 
         if(value == NULL) {
             get = false;
-            if (function->type == name_par && !operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(function->data.value, var_list))) {
-                value = result.value;
+            if (function->type == name_par && !operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result))) {
+                value = result->value;
                 goto not_return;
             }
-            setResultError(&result, inter, "ArgumentException", "Too less Argument", name, true);
+            setResultError(result, inter, "ArgumentException", "Too less Argument", name, true);
             *function_ad = function;
-            return result;
+            return result->type;
         }
 
         not_return:
-        freeResult(&result);
-        result = assCore(name, value, CALL_INTER_FUNCTIONSIG_CORE(function_var));
+        freeResult(result);
+        assCore(name, value, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+
         if (!run_continue(result)) {
             *function_ad = function;
-            return result;
+            return result->type;
         }
         else
-            freeResult(&result);
+            freeResult(result);
 
         if (get)
             (*num)++;
-        function = function->next;
     }
 
-    setResult(&result, inter);
+    setResult(result, inter);
     *function_ad = function;
-    return result;
+    return result->type;
 }
 
 /**
@@ -364,28 +345,24 @@ Result parameterFromVar(Parameter **function_ad, VarList *function_var, struct I
  * @param var_list
  * @return
  */
-Result argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList *function_var, INTER_FUNCTIONSIG_CORE){
+ResultType argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList *function_var, INTER_FUNCTIONSIG_NOT_ST){
     Argument *call = *call_ad;
     Parameter *function = *function_ad;
-    Result result;
-    setResultCore(&result);
+    setResultCore(result);
 
-    while (call != NULL && function != NULL && (call->type == value_arg) && function->type != args_par){
+    for (PASS; call != NULL && function != NULL && (call->type == value_arg) && function->type != args_par; call = call->next, function = function->next){
         Statement *name = function->type == value_par ? function->data.value : function->data.name;
-        result = assCore(name, call->data.value, CALL_INTER_FUNCTIONSIG_CORE(function_var));
+        assCore(name, call->data.value, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
         if (!run_continue(result))
             goto return_;
-
-        freeResult(&result);
-        call = call->next;
-        function = function->next;
+        freeResult(result);
     }
 
-    setResult(&result, inter);
+    setResult(result, inter);
     return_:
     *call_ad = call;
     *function_ad = function;
-    return result;
+    return result->type;
 }
 
 /**
@@ -395,41 +372,40 @@ Result argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList
  * @param var_list
  * @return
  */
-Result iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_CORE){
+ResultType iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_NOT_ST){
     Argument *base = *base_ad;
-    Result result;
-    setResultCore(&result);
+    setResultCore(result);
 
-    while (call != NULL){
-        if(operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(call->data.value, var_list)))
+    for (PASS; call != NULL; call = call->next){
+        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(call->data.value, var_list, result)))
             goto return_;
 
         if (call->type == value_par)
-            base = connectValueArgument(result.value, base);
+            base = connectValueArgument(result->value, base);
         else if (call->type == name_par)
-            base = connectStatementNameArgument(result.value, call->data.name, base);
+            base = connectStatementNameArgument(result->value, call->data.name, base);
         else if (call->type == args_par){
-            Argument *tmp_at = listToArgument(result.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+            Argument *tmp_at = listToArgument(result->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
             base = connectArgument(tmp_at, base);
         }
         else if (call->type == kwargs_par){
-            Argument *tmp_at = dictToArgument(result.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+            Argument *tmp_at = dictToArgument(result->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
             base = connectArgument(tmp_at, base);
         }
-        freeResult(&result);
-        call = call->next;
+        freeResult(result);
     }
-    setResult(&result, inter);
+    setResult(result, inter);
 
     return_:
     *base_ad = base;
-    return result;
+    return result->type;
 }
 
 Argument *getArgument(Parameter *call, Result *result, INTER_FUNCTIONSIG_CORE){
     Argument *new_arg = NULL;
     freeResult(result);
-    *result = iterParameter(call, &new_arg, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+
+    iterParameter(call, &new_arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
     return new_arg;
 }
 
@@ -449,27 +425,26 @@ Argument *getArgument(Parameter *call, Result *result, INTER_FUNCTIONSIG_CORE){
  * @param var_list
  * @return
  */
-Result setParameter(Parameter *call_base, Parameter *function_base, VarList *function_var, Statement *base,
-                    struct Inter *inter, struct VarList *var_list) {
-    Argument *call;
-    Result result;
-    setResultCore(&result);
-    call = getArgument(call_base, &result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+ResultType setParameter(Parameter *call_base, Parameter *function_base, VarList *function_var, Statement *base,
+                    INTER_FUNCTIONSIG_NOT_ST) {
+    Argument *call = NULL;
+    setResultCore(result);
+    call = getArgument(call_base, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     if (!run_continue(result)) {
         freeArgument(call, false);
-        return result;
+        return result->type;
     }
-    freeResult(&result);
-    result = setParameterCore(call, function_base, function_var, base, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+
+    freeResult(result);
+    setParameterCore(call, function_base, function_var, base, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
     freeArgument(call, false);
-    return result;
+    return result->type;
 }
 
-Result setParameterCore(Argument *call, Parameter *function_base, VarList *function_var, Statement *base,
-                        struct Inter *inter, struct VarList *var_list) {
-    Parameter *function = NULL, *tmp_function = NULL;  // 释放使用
-    Result result;
-    setResultCore(&result);
+ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *function_var, Statement *base,
+                        INTER_FUNCTIONSIG_NOT_ST) {
+    Parameter *function = NULL;
+    Parameter *tmp_function = NULL;  // 释放使用
     enum {
         match_status = 1,
         default_status = 2,
@@ -481,6 +456,7 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
     } status = match_status;
     function = copyParameter(function_base);
     tmp_function = function;
+    setResultCore(result);
 
     while (true){
         if (call == NULL && function == NULL)
@@ -499,33 +475,34 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
         else if (call->type == name_arg)
             status = self_ass;
 
-        freeResult(&result);
+        freeResult(result);
         switch (status) {
             case match_status: {
-                result = argumentToParameter(&call, &function, function_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+                argumentToParameter(&call, &function, function_var, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
                 returnResult(result);
                 break;
             }
             case default_status: {
-                int num = 0;
-                result = defaultParameter(&function, CALL_INTER_FUNCTIONSIG_CORE(function_var), &num);
+                NUMBER_TYPE num = 0;
+                defaultParameter(&function, &num, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
                 returnResult(result);
                 break;
             }
             case self_ass: {
-                VarList *tmp = pushVarList(var_list, inter);
-                NUMBER_TYPE set_num = 0, get_num = 0;
+                NUMBER_TYPE set_num = 0;
+                NUMBER_TYPE get_num = 0;
                 bool dict_status = false;
-                result = argumentToVar(&call, CALL_INTER_FUNCTIONSIG_CORE(tmp), &set_num);
+                VarList *tmp = pushVarList(var_list, inter);
+
+                argumentToVar(&call, &set_num, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result));
                 returnResult(result);
                 if (!run_continue(result)) {
-                    freeVarList(tmp, true);
+                    popVarList(tmp);
                     goto return_;
                 }
 
-                freeResult(&result);
-                result = parameterFromVar(&function, function_var, CALL_INTER_FUNCTIONSIG_CORE(tmp), &get_num, set_num,
-                                          &dict_status);
+                freeResult(result);
+                parameterFromVar(&function, function_var, &get_num, set_num, &dict_status, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result));
                 if (!run_continue(result)) {
                     popVarList(tmp);
                     goto return_;
@@ -533,7 +510,7 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
                 popVarList(tmp);
 
                 if (!dict_status && set_num > get_num) {
-                    freeResult(&result);
+                    freeResult(result);
                     goto error_;
                 }
                 break;
@@ -543,16 +520,16 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
                 if (!run_continue(result))
                     goto return_;
                 else
-                    freeResult(&result);
-                result = assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_CORE(function_var));
+                    freeResult(result);
+
+                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
                 returnResult(result);
                 function = function->next;
                 break;
             }
             case space_kwargs:{
-                LinkValue *tmp = makeLinkValue(makeDictValue(NULL, true, &result, inter, var_list), NULL, inter);
-
-                result = assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_CORE(function_var));
+                LinkValue *tmp = makeLinkValue(makeDictValue(NULL, true, result, inter, var_list), NULL, inter);
+                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
                 returnResult(result);
                 function = function->next;
                 break;
@@ -560,16 +537,16 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
             case error:
             error_:  // Statement 处理
                 writeLog(inter->data.debug, ERROR, "setParameter error\n", NULL);
-                setResultError(&result, inter, "ArgumentException", "Set Argument error", 0, true);
+                setResultError(result, inter, "ArgumentException", "Set Argument error", 0, true);
                 goto return_;
             default:
                 goto break_;
         }
     }
     break_:
-    setResult(&result, inter);
+    setResult(result, inter);
 
     return_:
     freeParameter(tmp_function, true);
-    return result;
+    return result->type;
 }

src/run.c

@@ -7,73 +7,73 @@
  * @param var_list
  * @return
  */
-Result runStatement(INTER_FUNCTIONSIG) {
-    Result result;
-    setResultCore(&result);
+ResultType runStatement(INTER_FUNCTIONSIG) {
+    setResultCore(result);
+    ResultType type = not_return;
     switch (st->type) {
         case base_value:
-            result = getBaseValue(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = getBaseValue(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case base_var:
-            result = getVar(CALL_INTER_FUNCTIONSIG(st, var_list), getBaseVarInfo);
+            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result), getBaseVarInfo);
             break;
         case base_svar:
-            result = getVar(CALL_INTER_FUNCTIONSIG(st, var_list), getBaseSVarInfo);
+            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result), getBaseSVarInfo);
             break;
         case base_list:
-            result = getList(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = getList(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case base_dict:
-            result = getDict(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = getDict(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case operation:
-            result = operationStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-            if (run_continue(result))
-                printLinkValue(result.value, "operation result = ", "\n", inter->data.debug);
+            type = operationStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            if (run_continue_type(type))
+                printLinkValue(result->value, "operation result = ", "\n", inter->data.debug);
             break;
         case set_function:
-            result = setFunction(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = setFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case call_function:
-            result = callFunction(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = callFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case if_branch:
-            result = ifBranch(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = ifBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case while_branch:
-            result = whileBranch(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = whileBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case try_branch:
-            result = tryBranch(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = tryBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case break_cycle:
-            result = breakCycle(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = breakCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case continue_cycle:
-            result = continueCycle(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = continueCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case rego_if:
-            result = regoIf(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = regoIf(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case restart:
-            result = restartCode(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = restartCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case return_code:
-            result = returnCode(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = returnCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case raise_code:
-            result = raiseCode(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = raiseCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case include_file:
-            result = includeFile(CALL_INTER_FUNCTIONSIG(st, var_list));
+            type = includeFile(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         default:
-            setResult(&result, inter);
+            setResult(result, inter);
             break;
     }
 
     runGC(inter, 1, 0, 0, var_list);
-    return result;
+    return type;
 }
 
 /**
@@ -83,33 +83,30 @@ Result runStatement(INTER_FUNCTIONSIG) {
  * @param var_list
  * @return
  */
-Result iterStatement(INTER_FUNCTIONSIG) {
-    Result result;
-    setResultCore(&result);
+ResultType iterStatement(INTER_FUNCTIONSIG) {
+    Statement *base_st = NULL;
+    ResultType type;
+    setResultCore(result);
+
     if (st == NULL){
-        setResult(&result, inter);
-        return result;
+        setResult(result, inter);
+        return result->type;
     }
-    Statement *base_st = NULL;
 
-    while (true) {
-        base_st = st;
-        while (base_st != NULL) {
-            freeResult(&result);
-            result = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list));
-            if (!run_continue(result))
-                goto return_;
-            base_st = base_st->next;
+    do {
+        for (base_st = st; base_st != NULL; base_st = base_st->next) {
+            freeResult(result);
+            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result));
+            if (!run_continue_type(type))
+                break;
         }
+    } while (type == restart_return && result->times == 0);
 
-        if (result.type != restart_return || result.times > 0)
-            break;
-    }
-    if (result.type == not_return)
-        setResultOperationNone(&result, inter);
+    if (type == not_return || type == restart_return)
+        setResultOperationNone(result, inter);
 
     runGC(inter, 1, 0, 0, var_list);
-    return_: return result;
+    return result->type;
 }
 
 /**
@@ -117,91 +114,87 @@ Result iterStatement(INTER_FUNCTIONSIG) {
  * @param inter
  * @return
  */
-Result globalIterStatement(Inter *inter) {
+ResultType globalIterStatement(Inter *inter, Result *result) {
     Statement *base_st = NULL;
     VarList *var_list = NULL;
-    Result result;
-    setResultCore(&result);
-
-    while (true) {
-        base_st = inter->statement;
-        var_list = inter->var_list;
-        while (base_st != NULL) {
-            freeResult(&result);
-            result = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list));
-            if (!run_continue(result))
+    enum ResultType type;
+
+    do {
+        for (base_st = inter->statement, var_list = inter->var_list; base_st != NULL; base_st = base_st->next) {
+            freeResult(result);
+            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result));
+            if (!run_continue_type(type))
                 break;
-            base_st = base_st->next;
         }
-        if (result.type != restart_return || result.times > 0)
-            break;
-    }
+    } while (type == restart_return && result->times == 0);
 
-    if (result.type != error_return && result.type != function_return)
-        setResultOperationNone(&result, inter);
+    if (type != error_return && type != function_return)
+        setResultOperationNone(result, inter);
 
     runGC(inter, 1, 0, 0, var_list);
-    return result;
+    return result->type;
 }
 
 // 若需要中断执行, 则返回true
-bool operationSafeInterStatement(Result *result, INTER_FUNCTIONSIG){
-    freeResult(result);
-    *result = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (run_continue_(result))
+bool operationSafeInterStatement(INTER_FUNCTIONSIG){
+    ResultType type;
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (run_continue_type(type))
         return false;
     return true;
 }
 
-bool ifBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG){
-    freeResult(result);
-    *result = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (run_continue_(result)){
+bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG){
+    ResultType type;
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (run_continue_type(type)){
         return false;
     }
-    if (result->type == rego_return){
+    if (type == rego_return){
         result->times--;
         if (result->times < 0)
             return false;
     }
-    if (result->type == restart_return)
+    if (type == restart_return) {
+        printf("TAG A\n");
         result->times--;
+    }
     return true;
 }
 
-bool cycleBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG){
-    freeResult(result);
-    *result = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (run_continue_(result)){
+bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG){
+    ResultType type;
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (run_continue_type(type)){
         return false;
     }
-    if (result->type == break_return || result->type == continue_return){
+    if (type == break_return || type == continue_return){
         result->times--;
         if (result->times < 0)
             return false;
     }
-    if (result->type == restart_return)
+    if (type == restart_return)
         result->times--;
     return true;
 }
 
-bool tryBranchSafeInterStatement(Result *result, INTER_FUNCTIONSIG){
-    freeResult(result);
-    *result = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (run_continue_(result)){
+bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG){
+    ResultType type;
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (run_continue_type(type)){
         return false;
     }
-    if (result->type == restart_return)
+    if (type == restart_return)
         result->times--;
     return true;
 }
 
-bool functionSafeInterStatement(Result *result, INTER_FUNCTIONSIG){
-    freeResult(result);
-    *result = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (result->type == error_return)
+bool functionSafeInterStatement(INTER_FUNCTIONSIG){
+    ResultType type;
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (type == error_return)
         return true;
-    else if (result->type == function_return){
+    else if (type == function_return){
         result->type = operation_return;
         return true;
     }

src/runbranch.c

@@ -1,10 +1,10 @@
 #include "__run.h"
 
+// TODO-szh 重新命名
 #define checkNumber(new_result) do{ \
-if (!isType(new_result.value->value, number)){ \
-freeResult(&new_result); \
-setResultError(&result, inter, "TypeException", "Don't get a number value", st, true); \
-return result; \
+if (!isType(new_result->value->value, number)){ \
+setResultError(result, inter, "TypeException", "Don't get a number value", st, true); \
+return result->type; \
 }}while(0) /*该Macro只适用于控制分支*/
 
 bool checkBool(Value *value){
@@ -20,400 +20,339 @@ bool checkBool(Value *value){
     }
 }
 
-Result ifBranch(INTER_FUNCTIONSIG) {
+ResultType ifBranch(INTER_FUNCTIONSIG) {
     StatementList *if_list = st->u.if_branch.if_list;
+    Statement *else_st = st->u.if_branch.else_list;
+    Statement *finally = st->u.if_branch.finally;
     bool set_result = true;
     bool is_rego = false;
 
-    Result result;
-    Result else_tmp;
     Result finally_tmp;
-    setResultCore(&result);
-    setResultCore(&else_tmp);
+    setResultCore(result);
     setResultCore(&finally_tmp);
 
     var_list = pushVarList(var_list, inter);
-    while (if_list != NULL){
+    for (; if_list != NULL; if_list = if_list->next){
+        freeResult(result);
         if (if_list->type == if_b){
-            Result condition_tmp;
-            Result var_tmp;
-            setResultCore(&condition_tmp);
-            setResultCore(&var_tmp);
-
-            if (operationSafeInterStatement(&condition_tmp, CALL_INTER_FUNCTIONSIG(if_list->condition, var_list))){
-                result = condition_tmp;
+            LinkValue *condition_value = NULL;
+            if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->condition, var_list, result))){
                 set_result = false;
                 goto not_else;
             }
 
+            condition_value = result->value;
+            freeResult(result);
             if (if_list->var != NULL) {
-                freeResult(&var_tmp);
-                var_tmp = assCore(if_list->var, condition_tmp.value, inter, var_list);
-                if (!run_continue(var_tmp)){
-                    freeResult(&condition_tmp);
-                    result = var_tmp;
+                assCore(if_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+                if (!run_continue(result)){
                     set_result = false;
                     goto not_else;
                 }
-                freeResult(&var_tmp);  // 赋值的返回值被丢弃
+                freeResult(result);
             }
 
-            bool condition = is_rego ? true : checkBool(condition_tmp.value->value);  // 若是rego则不执行checkbool的判断了
-            freeResult(&condition_tmp);
+            bool condition = is_rego ? true : checkBool(condition_value->value);  // 若是rego则不执行checkbool的判断了
             if (condition){
-                Result code_tmp;
-                setResultCore(&code_tmp);
-
                 is_rego = false;
-                if (ifBranchSafeInterStatement(&code_tmp, CALL_INTER_FUNCTIONSIG(if_list->code, var_list))){
-                    result = code_tmp;
+                if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result))){
                     set_result = false;
                     goto not_else;
                 }
-                if (code_tmp.type == rego_return)
+                if (result->type == rego_return)
                     is_rego = true;
                 else {
-                    freeResult(&code_tmp);
+                    freeResult(result);
                     goto not_else;
                 }
-
-                freeResult(&code_tmp);
+                freeResult(result);
             }
         }
         else{
-            Result code_tmp;
-            setResultCore(&code_tmp);
-            if (ifBranchSafeInterStatement(&code_tmp, CALL_INTER_FUNCTIONSIG(if_list->code, var_list))){
-                result = code_tmp;
+            if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result))){
                 set_result = false;
                 goto not_else;
             }
-            if (code_tmp.type == rego_return)
+            if (result->type == rego_return)
                 is_rego = true;
-            freeResult(&code_tmp);
+            freeResult(result);
         }
-        if_list = if_list->next;
     }
-    if (st->u.if_branch.else_list != NULL && ifBranchSafeInterStatement(&else_tmp, CALL_INTER_FUNCTIONSIG(st->u.if_branch.else_list, var_list))){
+    if (else_st != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
         set_result = false;
-        result = else_tmp;
-    }
     else
-        freeResult(&else_tmp);
+        freeResult(result);
 
     not_else:
-    if (st->u.if_branch.finally != NULL && ifBranchSafeInterStatement(&finally_tmp, CALL_INTER_FUNCTIONSIG(st->u.if_branch.finally, var_list))){
+    if (finally != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
         if (!set_result)
-            freeResult(&result);
+            freeResult(result);
         set_result = false;
-        result = finally_tmp;
+        *result = finally_tmp;
     }
     else
         freeResult(&finally_tmp);
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(&result, inter);
-    return result;
+        setResult(result, inter);
+    return result->type;
 }
 
-Result whileBranch(INTER_FUNCTIONSIG) {
+ResultType whileBranch(INTER_FUNCTIONSIG) {
     StatementList *while_list = st->u.while_branch.while_list;
+    Statement *after = st->u.while_branch.after;
+    Statement *else_st = st->u.while_branch.else_list;
+    Statement *finally = st->u.while_branch.finally;
     bool set_result = true;
     bool is_break = false;
-    Result result;
-    Result else_tmp;
+
     Result finally_tmp;
-    setResultCore(&result);
-    setResultCore(&else_tmp);
+    setResultCore(result);
     setResultCore(&finally_tmp);
 
     var_list = pushVarList(var_list, inter);
     while (!is_break){
-        Result tmp;
-        Result var_tmp;
-        Result do_tmp;
-        setResultCore(&tmp);
-        setResultCore(&var_tmp);
-        setResultCore(&do_tmp);
-
-        if (operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(while_list->condition, var_list))){
-            result = tmp;
+        LinkValue *condition_value = NULL;
+
+        freeResult(result);
+        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->condition, var_list, result))){
             set_result = false;
             goto not_else;
         }
+
+        condition_value = result->value;
+        freeResult(result);
         if (while_list->var != NULL){
-            freeResult(&var_tmp);
-            var_tmp = assCore(while_list->var, tmp.value, inter, var_list);
-            if (!run_continue(var_tmp)){
-                freeResult(&tmp);
-                result = var_tmp;
+            assCore(while_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+            if (!run_continue(result)){
                 set_result = false;
                 goto not_else;
             }
-            freeResult(&var_tmp);  // 赋值的返回值被丢弃
+            freeResult(result);  // 赋值的返回值被丢弃
         }
 
-        bool condition = checkBool(tmp.value->value);
-        freeResult(&tmp);
+        bool condition = checkBool(condition_value->value);
         if (condition){
-            Result code_tmp;
-            setResultCore(&code_tmp);
-            if (cycleBranchSafeInterStatement(&code_tmp, CALL_INTER_FUNCTIONSIG(while_list->code, var_list))){
-                result = code_tmp;
+            if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->code, var_list, result))){
                 set_result = false;
                 goto not_else;
             }
-            if (code_tmp.type == break_return)
+            else if (result->type == break_return)
                 is_break = true;
-            if (code_tmp.type == continue_return)
+            else if (result->type == continue_return)
                 PASS;
-            freeResult(&code_tmp);
+            freeResult(result);
         }
         else
             break;
 
-        if (st->u.while_branch.after == NULL)
-            goto not_after_do;
+        if (after == NULL)
+            continue;
 
-        if (cycleBranchSafeInterStatement(&do_tmp, CALL_INTER_FUNCTIONSIG(st->u.while_branch.after, var_list))){
-            result = do_tmp;
+        if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(after, var_list, result))){
             set_result = false;
             goto not_else;
         }
-        if (do_tmp.type == break_return) {
-            freeResult(&do_tmp);
+        else if (result->type == break_return) {
+            freeResult(result);
             goto not_else;
         }
-        if (do_tmp.type == continue_return)
+        else if (result->type == continue_return)
             PASS;
 
-        freeResult(&do_tmp);
-        not_after_do: PASS;
+        freeResult(result);
     }
-    if (!is_break && st->u.while_branch.else_list != NULL && cycleBranchSafeInterStatement(&else_tmp, CALL_INTER_FUNCTIONSIG(st->u.while_branch.else_list, var_list))){
+    if (!is_break && else_st != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
         set_result = false;
-        result = else_tmp;
-    }
     else
-        freeResult(&else_tmp);
+        freeResult(result);
 
     not_else:
-    if (st->u.while_branch.finally != NULL && cycleBranchSafeInterStatement(&finally_tmp, CALL_INTER_FUNCTIONSIG(st->u.while_branch.finally, var_list))){
+    if (finally != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
         if (!set_result)
-            freeResult(&result);
+            freeResult(result);
         set_result = false;
-        result = finally_tmp;
+        *result = finally_tmp;
     }
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(&result, inter);
-    return result;
+        setResult(result, inter);
+    return result->type;
 }
 
-Result tryBranch(INTER_FUNCTIONSIG) {
-    bool set_result = true;
+ResultType tryBranch(INTER_FUNCTIONSIG) {
     StatementList *except_list = st->u.try_branch.except_list;
-    Result result;
-    Result try_result;
-    Result var_tmp;
-    Result except_result;
-    Result else_tmp;
+    Statement *try = st->u.try_branch.try;
+    Statement *else_st = st->u.try_branch.else_list;
+    Statement *finally = st->u.try_branch.finally;
+    LinkValue *error_value = NULL;
+    bool set_result = true;
+
     Result finally_tmp;
-    setResultCore(&result);
-    setResultCore(&except_result);
-    setResultCore(&try_result);
-    setResultCore(&var_tmp);
-    setResultCore(&else_tmp);
+    setResultCore(result);
     setResultCore(&finally_tmp);
 
     var_list = pushVarList(var_list, inter);
-    if (!tryBranchSafeInterStatement(&try_result, CALL_INTER_FUNCTIONSIG(st->u.try_branch.try, var_list))){
-        freeResult(&try_result);
+    if (!tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(try, var_list, result))){
+        freeResult(result);
         goto not_except;
     }
 
     if (except_list == NULL) {
-        result = try_result;
         set_result = false;
         goto not_else;
     }
+
+    error_value = result->value;
+    freeResult(result);
     if (except_list->var != NULL){
-        freeResult(&var_tmp);
-        var_tmp = assCore(except_list->var, try_result.value, inter, var_list);
-        if (!run_continue(var_tmp)){
-            freeResult(&try_result);
-            result = var_tmp;
+        assCore(except_list->var, error_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        if (!run_continue(result)){
             set_result = false;
             goto not_else;
         }
-        freeResult(&var_tmp);  // 赋值的返回值被丢弃
+        freeResult(result);
     }
-    if (tryBranchSafeInterStatement(&except_result, CALL_INTER_FUNCTIONSIG(except_list->code, var_list))){
-        result = except_result;
+    if (tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(except_list->code, var_list, result)))
         set_result = false;
-    }
     else
-        freeResult(&except_result);
-
-    freeResult(&try_result);
+        freeResult(result);
     goto not_else;
 
     not_except:
-    if (st->u.try_branch.else_list != NULL && tryBranchSafeInterStatement(&else_tmp, CALL_INTER_FUNCTIONSIG(st->u.try_branch.else_list, var_list))){
+    if (else_st != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
         set_result = false;
-        result = else_tmp;
-    }
     else
-        freeResult(&else_tmp);
+        freeResult(result);
 
     not_else:
-    if (st->u.try_branch.finally != NULL && tryBranchSafeInterStatement(&finally_tmp, CALL_INTER_FUNCTIONSIG(st->u.try_branch.finally, var_list))){
+    if (finally != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
         if (!set_result)
-            freeResult(&result);
+            freeResult(result);
         set_result = false;
-        result = finally_tmp;
+        *result = finally_tmp;
     }
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(&result, inter);
-    return result;
+        setResult(result, inter);
+    return result->type;
 }
 
-Result breakCycle(INTER_FUNCTIONSIG){
-    Result result;
-    Result times;
-    setResultCore(&result);
-    setResultCore(&times);
-
+ResultType breakCycle(INTER_FUNCTIONSIG){
     int times_int = 0;
+    setResultCore(result);
     if (st->u.break_cycle.times == NULL)
         goto not_times;
 
-    if (operationSafeInterStatement(&times, CALL_INTER_FUNCTIONSIG(st->u.break_cycle.times, var_list)))
-        return times;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.break_cycle.times, var_list, result)))
+        return result->type;
 
-    checkNumber(times);
-    times_int = (int)times.value->value->data.num.num;
-    freeResult(&times);
+    checkNumber(result);
+    times_int = (int)result->value->value->data.num.num;
+    freeResult(result);
 
     not_times:
-    setResult(&result, inter);
+    setResult(result, inter);
     if (times_int >= 0) {
-        result.type = break_return;
-        result.times = times_int;
+        result->type = break_return;
+        result->times = times_int;
     }
-    return result;
+    return result->type;
 }
 
-Result continueCycle(INTER_FUNCTIONSIG){
-    Result result;
-    Result times;
-    setResultCore(&result);
-    setResultCore(&times);
-
+ResultType continueCycle(INTER_FUNCTIONSIG){
     int times_int = 0;
+    setResultCore(result);
     if (st->u.continue_cycle.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(&times, CALL_INTER_FUNCTIONSIG(st->u.continue_cycle.times, var_list)))
-        return times;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.continue_cycle.times, var_list, result)))
+        return result->type;
 
-    checkNumber(times);
-    times_int = (int)times.value->value->data.num.num;
-    freeResult(&times);
+    checkNumber(result);
+    times_int = (int)result->value->value->data.num.num;
+    freeResult(result);
 
     not_times:
-    setResult(&result, inter);
+    setResult(result, inter);
     if (times_int >= 0) {
-        result.type = continue_return;
-        result.times = times_int;
+        result->type = continue_return;
+        result->times = times_int;
     }
-    return result;
+    return result->type;
 }
 
-Result regoIf(INTER_FUNCTIONSIG){
-    Result result;
-    Result times;
-    setResultCore(&result);
-    setResultCore(&times);
-
+ResultType regoIf(INTER_FUNCTIONSIG){
     int times_int = 0;
+    setResultCore(result);
     if (st->u.rego_if.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(&times, CALL_INTER_FUNCTIONSIG(st->u.rego_if.times, var_list)))
-        return times;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.rego_if.times, var_list, result)))
+        return result->type;
 
-    checkNumber(times);
-    times_int = (int)times.value->value->data.num.num;
-    freeResult(&times);
+    checkNumber(result);
+    times_int = (int)result->value->value->data.num.num;
+    freeResult(result);
 
     not_times:
-    setResult(&result, inter);
+    setResult(result, inter);
     if (times_int >= 0) {
-        result.type = rego_return;
-        result.times = times_int;
+        result->type = rego_return;
+        result->times = times_int;
     }
-    return result;
+    return result->type;
 }
 
-Result restartCode(INTER_FUNCTIONSIG){
-    Result result;
-    Result times;
-    setResultCore(&result);
-    setResultCore(&times);
-
+ResultType restartCode(INTER_FUNCTIONSIG){
     int times_int = 0;
+    setResultCore(result);
     if (st->u.restart.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(&times, CALL_INTER_FUNCTIONSIG(st->u.restart.times, var_list)))
-        return times;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.restart.times, var_list, result)))
+        return result->type;
 
-    checkNumber(times);
-    times_int = (int)times.value->value->data.num.num;
-    freeResult(&times);
+    checkNumber(result);
+    times_int = (int)result->value->value->data.num.num;
+    freeResult(result);
 
     not_times:
-    setResult(&result, inter);
+    setResult(result, inter);
     if (times_int >= 0) {
-        result.type = restart_return;
-        result.times = times_int;
+        result->type = restart_return;
+        result->times = times_int;
     }
-    return result;
+    return result->type;
 }
 
-Result returnCode(INTER_FUNCTIONSIG){
-    Result result;
-    setResultCore(&result);
-
+ResultType returnCode(INTER_FUNCTIONSIG){
+    setResultCore(result);
     if (st->u.return_code.value == NULL) {
-        setResult(&result, inter);
+        setResult(result, inter);
         goto set_result;
     }
 
-    if (operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(st->u.return_code.value, var_list)))
-        return result;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.return_code.value, var_list, result)))
+        return result->type;
 
     set_result:
-    result.type = function_return;
-    return result;
+    result->type = function_return;
+    return result->type;
 }
 
-Result raiseCode(INTER_FUNCTIONSIG){
-    Result result;
-    setResultCore(&result);
-
+ResultType raiseCode(INTER_FUNCTIONSIG){
+    setResultCore(result);
     if (st->u.raise_code.value == NULL) {
-        setResult(&result, inter);
+        setResult(result, inter);
         goto set_result;
     }
 
-    if (operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(st->u.raise_code.value, var_list)))
-        return result;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.raise_code.value, var_list, result)))
+        return result->type;
 
     set_result:
-    result.type = error_return;
-    setResultError(&result, inter, "RaiseException", "Exception was raise by user", st, false);
-    return result;
+    result->type = error_return;
+    result->error = connectError(makeError("RaiseException", "Exception was raise by user", st->line, st->code_file), result->error);
+    return result->type;
 }

src/runcall.c

@@ -1,57 +1,54 @@
 #include "__run.h"
 
-Result setFunction(INTER_FUNCTIONSIG) {
-    Result result;
+enum ResultType  setFunction(INTER_FUNCTIONSIG) {
     LinkValue *tmp = makeLinkValue(NULL, NULL, inter);
-    setResultCore(&result);
+    setResultCore(result);
 
     tmp->value = makeFunctionValue(st->u.set_function.function, st->u.set_function.parameter, var_list, inter);
-    result = assCore(st->u.set_function.name, tmp, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-    if (!run_continue(result))
-        return result;
-    setResult(&result, inter);
-    return result;
+    assCore(st->u.set_function.name, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    if (run_continue(result))
+        setResult(result, inter);
+
+    return result->type;
 }
 
-Result callFunction(INTER_FUNCTIONSIG) {
-    Result result;
-    Result function_value;
-    Result set_tmp;
-    setResultCore(&result);
-    setResultCore(&function_value);
-    setResultCore(&set_tmp);
-
-    if (operationSafeInterStatement(&function_value, CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list)))
-        return function_value;
-    if (function_value.value->value->type != function){
-        freeResult(&function_value);
-        setResultError(&result, inter, "TypeException", "Object is not callable", st, true);
-        result.type = error_return;
+enum ResultType callFunction(INTER_FUNCTIONSIG) {
+    LinkValue *function_value = NULL;
+    VarList *function_var = NULL;
+    setResultCore(result);
+
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list, result)))
+        goto return_;
+    if (result->value->value->type != function){
+        setResultError(result, inter, "TypeException", "Object is not callable", st, true);
         goto return_;
     }
-    VarList *function_var = pushVarList(function_value.value->value->data.function.var, inter);
+
+    function_value = result->value;
+    function_var = pushVarList(function_value->value->data.function.var, inter);
     gcAddTmp(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, true);
 
-    set_tmp = setParameter(st->u.call_function.parameter, function_value.value->value->data.function.pt, function_var,
-                           st, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-    if (set_tmp.type == error_return) {
+    freeResult(result);
+    setParameter(st->u.call_function.parameter, function_value->value->data.function.pt, function_var,
+                 st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    if (!run_continue(result)) {
         gcAddTmp(&function_var->hashtable->gc_status);
         runFREEZE(inter, var_list, function_var, false);
         popVarList(function_var);
-        return set_tmp;
+        goto return_;
     }
     else
-        freeResult(&set_tmp);
-    functionSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(function_value.value->value->data.function.function, function_var));
+        freeResult(result);
+
+    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(function_value->value->data.function.function, function_var, result));
 
     gcFreeTmpLink(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, false);
     popVarList(function_var);
 
-    freeResult(&function_value);
-    setResultError(&result, inter, NULL, NULL, st, false);  // 自带检查
+    setResultError(result, inter, NULL, NULL, st, false);  // 自带检查
 
     return_:
-    return result;
+    return result->type;
 }

src/runfile.c

@@ -1,28 +1,24 @@
 #include "__run.h"
 
-Result includeFile(INTER_FUNCTIONSIG) {
+ResultType includeFile(INTER_FUNCTIONSIG) {
     Statement *new_st = NULL;
     ParserMessage *pm = NULL;
     char *file_dir = NULL;
-    Result result;
-    Result file;
-    setResultCore(&result);
-    setResultCore(&file);
+    setResultCore(result);
 
-    if (operationSafeInterStatement(&file, CALL_INTER_FUNCTIONSIG(st->u.include_file.file, var_list)))
-        return file;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.include_file.file, var_list, result)))
+        return result->type;
 
-    if (!isType(file.value->value, string)){
-        freeResult(&file);
-        setResultError(&result, inter, "TypeException", "Don't get a string value", st, true);
+    if (!isType(result->value->value, string)){
+        setResultError(result, inter, "TypeException", "Don't get a string value", st, true);
         goto return_;
     }
 
-    file_dir = file.value->value->data.str.str;
-    freeResult(&file);
+    file_dir = result->value->value->data.str.str;
+    freeResult(result);
 
     if (checkFile(file_dir) != 1){
-        setResultError(&result, inter, "IncludeFileException", "File is not readable", st, true);
+        setResultError(result, inter, "IncludeFileException", "File is not readable", st, true);
         goto return_;
     }
 
@@ -30,16 +26,16 @@ Result includeFile(INTER_FUNCTIONSIG) {
     pm = makeParserMessage(file_dir, NULL);
     parserCommandList(pm, inter, true, new_st);
     if (pm->status != success){
-        setResultError(&result, inter, "IncludeSyntaxException", pm->status_message, st, true);
+        setResultError(result, inter, "IncludeSyntaxException", pm->status_message, st, true);
         goto return_;
     }
 
-    functionSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(new_st, var_list));
+    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(new_st, var_list, result));
     if (!run_continue(result))
-        setResultError(&result, inter, NULL, NULL, st, false);
+        setResultError(result, inter, NULL, NULL, st, false);
 
     return_:
     freeStatement(new_st);
     freeParserMessage(pm, true);
-    return result;
+    return result->type;
 }

src/runoperation.c

@@ -1,39 +1,10 @@
 #include "__run.h"
-/**
- * operation.c中是用于数学计算的函数
- */
 
-#define getresult(base, var, inter) do{ \
-if (operationSafeInterStatement(&var, CALL_INTER_FUNCTIONSIG(st->u.operation.base, var_list))){ return var; }} while (0)
-
-#define getresultFree(base, var, other, inter) do{ \
-if (operationSafeInterStatement(&var, CALL_INTER_FUNCTIONSIG(st->u.operation.base, var_list))){ \
-freeResult(&other); \
-return var; \
-} \
-}while(0)
-#define viewtype_core(a, b, valuetype_a, valuetype_a_b) a .value->value->type == valuetype_a && b.value->value->type == valuetype_a_b
-#define viewtype(a, b, valuetype) viewtype_core(a, b, valuetype, valuetype)
-#define operationValue(a, b, type, symbol) a.value->value->data.type symbol b.value->value->data.type
-#define valueToResult(result, result_value, type, inter) result.value->value = make##type##Value(result_value, inter)
-#define noneOperation(left, right, result, st) \
-else if (left.value->value->type == none){ \
-result = right; \
-gcAddTmp(&result.value->gc_status); \
-} \
-else if (right.value->value->type == none){ \
-result = left; \
-gcAddTmp(&result.value->gc_status); \
-} \
-else{ \
-setResultError(&result, inter, "TypeException", "Get Not Support Value", st, true); \
-}PASS
-
-Result addOperation(INTER_FUNCTIONSIG);
-Result subOperation(INTER_FUNCTIONSIG);
-Result mulOperation(INTER_FUNCTIONSIG);
-Result divOperation(INTER_FUNCTIONSIG);
-Result assOperation(INTER_FUNCTIONSIG);
+enum ResultType addOperation(INTER_FUNCTIONSIG);
+enum ResultType subOperation(INTER_FUNCTIONSIG);
+enum ResultType mulOperation(INTER_FUNCTIONSIG);
+enum ResultType divOperation(INTER_FUNCTIONSIG);
+enum ResultType assOperation(INTER_FUNCTIONSIG);
 
 /**
  * operation的整体操作
@@ -42,179 +13,172 @@ Result assOperation(INTER_FUNCTIONSIG);
  * @param var_list
  * @return
  */
-Result operationStatement(INTER_FUNCTIONSIG) {
-    Result result;
-    setResultCore(&result);
+ResultType operationStatement(INTER_FUNCTIONSIG) {
+    setResultCore(result);
     switch (st->u.operation.OperationType) {
         case OPT_ADD:
-            result = addOperation(CALL_INTER_FUNCTIONSIG(st, var_list));
+            addOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case OPT_SUB:
-            result = subOperation(CALL_INTER_FUNCTIONSIG(st, var_list));
+            subOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case OPT_MUL:
-            result = mulOperation(CALL_INTER_FUNCTIONSIG(st, var_list));
+            mulOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case OPT_DIV:
-            result = divOperation(CALL_INTER_FUNCTIONSIG(st, var_list));
+            divOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         case OPT_ASS:
-            result = assOperation(CALL_INTER_FUNCTIONSIG(st, var_list));
+            assOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
             break;
         default:
-            setResult(&result, inter);
+            setResult(result, inter);
             break;
     }
-    return result;
+    return result->type;
+}
+
+bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG){
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.left, var_list, result)) || result->value->value->type == none)
+        return true;
+    *left = *result;
+    setResultCore(result);
+
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result)) || result->value->value->type == none)
+        return true;
+    *right = *result;
+    return false;
 }
 
-Result addOperation(INTER_FUNCTIONSIG) {
+ResultType addOperation(INTER_FUNCTIONSIG) {
     Result left;
     Result right;
-    Result result;
     setResultCore(&left);
     setResultCore(&right);
-    setResultCore(&result);
 
-    getresult(left, left, inter);
-    getresultFree(right, right, left, inter);
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+        return result->type;
 
-    setResultOperationBase(&result, makeLinkValue(NULL, NULL, inter), inter);
-    if (viewtype(left, right, number))
-        valueToResult(result, (operationValue(left, right, num.num, +)), Number, inter);
-    else if(viewtype(left, right, string)){
+    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    if (left.value->value->type == number && right.value->value->type == number)
+        result->value->value = makeNumberValue(left.value->value->data.num.num + right.value->value->data.num.num, inter);
+    else if(left.value->value->type == string && right.value->value->type == string){
         char *new_string = memStrcat(left.value->value->data.str.str, right.value->value->data.str.str, false);
-        valueToResult(result, new_string, String, inter);
+        result->value->value = makeStringValue(new_string, inter);
         memFree(new_string);
     }
-    noneOperation(left, right, result, st);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
+
     freeResult(&left);
     freeResult(&right);
-    return result;
+    return result->type;
 }
 
-Result subOperation(INTER_FUNCTIONSIG) {
+ResultType subOperation(INTER_FUNCTIONSIG) {
     Result left;
     Result right;
-    Result result;
     setResultCore(&left);
     setResultCore(&right);
-    setResultCore(&result);
 
-    getresult(left, left, inter);
-    getresultFree(right, right, left, inter);
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+        return result->type;
 
-    setResultOperationBase(&result, makeLinkValue(NULL, NULL, inter), inter);
-    if (viewtype(left, right, number))
-        valueToResult(result, (operationValue(left, right, num.num, -)), Number, inter);
+    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    if (left.value->value->type == number && right.value->value->type == number)
+        result->value->value = makeNumberValue(left.value->value->data.num.num - right.value->value->data.num.num, inter);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
 
-    noneOperation(left, right, result, st);
     freeResult(&left);
     freeResult(&right);
-    return result;
+    return result->type;
 }
 
-Result mulOperation(INTER_FUNCTIONSIG) {
+ResultType mulOperation(INTER_FUNCTIONSIG) {
     Result left;
     Result right;
-    Result result;
     setResultCore(&left);
     setResultCore(&right);
-    setResultCore(&result);
 
-    getresult(left, left, inter);
-    getresultFree(right, right, left, inter);
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+        return result->type;
 
-    setResultOperationBase(&result, makeLinkValue(NULL, NULL, inter), inter);
-    if (viewtype(left, right, number))
-        valueToResult(result, (operationValue(left, right, num.num, *)), Number, inter);
-    else if(viewtype_core(left, right, number, string)){
+    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    if (left.value->value->type == number && right.value->value->type == number)
+        result->value->value = makeNumberValue(left.value->value->data.num.num * right.value->value->data.num.num, inter);
+    else if(left.value->value->type == number && right.value->value->type == string){
         Result tmp = left;
         left = right;
         right = tmp;
         goto mul_str;
     }
-    else if(viewtype_core(left, right, string, number)){
-        mul_str:
-        {
-            char *new_string = memStrcpySelf(left.value->value->data.str.str, right.value->value->data.num.num);
-            valueToResult(result, new_string, String, inter);
-            memFree(new_string);
-        }
+    else if(left.value->value->type == string && right.value->value->type == number) mul_str: {
+        char *new_string = memStrcpySelf(left.value->value->data.str.str, right.value->value->data.num.num);
+        result->value->value = makeStringValue(new_string, inter);
+        memFree(new_string);
     }
-    noneOperation(left, right, result, st);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
 
     freeResult(&left);
     freeResult(&right);
-    return result;
+    return result->type;
 }
 
-Result divOperation(INTER_FUNCTIONSIG) {
+ResultType divOperation(INTER_FUNCTIONSIG) {
     Result left;
     Result right;
-    Result result;
     setResultCore(&left);
     setResultCore(&right);
-    setResultCore(&result);
 
-    getresult(left, left, inter);
-    getresultFree(right, right, left, inter);
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+        return result->type;
+
+    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    if (left.value->value->type == number && right.value->value->type == number)
+        result->value->value = makeNumberValue(left.value->value->data.num.num / right.value->value->data.num.num, inter);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
 
-    setResultOperationBase(&result, makeLinkValue(NULL, NULL, inter), inter);
-    if (viewtype(left, right, number))
-        valueToResult(result, (operationValue(left, right, num.num, /)), Number, inter);
-    noneOperation(left, right, result, st);
     freeResult(&left);
     freeResult(&right);
-    printf("result.tmp = %ld, %p\n", result.value->gc_status.tmp_link, result.value);
-    return result;
+    return result->type;
 }
 
-Result assOperation(INTER_FUNCTIONSIG) {
-    Result result;
-    Result times;
-    setResultCore(&result);
-    setResultCore(&times);
-
-    getresult(right, result, inter);
-    times = assCore(st->u.operation.left, result.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-    if (is_error(times)) {
-        freeResult(&result);
-        return times;
-    }
-    freeResult(&times);
-    return result;
-}
+ResultType assOperation(INTER_FUNCTIONSIG) {
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result)))
+        return result->type;
+    assCore(st->u.operation.left, result->value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
 
-Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
-    Result result;
-    Result tmp_result;
-    setResultCore(&result);
-    setResultCore(&tmp_result);
+    return result->type;
+}
 
+ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
     int int_times;
+    setResultCore(result);
+    gcAddTmp(&value->gc_status);
+
     if (name->type == base_list && name->u.base_list.type == value_tuple){
         Parameter *pt = NULL;
         Argument *call = NULL;
         Statement *tmp_st = makeBaseLinkValueStatement(value, name->line, name->code_file);
 
         pt = makeArgsParameter(tmp_st);
-        call = getArgument(pt, &tmp_result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-        if (!run_continue(tmp_result)) {
+        call = getArgument(pt, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        if (!run_continue(result)) {
             freeArgument(call, false);
             freeParameter(pt, true);
-            return tmp_result;
+            goto return_;
         }
 
-        freeResult(&tmp_result);
-        tmp_result = setParameterCore(call, name->u.base_list.list, var_list, name, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-        if (!run_continue(tmp_result))
-            result = tmp_result;
-        else{
+        freeResult(result);
+         setParameterCore(call, name->u.base_list.list, var_list, name, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        if (run_continue(result)){
             Argument *tmp = call;
             LinkValue *new_value = makeLinkValue(makeListValue(&tmp, inter, value_tuple), NULL, inter);
-            freeResult(&tmp_result);
-            setResultOperation(&result, new_value, inter);
+            freeResult(result);
+            setResultOperation(result, new_value, inter);
         }
         freeArgument(call, false);
         freeParameter(pt, true);
@@ -222,113 +186,112 @@ Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
     else{
         char *str_name = NULL;
 
-        tmp_result = getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list));
-        if (!run_continue(tmp_result)) {
+        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result));
+        if (!run_continue(result)) {
             memFree(str_name);
-            return tmp_result;
+            return result->type;
         }
-        addFromVarList(str_name, var_list, int_times, value, tmp_result.value);
+        addFromVarList(str_name, var_list, int_times, value, result->value);
         memFree(str_name);
-        freeResult(&tmp_result);
+        freeResult(result);
 
-        setResultCore(&result);
-        result.type = operation_return;
-        result.value = value;
-        gcAddTmp(&result.value->gc_status);
+        result->type = operation_return;
+        result->value = value;
+        gcAddTmp(&result->value->gc_status);
     }
-    return result;
+
+    return_:
+    gcFreeTmpLink(&value->gc_status);
+    return result->type;
 }
 
-Result getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
+ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
     int int_times = 0;
     char *name = NULL;
-    Result result;
-    Result tmp;
-    setResultCore(&result);
-    setResultCore(&tmp);
 
-    tmp = var_info(&name, &int_times, CALL_INTER_FUNCTIONSIG(st, var_list));
-    if (!run_continue(tmp)) {
+    freeResult(result);
+    var_info(&name, &int_times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    if (!run_continue(result)) {
         memFree(name);
-        return tmp;
+        return result->type;
     }
-    freeResult(&tmp);
 
-    setResultCore(&result);
-    result.type = operation_return;
-    result.value = findFromVarList(name, var_list, int_times, false);
-    memFree(name);
+    freeResult(result);
+    result->type = operation_return;
+    result->value = findFromVarList(name, var_list, int_times, false);
 
-    if (result.value == NULL){
-        char *info = memStrcat("Name Not Found: ", st->u.base_var.name, false);
-        setResultError(&result, inter, "NameException", info, st, true);
+    if (result->value == NULL){
+        char *info = memStrcat("Name Not Found: ", name, false);
+        setResultError(result, inter, "NameException", info, st, true);
         memFree(info);
     }
     else
-        gcAddTmp(&result.value->gc_status);
+        gcAddTmp(&result->value->gc_status);
 
-    return result;
+    memFree(name);
+    return result->type;
 }
 
-Result getBaseValue(INTER_FUNCTIONSIG) {
-    Result result;
-    setResultCore(&result);
+ResultType getBaseValue(INTER_FUNCTIONSIG) {
+    freeResult(result);
     if (st->u.base_value.type == link_value) {
-        result.value = st->u.base_value.value;
+        result->value = st->u.base_value.value;
     }
     else if (st->u.base_value.type == number_str){
         char *stop = NULL;
-        result.value = makeLinkValue(makeNumberValue(strtol(st->u.base_value.str, &stop, 10), inter), NULL, inter);
+        result->value = makeLinkValue(makeNumberValue(strtol(st->u.base_value.str, &stop, 10), inter), NULL, inter);
     }
     else
-        result.value = makeLinkValue(makeStringValue(st->u.base_value.str, inter), NULL, inter);
-    result.type = operation_return;
-    gcAddTmp(&result.value->gc_status);
-    return result;
+        result->value = makeLinkValue(makeStringValue(st->u.base_value.str, inter), NULL, inter);
+
+    result->type = operation_return;
+    gcAddTmp(&result->value->gc_status);
+    return result->type;
 }
 
-Result getList(INTER_FUNCTIONSIG) {
+ResultType getList(INTER_FUNCTIONSIG) {
     Argument *at = NULL;
     Argument *at_tmp = NULL;
-    Result result;
-    setResultCore(&result);
 
-    at = getArgument(st->u.base_list.list, &result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    freeResult(result);
+    at = getArgument(st->u.base_list.list, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     at_tmp = at;
     if (!run_continue(result)){
         freeArgument(at_tmp, true);
-        return result;
+        return result->type;
     }
 
     LinkValue *value = makeLinkValue(makeListValue(&at, inter, st->u.base_list.type), NULL, inter);
-    setResultOperation(&result, value, inter);
+    setResultOperation(result, value, inter);
     freeArgument(at_tmp, false);
 
-    return result;
+    return result->type;
 }
 
-Result getDict(INTER_FUNCTIONSIG) {
+// TODO-szh 设置字典key为变量时直接取值
+ResultType getDict(INTER_FUNCTIONSIG) {
     Argument *at = NULL;
     Argument *at_tmp = NULL;
-    Result result;
-    setResultCore(&result);
 
-    at = getArgument(st->u.base_dict.dict, &result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    freeResult(result);
+    at = getArgument(st->u.base_dict.dict, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     at_tmp = at;
     if (!run_continue(result)){
         freeArgument(at_tmp, false);
-        return result;
+        return result->type;
     }
 
-    Value *tmp_value = makeDictValue(&at, true, &result, inter, var_list);
+    freeResult(result);
+    Value *tmp_value = makeDictValue(&at, true, result, inter, var_list);
     if (!run_continue(result)) {
         freeArgument(at_tmp, false);
-        return result;
+        return result->type;
     }
-    freeResult(&result);
+
+    freeResult(result);
     LinkValue *value = makeLinkValue(tmp_value, NULL, inter);
-    setResultOperation(&result, value, inter);
+    setResultOperation(result, value, inter);
     freeArgument(at_tmp, false);
 
-    return result;
+    return result->type;
 }

src/statement.c

@@ -192,16 +192,17 @@ Statement *makeIncludeStatement(Statement *file, long int line, char *file_dir){
 }
 
 void connectStatement(Statement *base, Statement *new){
-    while (base->next != NULL){
-        base = base->next;
-    }
+    for (PASS; base->next != NULL; base = base->next)
+        PASS;
     base->next = new;
 }
 
 void freeStatement(Statement *st){
+    Statement *next_tmp = NULL;
     freeBase(st, return_);
-    Statement *next_tmp;
-    while (st != NULL){
+
+    for (PASS; st != NULL; st = next_tmp){
+        next_tmp = st->next;
         switch (st->type) {
             case operation:
                 freeStatement(st->u.operation.right);
@@ -291,9 +292,7 @@ void freeStatement(Statement *st){
                 break;
         }
         memFree(st->code_file);
-        next_tmp = st->next;
         memFree(st);
-        st = next_tmp;
     }
     return_:
     return;
@@ -304,13 +303,10 @@ Statement *copyStatement(Statement *st){
         return NULL;
 
     Statement *tmp = copyStatementCore(st);
-    Statement *base_tmp = tmp;
+    Statement *base_tmp = NULL;
 
-    while (st->next != NULL){
+    for (base_tmp = tmp; st->next != NULL;st = st->next, tmp = tmp->next)
         tmp->next = copyStatementCore(st->next);
-        tmp = tmp->next;
-        st = st->next;
-    }
     return base_tmp;
 }
 
@@ -429,37 +425,32 @@ StatementList *connectStatementList(StatementList *base, StatementList *new){
     StatementList *tmp = base;
     if (base == NULL)
         return new;
-    while (tmp->next != NULL){
-        tmp = tmp->next;
-    }
+    for (PASS; tmp->next != NULL; tmp = tmp->next)
+        PASS;
     tmp->next = new;
     return base;
 }
 
 void freeStatementList(StatementList *base){
-    while (base != NULL){
+    StatementList *next = NULL;
+    for (PASS; base != NULL; base = next){
+        next = base->next;
         freeStatement(base->condition);
         freeStatement(base->code);
         freeStatement(base->var);
-        StatementList *tmp = base;
-        base = base->next;
-        memFree(tmp);
+        memFree(base);
     }
 }
 
 StatementList *copyStatementList(StatementList *sl){
+    StatementList *tmp = NULL;
+    StatementList *base_tmp = NULL;
+
     if (sl == NULL)
         return NULL;
 
-    StatementList *tmp = makeStatementList(copyStatement(sl->condition), copyStatement(sl->var),
-                                           copyStatement(sl->code), sl->type);
-    StatementList *base_tmp = tmp;
-
-    while (sl->next != NULL){
-        tmp->next = makeStatementList(copyStatement(sl->condition), copyStatement(sl->var),
-                                      copyStatement(sl->code), sl->type);
-        tmp = tmp->next;
-        sl = sl->next;
-    }
+    tmp = makeStatementList(copyStatement(sl->condition), copyStatement(sl->var),copyStatement(sl->code), sl->type);
+    for (base_tmp = tmp; sl->next != NULL;tmp = tmp->next, sl = sl->next)
+        tmp->next = makeStatementList(copyStatement(sl->condition), copyStatement(sl->var), copyStatement(sl->code), sl->type);
     return base_tmp;
 }

src/value.c

@@ -13,9 +13,9 @@ Value *makeValue(Inter *inter) {
         goto return_;
     }
 
-    while (list_tmp->next !=  NULL){
-        list_tmp = list_tmp->next;
-    }
+    for (PASS; list_tmp->next !=  NULL; list_tmp = list_tmp->next)
+        PASS;
+
     list_tmp->next = tmp;
     tmp->last = list_tmp;
 
@@ -57,11 +57,10 @@ Value *makeListValue(Argument **arg_ad, Inter *inter, enum ListType type) {
     tmp->data.list.type = type;
     tmp->data.list.list = NULL;
     tmp->data.list.size = 0;
-    while (at != NULL && at->type == value_arg){
+    for (PASS; at != NULL && at->type == value_arg; at = at->next) {
         tmp->data.list.size++;
         tmp->data.list.list = memRealloc(tmp->data.list.list, tmp->data.list.size * sizeof(LinkValue *));
         tmp->data.list.list[tmp->data.list.size - 1] = at->data.value;
-        at = at->next;
     }
     *arg_ad = at;
     return tmp;
@@ -77,7 +76,7 @@ Value *makeDictValue(Argument **arg_ad, bool new_hash, Result *result, Inter *in
         gcAddTmp(&tmp->gc_status);
         tmp->data.dict.dict = hash->hashtable;
         freeResult(result);
-        *result = argumentToVar(arg_ad, inter, hash, &tmp->data.dict.size);
+        argumentToVar(arg_ad, &tmp->data.dict.size, CALL_INTER_FUNCTIONSIG_NOT_ST(hash, result));
         popVarList(hash);
         gcFreeTmpLink(&tmp->gc_status);
     }
@@ -134,8 +133,8 @@ LinkValue *makeLinkValue(Value *value, LinkValue *linkValue, Inter *inter){
         goto return_;
     }
 
-    while (list_tmp->next !=  NULL)
-        list_tmp = list_tmp->next;
+    for (PASS; list_tmp->next !=  NULL; list_tmp = list_tmp->next)
+        PASS;
 
     list_tmp->next = tmp;
     tmp->last = list_tmp;
@@ -212,14 +211,18 @@ void setResultOperationBase(Result *ru, LinkValue *value, Inter *inter) {
 }
 
 void freeResult(Result *ru){
-    if (ru->error != NULL)
-        freeError(ru);
+    freeResultSave(ru);
     if (ru->value != NULL) {
         gcFreeTmpLink(&ru->value->gc_status);
         ru->value = NULL;
     }
 }
 
+void freeResultSave(Result *ru){
+    if (ru->error != NULL)
+        freeError(ru);
+}
+
 void printValue(Value *value, FILE *debug){
     switch (value->type){
         case number:
@@ -242,11 +245,11 @@ void printValue(Value *value, FILE *debug){
             writeLog(debug, INFO, " ]", NULL);
             break;
         case dict: {
+            Var *tmp = NULL;
             bool print_comma = false;
             writeLog(debug, INFO, "dict on <%p> size : %d  { ", value, (int) value->data.dict.size);
             for (int i = 0; i < MAX_SIZE; i++) {
-                Var *tmp = value->data.dict.dict->hashtable[i];
-                while (tmp != NULL) {
+                for (tmp = value->data.dict.dict->hashtable[i]; tmp != NULL; tmp = tmp->next) {
                     if (print_comma)
                         writeLog(debug, INFO, ", ", NULL);
                     else
@@ -254,7 +257,6 @@ void printValue(Value *value, FILE *debug){
                     printLinkValue(tmp->name_, "", "", debug);
                     writeLog(debug, INFO, " ['%s'] : ", tmp->name);
                     printLinkValue(tmp->value, "", "", debug);
-                    tmp = tmp->next;
                 }
             }
             writeLog(debug, INFO, " }", NULL);
@@ -299,27 +301,24 @@ Error *connectError(Error *new, Error *base){
 
 void freeError(Result *base){
     Error *error = base->error;
-    while (error != NULL){
-        Error *tmp = error->next;
+    for (Error *next = NULL; error != NULL; error = next){
+        next = error->next;
         memFree(error->messgae);
         memFree(error->type);
         memFree(error->file);
         memFree(error);
-        error = tmp;
     }
     base->error = NULL;
 }
 
 void printError(Result *result, Inter *inter, bool free) {
-    Error *base = result->error;
-    while (base != NULL){
+    for (Error *base = result->error; base != NULL; base = base->next){
         if (base->next != NULL){
             writeLog(inter->data.error, ERROR, "Error Backtracking:  On Line: %ld In file: %s Error ID: %p\n", base->line, base->file, base);
         }
         else{
             writeLog(inter->data.error, ERROR, "%s\n%s\nOn Line: %ld\nIn File: %s\nError ID: %p\n", base->type, base->messgae, base->line, base->file, base);
         }
-        base = base->next;
     }
     if (free)
         freeError(result);

src/var.c

@@ -37,8 +37,8 @@ HashTable *makeHashTable(Inter *inter) {
         goto return_;
     }
 
-    while (list_tmp->next !=  NULL)
-        list_tmp = list_tmp->next;
+    for (PASS; list_tmp->next !=  NULL; list_tmp = list_tmp->next)
+        PASS;
     list_tmp->next = tmp;
     tmp->last = list_tmp;
 
@@ -96,9 +96,8 @@ VarList *freeVarList(VarList *vl, bool self){
  */
 HASH_INDEX time33(char *key){ // hash function
     HASH_INDEX hash = 5381;
-    while(*key){
+    while(*key)
         hash += (hash << (HASH_INDEX)5) + (*key++);
-    }
     return (hash & (HASH_INDEX)0x7FFFFFFF) % MAX_SIZE;
 }
 
@@ -108,25 +107,17 @@ void addVar(char *name, LinkValue *value, LinkValue *name_, VarList *var_list) {
     Var *base = var_list->hashtable->hashtable[index];
     if (base == NULL){
         var_list->hashtable->hashtable[index] = makeVar(name, value, name_);
-        goto return_;
-    }
-    while (true){
-        if (base->next != NULL)
-            goto new_one;
-        if (eqString(base->name, name))
-            goto change;
-        base = base->next;
+        return;
     }
-    new_one:
-    base->next = makeVar(name, value, name_);
-    goto return_;
-
-    change:
-    base->value = value;
-    goto return_;
-
-    return_:
-    return;
+    for (PASS; true; base = base->next)
+        if (base->next != NULL) {
+            base->next = makeVar(name, value, name_);
+            break;
+        }
+        else if (eqString(base->name, name)) {
+            base->value = value;
+            break;
+        }
 }
 
 LinkValue *findVar(char *name, VarList *var_list, bool del_var) {
@@ -134,10 +125,11 @@ LinkValue *findVar(char *name, VarList *var_list, bool del_var) {
     HASH_INDEX index = time33(name);
     Var *base = var_list->hashtable->hashtable[index];
     Var *last = NULL;
-    if (base == NULL){
+
+    if (base == NULL)
         goto return_;
-    }
-    while (base != NULL){
+
+    for (PASS; base != NULL; last = base, base = base->next){
         if (eqString(base->name, name)){
             tmp = base->value;
             if (del_var){
@@ -148,8 +140,6 @@ LinkValue *findVar(char *name, VarList *var_list, bool del_var) {
             }
             goto return_;
         }
-        last = base;
-        base = base->next;
     }
     return_:
     return tmp;
@@ -157,24 +147,16 @@ LinkValue *findVar(char *name, VarList *var_list, bool del_var) {
 
 LinkValue *findFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, bool del_var) {
     LinkValue *tmp = NULL;
-    for (NUMBER_TYPE i=0; i < times && var_list->next != NULL; i++){
+    for (NUMBER_TYPE i=0; i < times && var_list->next != NULL; i++)
         var_list = var_list->next;
-    }
-    while (var_list != NULL){
+    for (PASS; var_list != NULL && tmp == NULL; var_list = var_list->next)
         tmp = findVar(name, var_list, del_var);
-        if (tmp != NULL){
-            goto return_;
-        }
-        var_list = var_list->next;
-    }
-    return_:
     return tmp;
 }
 
 void addFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, LinkValue *value, LinkValue *name_) {
-    for (NUMBER_TYPE i=0; i < times && var_list->next != NULL; i++){
+    for (NUMBER_TYPE i=0; i < times && var_list->next != NULL; i++)
         var_list = var_list->next;
-    }
     addVar(name, value, name_, var_list);
 }
 
@@ -197,14 +179,11 @@ VarList *copyVarListCore(VarList *base, Inter *inter){
 }
 
 VarList *copyVarList(VarList *base, bool n_new, Inter *inter){
-    VarList *new;
-    VarList *tmp;
+    VarList *new = NULL;
+    VarList *tmp = NULL;
     new = tmp = copyVarListCore(base, inter);
-    while (base->next != NULL){
+    for (PASS; base->next != NULL; tmp = tmp->next, base = base->next)
         tmp->next = copyVarListCore(base->next, inter);
-        tmp = tmp->next;
-        base = base->next;
-    }
     if (n_new)
         new = pushVarList(new, inter);
     return new;