feat: 支持使用中括号声明list

include/run.h

@@ -2,14 +2,14 @@
 #define VIRTUALMATH_RUN_H
 #include "__macro.h"
 
-Result operationStatement(INTER_FUNCTIONSIG);
-Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE);
 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 getBaseVar(INTER_FUNCTIONSIG);
@@ -25,6 +25,8 @@ Result restartCode(INTER_FUNCTIONSIG);
 Result returnCode(INTER_FUNCTIONSIG);
 Result raiseCode(INTER_FUNCTIONSIG);
 
+Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE);
+
 char *setVarName(char *old, bool free_old);
 Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
 Result getVarInfo(char **name, int *times, INTER_FUNCTIONSIG);

include/statement.h

@@ -32,7 +32,7 @@ struct Statement{
             struct Statement *times;
         } base_var;
         struct {
-            enum{
+            enum BaseListType{
                 list_,
                 tuple_,
             } type;
@@ -131,10 +131,13 @@ typedef struct Statement Statement;
 typedef struct StatementList StatementList;
 
 Statement *makeStatement();
-Statement *makeOperationStatement(int type);
-struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right);
+void freeStatement(Statement *st);
+void connectStatement(Statement *base, Statement *new);
 
-Statement *makeTupleStatement(struct Parameter *pt, int type);
+Statement *makeOperationStatement(int type);
+Statement *makeBaseValueStatement(LinkValue *value);
+Statement *makeBaseVarStatement(char *name, Statement *times);
+Statement *makeTupleStatement(struct Parameter *pt, enum BaseListType type);
 Statement *makeFunctionStatement(Statement *name, Statement *function, struct Parameter *pt);
 Statement *makeCallStatement(Statement *function, struct Parameter *pt);
 Statement *makeIfStatement();
@@ -146,12 +149,10 @@ Statement *makeRegoStatement(Statement *times);
 Statement *makeRestartStatement(Statement *times);
 Statement *makeReturnStatement(Statement *value);
 Statement *makeRaiseStatement(Statement *value);
+struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right);
 
-void connectStatement(Statement *base, Statement *new);
-void freeStatement(Statement *st);
-
-StatementList *connectStatementList(StatementList *base, StatementList *new);
 StatementList *makeStatementList(Statement *condition, Statement *var, Statement *code, int type);
+StatementList *connectStatementList(StatementList *base, StatementList *new);
 void freeStatementList(StatementList *base);
 #define makeConnectStatementList(base, condition, var, code, type) connectStatementList(base, makeStatementList(condition, var, code, type))
 

include/syntax.h

@@ -1,13 +1,13 @@
 #ifndef VIRTUALMATH_SYNTAX_H
 #define VIRTUALMATH_SYNTAX_H
 
+#define strMatherMacro(n, word) strMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
+#define charMatherMacro(n, word) charMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
+
 void numberMather(signed char p, LexMather *mather);
 void varMather(signed char p, LexMather *mather);
 void stringMather(signed char p, LexMather *mather);
 void strMather(signed char p, LexMather *mather, const char *dest_p);
 void charMather(signed char p, LexMather *mather, signed char dest_p);
 
-#define strMatherMacro(n, word) strMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
-#define charMatherMacro(n, word) charMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
-
 #endif //VIRTUALMATH_SYNTAX_H

include/token.h

@@ -109,6 +109,12 @@
 #define RAISE -23
 #define TUPLE -24
 
