fix: var操作operating使用枚举体, if分支修改为switch

对变量操作传入操作类型参数使用枚举体(原位int类型)
代码中的部分的if分支改为switch分支
清除grammar中未使用的形参

include/var.h

@@ -32,10 +32,17 @@ struct VarList{
     struct VarList *next;
 };
 
+enum VarOperation {
+    get_var,
+    read_var,
+    del_var,
+};
+
 typedef struct Var Var;
 typedef struct HashTable HashTable;
 typedef struct DefaultVar DefaultVar;
 typedef struct VarList VarList;
+typedef enum VarOperation VarOperation;
 
 Var *makeVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter);
 void freeVar(Var **var);
@@ -47,8 +54,8 @@ VarList *makeVarList(Inter *inter, bool make_hash);
 VarList *freeVarList(VarList *vl);
 
 HASH_INDEX time33(char *key);
-LinkValue *findVar(char *name, int operating, Inter *inter, HashTable *ht);
-LinkValue *findFromVarList(char *name, NUMBER_TYPE times, int operating, INTER_FUNCTIONSIG_CORE);
+LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht);
+LinkValue *findFromVarList(char *name, NUMBER_TYPE times, VarOperation operating, INTER_FUNCTIONSIG_CORE);
 void addVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht);
 void updateHashTable(HashTable *update, HashTable *new, Inter *inter);
 void addFromVarList(char *name, LinkValue *name_, NUMBER_TYPE times, LinkValue *value, INTER_FUNCTIONSIG_CORE);

parser/__grammar.c