+#define printTokenEnter(tk, debug, type, message) do{ \
+writeLog(debug, type, message, NULL); \
+printToken(tk, debug, type); \
+writeLog(debug, type, "\n", NULL); \
+} while(0)
+
 struct Token{
     int token_type;  // 记录token的类型，大于0的数字均为lex匹配器所匹配，小于0的为syntax解析器所匹配
     struct TokenData{
@@ -136,28 +142,20 @@ typedef struct Token Token;
 typedef struct TokenStream TokenStream;
 typedef struct TokenMessage TokenMessage;
 
+TokenMessage *makeTokenMessage(char *file_dir, char *debug);
+void freeTokenMessage(TokenMessage *tm, bool self);
+
 Token *makeToken();
+void freeToken(Token *tk, bool self, bool error);
 Token *makeLexToken(int type, char *str, char *second_str);
 Token *makeStatementToken(int type, struct Statement *st);
-void freeToken(Token *tk, bool self, bool error);
 
 extern Token *getToken(LexFile *file, LexMathers *mathers, FILE *debug);
-
-
 void addBackToken(TokenStream *ts, Token *new_tk, FILE *debug);
 Token *popNewToken(TokenMessage *tm, FILE *debug);
 
-TokenMessage *makeTokenMessage(char *file_dir, char *debug);
-void freeTokenMessage(TokenMessage *tm, bool self);
-
 // token 可视化函数
 void printTokenStream(TokenStream *ts, FILE *debug, int type);
 void printToken(Token *tk, FILE *debug, int type);
 
-#define printTokenEnter(tk, debug, type, message) do{ \
-writeLog(debug, type, message, NULL); \
-printToken(tk, debug, type); \
-writeLog(debug, type, "\n", NULL); \
-} while(0)
-
 #endif //VIRTUALMATH_TOKEN_H

parser/grammar.c

@@ -771,30 +771,23 @@ void parserBaseValue(PASERSSIGNATURE){
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get number\n", NULL);
         value_token= popAheadToken(pm);
         char *stop;
-        st = makeStatement();
-        st->type = base_value;
-        st->u.base_value.value = makeLinkValue(makeNumberValue(strtol(value_token->data.str, &stop, 10), inter), NULL, inter);
+        st = makeBaseValueStatement(makeLinkValue(makeNumberValue(strtol(value_token->data.str, &stop, 10), inter), NULL, inter));
     }
     else if(MATHER_STRING == token_type){
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get string\n", NULL);
         value_token= popAheadToken(pm);
-        st = makeStatement();
-        st->type = base_value;
-        st->u.base_value.value = makeLinkValue(makeStringValue(value_token->data.str, inter), NULL, inter);
+        st = makeBaseValueStatement(makeLinkValue(makeStringValue(value_token->data.str, inter), NULL, inter));
     }
     else if(MATHER_VAR == token_type){
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get var\n", NULL);
         value_token= popAheadToken(pm);
-        st = makeStatement();
-        st->type = base_var;
-        st->u.base_var.name = memStrcpy(value_token->data.str, 0, false, false);
-        st->u.base_var.times = NULL;
+        st = makeBaseVarStatement(value_token->data.str, NULL);
     }
     else if(MATHER_LB == token_type){
         int tmp;
         Statement *tmp_st = NULL;
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get operation\n", NULL);
-        value_token= popAheadToken(pm);
+        value_token = popAheadToken(pm);
 
         tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RB, &tmp_st, "base value");
         if (tmp == 0){
@@ -809,14 +802,18 @@ void parserBaseValue(PASERSSIGNATURE){
         }
         if (MATHER_VAR == readBackToken(pm)){
             Token *var_token;
-            var_token= popAheadToken(pm);
-            st = makeStatement();
-            st->type = base_var;
-            st->u.base_var.name = memStrcpy(var_token->data.str, 0, false, false);
-            st->u.base_var.times = tmp_st;
+            var_token = popAheadToken(pm);
+            st = makeBaseVarStatement(var_token->data.str, tmp_st);
             freeToken(var_token, true, false);
         }
-        // TODO-szh list处理
+        else{
+            if (tmp_st->type == base_list && tmp_st->u.base_list.type == tuple_){
+                tmp_st->u.base_list.type = list_;
+                st = tmp_st;
+            }
+            else
+                st = makeTupleStatement(makeOnlyValueParameter(tmp_st), list_);
+        }
     }
     else if(MATHER_LP == token_type){
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get operation\n", NULL);

src/parameter.c

@@ -1,4 +1,5 @@
 #include "__virtualmath.h"
+
 #define returnResult(result) do{ \
 if (!run_continue(result)) { \
 goto return_; \
@@ -416,11 +417,10 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
                 break;
             }
             case mul_par: {
-                Result tmp_result;
                 Value *value = makeListValue(&call, inter, value_tuple);
                 LinkValue *tmp = makeLinkValue(value, NULL, inter);
-                tmp_result = assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_CORE(function_var));
-                returnResult(tmp_result);
+                result = assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_CORE(function_var));
+                returnResult(result);
                 function = function->next;
                 break;
             }
@@ -429,9 +429,12 @@ Result setParameterCore(Argument *call, Parameter *function_base, VarList *funct
                 setResultError(&result, inter);
                 goto return_;
             default:
-                goto return_;
+                goto break_;
         }
     }
+    break_:
+    setResult(&result, true ,inter);
+
     return_:
     freeParameter(tmp_function, false);
     return result;

src/statement.c

@@ -32,6 +32,21 @@ Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token
     return new_token;
 }
 
+Statement *makeBaseValueStatement(LinkValue *value){
+    Statement *tmp = makeStatement();
+    tmp->type = base_value;
+    tmp->u.base_value.value = value;
+    return tmp;
+}
+
+Statement *makeBaseVarStatement(char *name, Statement *times){
+    Statement *tmp = makeStatement();
+    tmp->type = base_var;
+    tmp->u.base_var.name = memStrcpy(name, 0, false, false);
+    tmp->u.base_var.times = times;
+    return tmp;
+}
+
 Statement *makeOperationStatement(int type){
     Statement *tmp = makeStatement();
     tmp->type = operation;
@@ -41,7 +56,7 @@ Statement *makeOperationStatement(int type){
     return tmp;
 }
 
-Statement *makeTupleStatement(Parameter *pt, int type) {
+Statement *makeTupleStatement(Parameter *pt, enum BaseListType type) {
     Statement *tmp = makeStatement();
     tmp->type = base_list;
     tmp->u.base_list.type = type;