@@ -44,7 +44,7 @@ inline void twoOperation(PASERSSIGNATURE, PasersFunction callBack, GetSymbolFunc
 
         callBack(CALLPASERSSIGNATURE);  // 获得右值
         if (!call_success(pm) || readBackToken(pm) != call_type){  // 若非正确数值
-            syntaxError(pm, syntax_error, line, 3, "ERROR from ", self_name, "(get right)");
+            syntaxError(pm, syntax_error, line, 5, "ERROR from ", self_name, "(get right ", call_name, ")");
             freeToken(left_token, true);
             freeStatement(st);
             goto return_;
@@ -69,7 +69,7 @@ inline void twoOperation(PASERSSIGNATURE, PasersFunction callBack, GetSymbolFunc
  * @param self_name 输出值名称(log)
  */
 inline void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction tailFunction, int call_type,
-                          int self_type, char *call_name, char *self_name){
+                          int self_type){
     while(true){
         Token *left_token = NULL;
         struct Statement *st = NULL;
@@ -149,8 +149,7 @@ bool checkToken(ParserMessage *pm, int type){
     return true;
 }
 
-bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st,
-                         char *log_message, bool must_operation, char *error_message) {
+bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st, bool must_operation, char *error_message) {
     Token *tmp_token = NULL;
     *st = NULL;
     parserControl(CALLPASERSSIGNATURE, callBack, type, must_operation, error_message);
@@ -161,11 +160,6 @@ bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type
     freeToken(tmp_token, false);
     return true;
 }
-
-inline bool commandCallBack_(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message){
-    return callChildStatement(CALLPASERSSIGNATURE, callBack, type, st, NULL);
-}
-
 bool callParserCode(PASERSSIGNATURE, Statement **st, char *message, long int line) {
     Token *tmp;
     *st = NULL;

parser/grammar.c

@@ -103,81 +103,72 @@ void parserCommand(PASERSSIGNATURE){
     token_type = readBackToken(pm);
     switch (token_type) {
         case MATHER_AT :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserDecoration, DECORATION, &st, "Command: call decoration\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserDecoration, DECORATION, &st, NULL);
             break;
         case MATHER_NONLOCAL :
         case MATHER_GLOBAL :
         case MATHER_DEFAULT :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserVarControl, VARCONTROL, &st, "Command: call var control\n");  // TODO-szh 取消message
+            status = callChildStatement(CALLPASERSSIGNATURE, parserVarControl, VARCONTROL, &st, NULL);
             break;
         case MATHER_CLASS :
         case MATHER_DEF :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserDef, FUNCTION, &st, "Command: call def/class\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserDef, FUNCTION, &st, NULL);
             break;
         case MATHER_GOTO :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserGoto, GOTO, &st, "Command: call goto\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserGoto, GOTO, &st, NULL);
             break;
         case MATHER_LABEL :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserLabel, LABEL, &st, "Command: call label\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserLabel, LABEL, &st, NULL);
             break;
         case MATHER_DO :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserDo, DO_BRANCH, &st, "Command: call do\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserDo, DO_BRANCH, &st, NULL);
             break;
         case MATHER_WITH :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserWith, WITH_BRANCH, &st, "Command: call with\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserWith, WITH_BRANCH, &st, NULL);
             break;
         case MATHER_IF :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserIf, IF_BRANCH, &st, "Command: call if\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserIf, IF_BRANCH, &st, NULL);
             break;
         case MATHER_FOR :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserFor, FOR_BRANCH, &st, "Command: call for\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserFor, FOR_BRANCH, &st, NULL);
             break;
         case MATHER_WHILE :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserWhile, WHILE_BRANCH, &st, "Command: call while\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserWhile, WHILE_BRANCH, &st, NULL);
             break;
         case MATHER_TRY :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserTry, TRY_BRANCH, &st, "Command: call try\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserTry, TRY_BRANCH, &st, NULL);
             break;
         case MATHER_BREAK :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeBreakStatement, BREAK, &st,
-                                         "Command: call break\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeBreakStatement, BREAK, &st, false, NULL);
             break;
         case MATHER_CONTINUE :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeContinueStatement, CONTINUE, &st,
-                                         "Command: call continue\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeContinueStatement, CONTINUE, &st, false, NULL);
             break;
         case MATHER_RESTART :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRestartStatement, RESTART, &st,
-                                         "Command: call restart\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRestartStatement, RESTART, &st, false, NULL);
             break;
         case MATHER_REGO :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRegoStatement, REGO, &st,
-                                         "Command: call rego\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRegoStatement, REGO, &st, false, NULL);
             break;
         case MATHER_RETURN :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeReturnStatement, RETURN, &st,
-                                         "Command: call return\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeReturnStatement, RETURN, &st, false, NULL);
             break;
         case MATHER_YIELD :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeYieldStatement, YIELD, &st,
-                                         "Command: call yield\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeYieldStatement, YIELD, &st, false, NULL);
             break;
         case MATHER_RAISE :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRaiseStatement, RAISE, &st,
-                                         "Command: call raise\n", false, NULL);
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRaiseStatement, RAISE, &st, false, NULL);
         case MATHER_ASSERT :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeAssertStatement, ASSERT, &st,
-                                         "Command: call assert\n", true,
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeAssertStatement, ASSERT, &st, true,
                                          "parserAssert: Don't get conditions after assert");
             break;
         case MATHER_INCLUDE :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeIncludeStatement, INCLUDE, &st,
-                                         "Command: call include\n", true,
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeIncludeStatement, INCLUDE, &st, true,
                                          "parserInclude: Don't get file after include");
             break;
         case MATHER_FROM :
         case MATHER_IMPORT :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserImport, IMPORT, &st, "Command: call import\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserImport, IMPORT, &st, NULL);
             break;
         case MATHER_STRING:
         case MATHER_NUMBER:
@@ -190,8 +181,7 @@ void parserCommand(PASERSSIGNATURE){
         case MATHER_PROTECT:
         case MATHER_PRIVATE:
         case MATHER_PUBLIC:
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserOperation, OPERATION, &st,
-                                      "Command: call operation\n");
+            status = callChildStatement(CALLPASERSSIGNATURE, parserOperation, OPERATION, &st, NULL);
             break;
         default:
             status = false;
@@ -1237,8 +1227,7 @@ int tailCall(PASERSSIGNATURE, Token *left_token, Statement **st){
     return 1;
 }
 void parserCallBack(PASERSSIGNATURE){
-    return tailOperation(CALLPASERSSIGNATURE, parserSlice, tailCall, SLICE, CALLBACK,
-            "slice", "call back");
+    return tailOperation(CALLPASERSSIGNATURE, parserSlice, tailCall, SLICE, CALLBACK);
 }
 
 int tailSlice(PASERSSIGNATURE, Token *left_token, Statement **st){
@@ -1272,8 +1261,7 @@ int tailSlice(PASERSSIGNATURE, Token *left_token, Statement **st){
     return 1;
 }
 void parserSlice(PASERSSIGNATURE){
-    return tailOperation(CALLPASERSSIGNATURE, parserPoint, tailSlice, POINT, SLICE,
-                         "point", "slice");
+    return tailOperation(CALLPASERSSIGNATURE, parserPoint, tailSlice, POINT, SLICE);
 }
 
 /**
@@ -1330,170 +1318,190 @@ int getOperation(PASERSSIGNATURE, int right_type, Statement **st, char *name){
 void parserBaseValue(PASERSSIGNATURE){
     Token *value_token = popNewToken(pm->tm);
     Statement *st = NULL;
-    if (MATHER_NUMBER == value_token->token_type){
-        Statement *tmp = NULL;
-        tmp = makeBaseStrValueStatement(value_token->data.str, number_str, value_token->line, pm->file);
-        if (*value_token->data.second_str == NUL)
-            st = tmp;
-        else{
-            Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line, pm->file);
-            st = makeCallStatement(sencod_var, makeValueParameter(tmp));
-        }
-    }
-    else if (MATHER_STRING == value_token->token_type){
-        Value *tmp_value = makeStringValue(value_token->data.str, inter);
-        Statement *tmp = NULL;
-        tmp = makeBaseStrValueStatement(value_token->data.str, string_str, value_token->line, pm->file);
-        if (*value_token->data.second_str == NUL)
-            st = tmp;
-        else{
-            Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line, pm->file);
-            st = makeCallStatement(sencod_var, makeValueParameter(tmp));
-        }
-    }
-    else if (MATHER_TRUE == value_token->token_type)
-        st = makeBaseValueStatement(bool_true, value_token->line, pm->file);
-    else if (MATHER_FALSE == value_token->token_type)
-        st = makeBaseValueStatement(bool_false, value_token->line, pm->file);
-    else if (MATHER_NULL == value_token->token_type)
-        st = makeBaseValueStatement(null_value, value_token->line, pm->file);
-    else if (MATHER_PASSVALUE == value_token->token_type)
-        st = makeBaseValueStatement(pass_value, value_token->line, pm->file);
-    else if (MATHER_LAMBDA == value_token->token_type){
-        Parameter *pt = NULL;
-        Statement *lambda_st = NULL;
-        if (!parserParameter(CALLPASERSSIGNATURE, &pt, false, true, false, false, MATHER_COMMA, MATHER_ASSIGNMENT)) {
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a lambda parameter");
-            goto return_;
-        }
-        if (!checkToken(pm, MATHER_COLON)){
-            lambda_st = makeStatement(value_token->line, pm->file);
-            goto not_lambda_st;
-        }
-        if (!callChildStatement(CALLPASERSSIGNATURE, parserOperation, OPERATION, &lambda_st, "Don't get a lambda operation")){
-            freeToken(value_token, true);
-            goto return_;
-        }
-        not_lambda_st:
-        st = makeLambdaStatement(lambda_st, pt);
-    }
-    else if (MATHER_VAR == value_token->token_type)
-        st = makeBaseVarStatement(value_token->data.str, NULL, value_token->line, pm->file);
-    else if (MATHER_SVAR == value_token->token_type){
-        Statement *svar_st = NULL;
-        if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &svar_st, NULL)){
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get super var after $");
-            freeToken(value_token, true);
-            goto return_;
-        }
-        st = makeBaseSVarStatement(svar_st, NULL);
-    }
-    else if (MATHER_LB == value_token->token_type){
-        int tmp;
-        Statement *tmp_st = NULL;
-        lexEnter(pm, true);
-        tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RB, &tmp_st, "base value");
-        lexEnter(pm, false);
-        if (tmp == 0){
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get operation from Base Value");
-            goto return_;
-        }
-        else if(tmp == -1){
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get ] from list/var");
-            goto return_;  // 优化goto return freeToken
+    switch (value_token->token_type) {
+        case MATHER_NUMBER : {
+            Statement *tmp = NULL;
+            tmp = makeBaseStrValueStatement(value_token->data.str, number_str, value_token->line, pm->file);
+            if (*value_token->data.second_str == NUL)
+                st = tmp;
+            else {
+                Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line,
+                                                             pm->file);
+                st = makeCallStatement(sencod_var, makeValueParameter(tmp));
+            }
+            break;
         }
-        if (MATHER_VAR == readBackToken(pm)){
-            Token *var_token;
-            var_token = popNewToken(pm->tm);
-            st = makeBaseVarStatement(var_token->data.str, tmp_st, var_token->line, pm->file);
-            freeToken(var_token, false);
+
+        case MATHER_STRING:{
+            Value *tmp_value = makeStringValue(value_token->data.str, inter);
+            Statement *tmp = NULL;
+            tmp = makeBaseStrValueStatement(value_token->data.str, string_str, value_token->line, pm->file);
+            if (*value_token->data.second_str == NUL)
+                st = tmp;
+            else {
+                Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line,
+                                                             pm->file);
+                st = makeCallStatement(sencod_var, makeValueParameter(tmp));
+            }
+            break;
         }
-        else{
-            if (tmp_st == NULL)
-                st = makeTupleStatement(NULL, value_list, value_token->line, pm->file);
-            else if (tmp_st->type == base_list && tmp_st->u.base_list.type == value_tuple){
-                tmp_st->u.base_list.type = value_list;
-                st = tmp_st;
+        case MATHER_TRUE:
+            st = makeBaseValueStatement(bool_true, value_token->line, pm->file);
+            break;
+        case MATHER_FALSE:
+            st = makeBaseValueStatement(bool_false, value_token->line, pm->file);
+            break;
+        case MATHER_NULL:
+            st = makeBaseValueStatement(null_value, value_token->line, pm->file);
+            break;
+        case MATHER_PASSVALUE:
+            st = makeBaseValueStatement(pass_value, value_token->line, pm->file);
+            break;
+        case MATHER_LAMBDA:  {
+            Parameter *pt = NULL;
+            Statement *lambda_st = NULL;
+            if (!parserParameter(CALLPASERSSIGNATURE, &pt, false, true, false, false, MATHER_COMMA,
+                                 MATHER_ASSIGNMENT)) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a lambda parameter");
+                goto return_;
             }
-            else
-                st = makeTupleStatement(makeValueParameter(tmp_st), value_list, value_token->token_type, pm->file);
+            if (!checkToken(pm, MATHER_COLON)) {
+                lambda_st = makeStatement(value_token->line, pm->file);
+                goto not_lambda_st;
+            }
+            if (!callChildStatement(CALLPASERSSIGNATURE, parserOperation, OPERATION, &lambda_st,
+                                    "Don't get a lambda operation")) {
+                freeToken(value_token, true);
+                goto return_;
+            }
+            not_lambda_st:
+            st = makeLambdaStatement(lambda_st, pt);
+            break;
         }
-    }
-    else if (MATHER_LP == value_token->token_type){
-        int tmp;
-        lexEnter(pm, true);
-        tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RP, &st, "base value");
-        lexEnter(pm, false);
-        if (tmp == 0){
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get operation from Base Value");
-            goto return_;
+        case MATHER_VAR:
+            st = makeBaseVarStatement(value_token->data.str, NULL, value_token->line, pm->file);
+            break;
+        case MATHER_SVAR: {
+            Statement *svar_st = NULL;
+            if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &svar_st, NULL)) {
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get super var after $");
+                freeToken(value_token, true);
+                goto return_;
+            }
+            st = makeBaseSVarStatement(svar_st, NULL);
+            break;
         }
-        else if(tmp == -1){
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get ) from Base Value");
-            goto return_;
+        case MATHER_LB: {
+            int tmp;
+            Statement *tmp_st = NULL;
+            lexEnter(pm, true);
+            tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RB, &tmp_st, "base value");
+            lexEnter(pm, false);
+            if (tmp == 0) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get operation from Base Value");
+                goto return_;
+            } else if (tmp == -1) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get ] from list/var");
+                goto return_;  // 优化goto return freeToken
+            }
+            if (MATHER_VAR == readBackToken(pm)) {
+                Token *var_token;
+                var_token = popNewToken(pm->tm);
+                st = makeBaseVarStatement(var_token->data.str, tmp_st, var_token->line, pm->file);
+                freeToken(var_token, false);
+            } else {
+                if (tmp_st == NULL)
+                    st = makeTupleStatement(NULL, value_list, value_token->line, pm->file);
+                else if (tmp_st->type == base_list && tmp_st->u.base_list.type == value_tuple) {
+                    tmp_st->u.base_list.type = value_list;
+                    st = tmp_st;
+                } else
+                    st = makeTupleStatement(makeValueParameter(tmp_st), value_list, value_token->token_type, pm->file);
+            }
+            break;
         }
-    }
-    else if (MATHER_LC == value_token->token_type){
-        Parameter *pt = NULL;
-        int parser_status;
-        parser_status = parserParameter(CALLPASERSSIGNATURE, &pt, true, false, false, true, MATHER_COMMA, MATHER_COLON);
-        if (!parser_status) {
-            freeToken(value_token, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a dict parameter");
-            goto return_;
+        case MATHER_LP: {
+            int tmp;
+            lexEnter(pm, true);
+            tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RP, &st, "base value");
+            lexEnter(pm, false);
+            if (tmp == 0) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get operation from Base Value");
+                goto return_;
+            } else if (tmp == -1) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get ) from Base Value");
+                goto return_;
+            }
+            break;
         }
-        if (!checkToken(pm, MATHER_RC)) {
-            freeToken(value_token, true);
-            freeParameter(pt, true);
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a } after dict");
-            goto return_;
+        case MATHER_LC: {
+            Parameter *pt = NULL;
+            int parser_status;
+            parser_status = parserParameter(CALLPASERSSIGNATURE, &pt, true, false, false, true, MATHER_COMMA,
+                                            MATHER_COLON);
+            if (!parser_status) {
+                freeToken(value_token, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a dict parameter");
+                goto return_;
+            }
+            if (!checkToken(pm, MATHER_RC)) {
+                freeToken(value_token, true);
+                freeParameter(pt, true);
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a } after dict");
+                goto return_;
+            }
+            st = makeBaseDictStatement(pt, value_token->line, pm->file);
+            break;
         }
-        st = makeBaseDictStatement(pt, value_token->line, pm->file);
-    }
-    else if (MATHER_BLOCK == value_token->token_type){
-        Statement *block = NULL;
-        if (!callParserCode(CALLPASERSSIGNATURE, &block, "Don't get a while code", value_token->line)) {
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get block command");
-            freeToken(value_token, true);
-            goto return_;
+        case MATHER_BLOCK: {
+            Statement *block = NULL;
+            if (!callParserCode(CALLPASERSSIGNATURE, &block, "Don't get a while code", value_token->line)) {
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get block command");
+                freeToken(value_token, true);
+                goto return_;
+            }
+            st = makeOperationStatement(OPT_BLOCK, block, NULL);
+            break;
         }
-        st = makeOperationStatement(OPT_BLOCK, block, NULL);
-    }
-    else if (MATHER_PROTECT == value_token->token_type || MATHER_PRIVATE == value_token->token_type || MATHER_PUBLIC == value_token->token_type){
-        if (MATHER_COLON != readBackToken(pm)){
-            syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a : after aut token");
-            freeToken(value_token, true);
-            goto return_;
+        case MATHER_PRIVATE:
+        case MATHER_PROTECT:
+        case MATHER_PUBLIC: {
+            if (MATHER_COLON != readBackToken(pm)) {
+                syntaxError(pm, syntax_error, value_token->line, 1, "Don't get a : after aut token");
+                freeToken(value_token, true);
+                goto return_;
+            }
+            delToken(pm);
+            if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &st,
+                                    "Don't get Base Value after aut token")) {
+                freeToken(value_token, true);
+                goto return_;
+            }
+            switch (value_token->token_type) {
+                case MATHER_PROTECT:
+                    st->aut = protect_aut;
+                    break;
+                case MATHER_PRIVATE:
+                    st->aut = private_aut;
+                    break;
+                case MATHER_PUBLIC:
+                    st->aut = public_aut;
+                    break;
+            }
+            break;
         }
-        delToken(pm);
-        if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &st, "Don't get Base Value after aut token")){
-            freeToken(value_token, true);
+        default:{
+            backToken_(pm, value_token);
             goto return_;
         }
-        switch (value_token->token_type) {
-            case MATHER_PROTECT:
-                st->aut = protect_aut;
-                break;
-            case MATHER_PRIVATE:
-                st->aut = private_aut;
-                break;
-            case MATHER_PUBLIC:
-                st->aut = public_aut;
-                break;
-        }
-    }
-    else{
-        backToken_(pm, value_token);
-        goto return_;
     }
     freeToken(value_token, false);
     addStatementToken(BASEVALUE, st, pm);
 
-    return_:
-    return;
+    return_: return;
 }

parser/include/__grammar.h

@@ -48,9 +48,7 @@ void syntaxError(ParserMessage *pm, int status,long int line , int num, ...);
 int readBackToken(ParserMessage *pm);
 bool checkToken(ParserMessage *pm, int type);
 
-bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st,
-                         char *log_message, bool must_operation, char *error_message);
-bool commandCallBack_(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message);
+bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st, bool must_operation, char *error_message);
 
 bool callParserCode(PASERSSIGNATURE, Statement **st, char *message, long int line);
 bool callParserAs(PASERSSIGNATURE, Statement **st,char *message);
@@ -62,8 +60,7 @@ bool parserParameter(PASERSSIGNATURE, Parameter **pt, bool enter, bool is_formal
 
 void twoOperation(PASERSSIGNATURE, PasersFunction callBack, GetSymbolFunction getSymbol, ChecktLeftToken checkleft,
                   int call_type, int self_type, char *call_name, char *self_name, bool is_right);
-void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction tailFunction, int call_type, int self_type,
-                   char *call_name, char *self_name);
+void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction tailFunction, int call_type, int self_type);
 
 void lexEnter(ParserMessage *pm, bool lock);
 

src/__run.c

@@ -198,7 +198,7 @@ void freeFunctionArgument(Argument *arg, Argument *base) {
 LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
     LinkValue *tmp = NULL;
     char *name_ = setStrVarName(name, free_old, inter);
-    tmp = findFromVarList(name_, 0, 0, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    tmp = findFromVarList(name_, 0, get_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     memFree(name_);
     return tmp;
 }
@@ -206,7 +206,7 @@ LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
 LinkValue *checkStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
     LinkValue *tmp = NULL;
     char *name_ = setStrVarName(name, free_old, inter);
-    tmp = findFromVarList(name_, 0, 2, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    tmp = findFromVarList(name_, 0, read_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     memFree(name_);
     return tmp;
 }

src/parameter.c

@@ -342,7 +342,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
         }
 
         freeResult(result);
-        value = findFromVarList(str_name, int_times, 1, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        value = findFromVarList(str_name, int_times, del_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
         memFree(str_name);
 
         if(value == NULL) {

src/runoperation.c

@@ -166,7 +166,7 @@ ResultType varAss(Statement *name, LinkValue *value, bool check_aut, INTER_FUNCT
     if (name->aut != auto_aut)
         var_value->aut = name->aut;
     if (check_aut) {
-        LinkValue *tmp = findFromVarList(str_name, int_times, 2, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        LinkValue *tmp = findFromVarList(str_name, int_times, read_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
         if (tmp != NULL) {
             if ((value->aut == public_aut || value->aut == auto_aut) && (tmp->aut != public_aut && tmp->aut != auto_aut)) {
                 setResultErrorSt(result, inter, "PermissionsException", "Wrong Permissions: access variables as public",
@@ -184,7 +184,7 @@ ResultType varAss(Statement *name, LinkValue *value, bool check_aut, INTER_FUNCT
             set_var: addFromVarList(str_name, result->value, int_times, var_value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     } else {
         if (name->aut != auto_aut) {
-            LinkValue *tmp = findFromVarList(str_name, int_times, 2, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+            LinkValue *tmp = findFromVarList(str_name, int_times, read_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
             if (tmp != NULL)
                 tmp->aut = name->aut;
         }
@@ -287,7 +287,7 @@ ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
 
     freeResult(result);
     result->type = operation_return;
-    result->value = findFromVarList(name, int_times, 0, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    result->value = findFromVarList(name, int_times, get_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     if (result->value == NULL) {
         char *info = memStrcat("Name Not Found: ", name, false, false);
         setResultErrorSt(result, inter, "NameException", info, st, belong, true);
@@ -318,20 +318,26 @@ ResultType getBaseValue(INTER_FUNCTIONSIG) {
         result->value = st->u.base_value.value;
     else {
         Value *value = NULL;
-        if (st->u.base_value.type == number_str) {
-            char *stop = NULL;
-            value = makeNumberValue(strtol(st->u.base_value.str, &stop, 10), inter);
+        switch (st->u.base_value.type){
+            case number_str:
+                value = makeNumberValue(strtol(st->u.base_value.str, NULL, 10), inter);
+                break;
+            case bool_true:
+                value = makeBoolValue(true, inter);
+                break;
+            case bool_false:
+                value = makeBoolValue(false, inter);
+                break;
+            case pass_value:
+                value = makePassValue(inter);
+                break;
+            case null_value:
+                value = makeNoneValue(inter);
+                break;
+            default:
+                value = makeStringValue(st->u.base_value.str, inter);
+                break;
         }
-        else if (st->u.base_value.type == bool_true)
-            value = makeBoolValue(true, inter);
-        else if (st->u.base_value.type == bool_false)
-            value = makeBoolValue(false, inter);
-        else if (st->u.base_value.type == pass_value)
-            value = makePassValue(inter);
-        else if (st->u.base_value.type == null_value)
-            value = makeNoneValue(inter);
-        else
-            value = makeStringValue(st->u.base_value.str, inter);
         result->value = makeLinkValue(value, belong, inter);
     }
 

src/var.c

@@ -174,14 +174,14 @@ void updateHashTable(HashTable *update, HashTable *new, Inter *inter) {
 }
 
 
-LinkValue *findVar(char *name, int operating, Inter *inter, HashTable *ht) {  // TODO-szh int operating 使用枚举体
+LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht) {
     LinkValue *tmp = NULL;
     HASH_INDEX index = time33(name);
 
     for (Var **base = &ht->hashtable[index]; *base != NULL; base = &(*base)->next){
         if (eqString((*base)->name, name)){
             tmp = (*base)->value;
-            if (operating == 1) {
+            if (operating == del_var) {
                 Var *next = (*base)->next;
                 (*base)->next = NULL;
                 *base = next;
@@ -189,24 +189,23 @@ LinkValue *findVar(char *name, int operating, Inter *inter, HashTable *ht) {  //
             goto return_;
         }
     }
-    return_:
-    return operating == 2 ? tmp : copyLinkValue(tmp, inter);
+    return_: return operating == get_var ? copyLinkValue(tmp, inter) : tmp;
 }
 
 /**
  * @param name
  * @param times
- * @param operating 1-删除  2-读取  0-获取
+ * @param operating read_var-不复制读取 get_var-复制读取 del_var-删除且返回(不复制)
  * @param inter
  * @param var_list
  * @return
  */
-LinkValue *findFromVarList(char *name, NUMBER_TYPE times, int operating, INTER_FUNCTIONSIG_CORE) {
+LinkValue *findFromVarList(char *name, NUMBER_TYPE times, VarOperation operating, INTER_FUNCTIONSIG_CORE) {
     LinkValue *tmp = NULL;
     NUMBER_TYPE base = findDefault(var_list->default_var, name) + times;
     for (NUMBER_TYPE i = 0; i < base && var_list->next != NULL; i++)
         var_list = var_list->next;
-    if (operating == 1 && var_list != NULL)
+    if (operating == del_var && var_list != NULL)
         tmp = findVar(name, true, inter, var_list->hashtable);
     else
         for (PASS; var_list != NULL && tmp == NULL; var_list = var_list->next)