style: 更新了代码风格

include/__grammar.h

@@ -2,6 +2,11 @@
 #define VIRTUALMATH___GRAMMAR_H
 #include "__virtualmath.h"
 
+typedef void (*PasersFunction)(PASERSSIGNATURE);
+typedef int (*GetSymbolFunction)(PASERSSIGNATURE, int, Statement **);
+typedef Statement *(*MakeControlFunction)(Statement *);
+typedef int (*TailFunction)(PASERSSIGNATURE, Token *, Statement **);
+
 #if OUT_LOG && OUT_PASERS_LOG
 #define doubleLog(pm, grammar_level, pasers_level, message, ...) do{ \
 writeLog(pm->grammar_debug, grammar_level, message, __VA_ARGS__); \
@@ -38,22 +43,20 @@ void parserCallBack(PASERSSIGNATURE);
 void parserFactor(PASERSSIGNATURE);
 void parserAssignment(PASERSSIGNATURE);
 void parserTuple(PASERSSIGNATURE);
-void twoOperation(ParserMessage *pm, Inter *inter, void (*callBack)(ParserMessage *, Inter *),
-                  int (*getSymbol)(ParserMessage *, Inter *, int, Statement **), int type, int self_type,
-                  char *call_name, char *self_name, bool is_right);
-void tailOperation(PASERSSIGNATURE, void (*callBack)(PASERSSIGNATURE), int (*tailFunction)(PASERSSIGNATURE, Token *left_token,  Statement **st), int , int , char *, char *);
-
+void twoOperation(ParserMessage *pm, Inter *inter, PasersFunction callBack, GetSymbolFunction getSymbol,
+                  int type, int self_type, char *call_name, char *self_name, bool is_right);
+void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction tailFunction, int type, int self_type,
+                   char *call_name, char *self_name);
 void syntaxError(ParserMessage *pm, int status, int num, ...);
 int readBackToken(ParserMessage *pm);
 Token *popAheadToken(ParserMessage *pm);
 bool checkToken_(ParserMessage *pm, int type);
-bool commandCallControl_(PASERSSIGNATURE, Statement *(*callBack)(Statement *), int type, Statement **st, char *message);
-bool commandCallBack_(PASERSSIGNATURE, void (*callBack)(PASERSSIGNATURE), int type, Statement **st, char *message);
+bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st, char *message);
+bool commandCallBack_(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message);
 bool callParserCode(PASERSSIGNATURE, Statement **st,char *message);
 bool callParserAs(PASERSSIGNATURE, Statement **st,char *message);
-bool callChildStatement(PASERSSIGNATURE, void (*call)(PASERSSIGNATURE), int type, Statement **st, char *message);
-
-bool callChildToken(ParserMessage *pm, Inter *inter, void (*call)(ParserMessage *, Inter *), int type, Token **tmp,
-                    char *message, int error_type);
+bool callChildStatement(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message);
+bool callChildToken(ParserMessage *pm, Inter *inter, PasersFunction callBack, int type, Token **tmp, char *message,
+                    int error_type);
 
 #endif //VIRTUALMATH___GRAMMAR_H

include/grammar.h

@@ -10,7 +10,7 @@ typedef struct ParserMessage{
     FILE *paser_debug;
     FILE *grammar_debug;
     int count;
-    enum {
+    enum ParserMessageStatus{
         success = 1,
         syntax_error,
         command_list_error,

include/lexical.h

@@ -5,19 +5,19 @@
 
 typedef struct LexFile{
     FILE *file;
-    struct {
+    struct LexFileBack{
         bool is_back;
-        char p;
+        signed char p;
     } back;
     int count;
 } LexFile;
 
 typedef struct LexMather{
     int len;
-    int string_type;
+    signed char string_type;
     char *str;
     char *second_str;
-    enum {
+    enum LexMatherStatus{
         LEXMATHER_START=1,
         LEXMATHER_ING,
         LEXMATHER_INGPOINT,
@@ -34,7 +34,7 @@ typedef struct LexMathers{
     struct LexMather **mathers;
 } LexMathers;
 
-char readChar(LexFile *file);
+signed char readChar(LexFile *file);
 void backChar(LexFile *file);
 
 LexFile *makeLexFile(char *dir);

include/parameter.h

@@ -3,12 +3,12 @@
 #include "__macro.h"
 
 typedef struct Parameter{
-    enum {
-        only_value,
-        name_value,
-        only_args,
+    enum ParameterType{
+        value_par,
+        name_par,
+        args_par,
     } type;
-    struct {
+    struct ParameterData{
         struct Statement *value;
         struct Statement *name;  // 仅在name-value模式生效
     } data;
@@ -16,11 +16,11 @@ typedef struct Parameter{
 } Parameter;
 
 typedef struct Argument{
-    enum {
+    enum ArgumentType{
         value_arg,
         name_arg,
     } type;
-    struct {
+    struct ArgumentData{
         struct LinkValue *value;
         struct Statement *name;  // 仅在name-value模式生效
     } data;

include/syntax.h

@@ -4,11 +4,11 @@
 #include "lexical.h"
 #include "token.h"
 
-void numberMather(char p, LexMather *mather);
-void varMather(char p, LexMather *mather);
-void stringMather(char p, LexMather *mather);
-void strMather(char p, LexMather *mather, const char *dest_p);
-void charMather(char p, LexMather *mather, char dest_p);
+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*/

include/token.h

@@ -111,7 +111,7 @@
 
 typedef struct Token{
     int token_type;  // 记录token的类型，大于0的数字均为lex匹配器所匹配，小于0的为syntax解析器所匹配
-    struct{
+    struct TokenData{
         char *str;
         char *second_str;  // 针对123.4j这种形式设定的，其中second_str存储j
         struct Statement *st;

include/value.h

@@ -22,7 +22,7 @@ typedef struct Value{
             struct Parameter *pt;
         } function;
         struct {
-            enum {
+            enum ListType{
                 value_tuple,
                 value_list,
             } type;
@@ -66,7 +66,7 @@ void freeLinkValue(LinkValue *value, Inter *inter);
 Value *makeNumberValue(long num, Inter *inter);
 Value *makeStringValue(char *str, Inter *inter);
 Value *makeFunctionValue(struct Statement *st, struct Parameter *pt, struct VarList *var_list, Inter *inter);
-Value *makeListValue(struct Argument **ad_ad, Inter *inter, int type);
+Value *makeListValue(struct Argument **arg_ad, Inter *inter, int type);
 
 void setResult(Result *ru, bool link, Inter *inter);
 void setResultError(Result *ru, Inter *inter);

parser/__grammar.c

@@ -1,11 +1,11 @@
 #include "__grammar.h"
 
-inline void twoOperation(ParserMessage *pm, Inter *inter, void (*callBack)(ParserMessage *, Inter *),
-                         int (*getSymbol)(ParserMessage *, Inter *, int, Statement **), int type, int self_type,
-                         char *call_name, char *self_name, bool is_right) {
+inline void twoOperation(ParserMessage *pm, Inter *inter, PasersFunction callBack, GetSymbolFunction getSymbol,
+                         int type, int self_type, char *call_name, char *self_name, bool is_right) {
     bool is_right_ = false;
     while(true){
-        Token *left_token = NULL, *right_token = NULL;
+        Token *left_token = NULL;
+        Token *right_token = NULL;
         struct Statement *st = NULL;
 
         readBackToken(pm);
@@ -18,7 +18,7 @@ inline void twoOperation(ParserMessage *pm, Inter *inter, void (*callBack)(Parse
                       "%s: get %s(left) success[push %s]\n", self_name, call_name, self_name);
             continue;
         }
-        left_token= popAheadToken(pm);
+        left_token = popAheadToken(pm);
 
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: call symbol\n", self_name);
         if (getSymbol(CALLPASERSSIGNATURE, readBackToken(pm), &st)){
@@ -46,14 +46,16 @@ inline void twoOperation(ParserMessage *pm, Inter *inter, void (*callBack)(Parse
 
         right_token = popAheadToken(pm);
         addToken_(pm, setOperationFromToken(&st, left_token, right_token, self_type, is_right_));
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Polynomial: get base value(right) success[push polynomial]\n", NULL);
+        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG,
+                  "Polynomial: get base value(right) success[push polynomial]\n", NULL);
         is_right_ = is_right;  // 第一次is_right不生效
     }
     return_:
     return;
 }
 
-inline void tailOperation(PASERSSIGNATURE, void (*callBack)(PASERSSIGNATURE), int (*tailFunction)(PASERSSIGNATURE, Token *,  Statement **), int type, int self_type, char *call_name, char *self_name){
+inline void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction tailFunction, int type, int self_type,
+                          char *call_name, char *self_name){
     while(true){
         Token *left_token = NULL;
         struct Statement *st = NULL;
@@ -67,7 +69,7 @@ inline void tailOperation(PASERSSIGNATURE, void (*callBack)(PASERSSIGNATURE), in
                       "%s: get %s(left) success[push %s]\n", self_name, call_name, self_name);
             continue;
         }
-        left_token= popAheadToken(pm);
+        left_token = popAheadToken(pm);
 
         int tail_status = tailFunction(CALLPASERSSIGNATURE, left_token, &st);
         if (tail_status == -1){
@@ -139,14 +141,13 @@ Token *popAheadToken(ParserMessage *pm){
 }
 
 bool checkToken_(ParserMessage *pm, int type){
-    if (readBackToken(pm) != type){
+    if (readBackToken(pm) != type)
         return false;
-    }
     delToken(pm);
     return true;
 }
 
-bool commandCallControl_(PASERSSIGNATURE, Statement *(*callBack)(Statement *), int type, Statement **st, char *message){
+bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st, char *message){
     writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, message, NULL);
     Token *tmp_token = NULL;
     parserControl(CALLPASERSSIGNATURE, callBack, type);
@@ -158,7 +159,7 @@ bool commandCallControl_(PASERSSIGNATURE, Statement *(*callBack)(Statement *), i
     return true;
 }
 
-inline bool commandCallBack_(PASERSSIGNATURE, void (*callBack)(PASERSSIGNATURE), int type, Statement **st, char *message){
+inline bool commandCallBack_(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message){
     writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, message, NULL);
     return callChildStatement(CALLPASERSSIGNATURE, callBack, type, st, NULL);
 }
@@ -184,9 +185,9 @@ bool callParserAs(PASERSSIGNATURE, Statement **st,char *message){
     return true;
 }
 
-bool callChildToken(ParserMessage *pm, Inter *inter, void (*call)(ParserMessage *, Inter *), int type, Token **tmp,
-                    char *message, int error_type) {
-    call(CALLPASERSSIGNATURE);
+bool callChildToken(ParserMessage *pm, Inter *inter, PasersFunction callBack, int type, Token **tmp, char *message,
+                    int error_type) {
+    callBack(CALLPASERSSIGNATURE);
     if (!call_success(pm)) {
         *tmp = NULL;
         return false;
@@ -201,9 +202,9 @@ bool callChildToken(ParserMessage *pm, Inter *inter, void (*call)(ParserMessage
     return true;
 }
 
-bool callChildStatement(PASERSSIGNATURE, void (*call)(PASERSSIGNATURE), int type, Statement **st, char *message){
+bool callChildStatement(PASERSSIGNATURE, PasersFunction callBack, int type, Statement **st, char *message){
     Token *tmp = NULL;
-    bool status = callChildToken(CALLPASERSSIGNATURE, call, type, &tmp, message, syntax_error);
+    bool status = callChildToken(CALLPASERSSIGNATURE, callBack, type, &tmp, message, syntax_error);
     if (!status){
         *st = NULL;
         return false;

parser/grammar.c

@@ -47,8 +47,9 @@ void freeParserMessage(ParserMessage *pm, bool self) {
  * | parserCommand MATHER_EOF
  */
 void parserCommandList(ParserMessage *pm, Inter *inter, bool global, Statement *st) {
-    int token_type, stop;
-    struct Statement *base_st = st;
+    int token_type;
+    int stop;
+    Statement *base_st = st;
     while (true){
         token_type = readBackToken(pm);
         if (token_type == MATHER_EOF){
@@ -74,10 +75,7 @@ void parserCommandList(ParserMessage *pm, Inter *inter, bool global, Statement *
             if (stop == MATHER_ENTER || stop == MATHER_SEMICOLON){
                 delToken(pm);
             }
-            else if(stop == MATHER_EOF){
-                PASS;
-            }
-            else{
+            else  if(stop != MATHER_EOF){
                 if (global) {
                     syntaxError(pm, command_list_error, 1, "ERROR from parserCommand list(get stop)");
                     printf("stop = %d\n", stop);
@@ -92,7 +90,6 @@ void parserCommandList(ParserMessage *pm, Inter *inter, bool global, Statement *
                 }
                 goto return_;
             }
-            /*...do something for commandList...*/
             connectStatement(base_st, command_token->data.st);
             freeToken(command_token, true, false);
             writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: get command success\n", NULL);
@@ -114,37 +111,48 @@ void parserCommand(PASERSSIGNATURE){
     token_type = readBackToken(pm);
     switch (token_type) {
         case MATHER_DEF :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserDef, FUNCTION, &st, "Command: call def\n");
+            status = commandCallBack_(CALLPASERSSIGNATURE, parserDef, FUNCTION, &st,
+                                      "Command: call def\n");
             break;
         case MATHER_IF :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserIf, IF_BRANCH, &st, "Command: call if\n");
+            status = commandCallBack_(CALLPASERSSIGNATURE, parserIf, IF_BRANCH, &st,
+                                      "Command: call if\n");
             break;
         case MATHER_WHILE :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserWhile, WHILE_BRANCH, &st, "Command: call while\n");
+            status = commandCallBack_(CALLPASERSSIGNATURE, parserWhile, WHILE_BRANCH, &st,
+                                      "Command: call while\n");
             break;
         case MATHER_TRY :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserTry, TRY_BRANCH, &st, "Command: call try\n");
+            status = commandCallBack_(CALLPASERSSIGNATURE, parserTry, TRY_BRANCH, &st,
+                                      "Command: call try\n");
             break;
         case MATHER_BREAK :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeBreakStatement, BREAK, &st, "Command: call break\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeBreakStatement, BREAK, &st,
+                                         "Command: call break\n");
             break;
         case MATHER_CONTINUE :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeContinueStatement, CONTINUE, &st, "Command: call continue\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeContinueStatement, CONTINUE, &st,
+                                         "Command: call continue\n");
             break;
         case MATHER_RESTART :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRestartStatement, RESTART, &st, "Command: call restart\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRestartStatement, RESTART, &st,
+                                         "Command: call restart\n");
             break;
         case MATHER_REGO :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRegoStatement, REGO, &st, "Command: call rego\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRegoStatement, REGO, &st,
+                                         "Command: call rego\n");
             break;
         case MATHER_RETURN :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeReturnStatement, RETURN,  &st, "Command: call return\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeReturnStatement, RETURN,  &st,
+                                         "Command: call return\n");
             break;
         case MATHER_RAISE :
-            status = commandCallControl_(CALLPASERSSIGNATURE, makeRaiseStatement, RAISE,  &st, "Command: call raise\n");
+            status = commandCallControl_(CALLPASERSSIGNATURE, makeRaiseStatement, RAISE,  &st,
+                                         "Command: call raise\n");
             break;
         default :
-            status = commandCallBack_(CALLPASERSSIGNATURE, parserOperation, OPERATION, &st, "Command: call operation\n");
+            status = commandCallBack_(CALLPASERSSIGNATURE, parserOperation, OPERATION, &st,
+                                      "Command: call operation\n");
             break;
     }
     if (!status)
@@ -155,7 +163,8 @@ void parserCommand(PASERSSIGNATURE){
 }
 
 void parserControl(PASERSSIGNATURE, Statement *(*callBack)(Statement *), int type){
-    Statement *times = NULL, *st = NULL;
+    Statement *times = NULL;
+    Statement *st = NULL;
     delToken(pm);
     parserOperation(CALLPASERSSIGNATURE);
     if (!call_success(pm))
@@ -173,10 +182,11 @@ void parserControl(PASERSSIGNATURE, Statement *(*callBack)(Statement *), int typ
 }
 
 void parserIf(PASERSSIGNATURE){
-    struct Statement *st = NULL, *else_st = NULL, *finally_st = NULL;
+    Statement *st = NULL;
+    Statement *else_st = NULL;
+    Statement *finally_st = NULL;
     StatementList *sl = NULL;
     bool have_if = false;
-    // TODO-szh 设置重复警告 (添加PASS语句)
     again:
     switch (readBackToken(pm)) {
         case MATHER_IF:
@@ -258,7 +268,10 @@ void parserIf(PASERSSIGNATURE){
 }
 
 void parserWhile(PASERSSIGNATURE){
-    struct Statement *st = NULL, *else_st = NULL, *finally_st = NULL,*do_st = NULL;
+    Statement *st = NULL;
+    Statement *else_st = NULL;
+    Statement *finally_st = NULL;
+    Statement *do_st = NULL;
     StatementList *sl = NULL;
     bool have_while = false;
 
@@ -339,7 +352,10 @@ void parserWhile(PASERSSIGNATURE){
 }
 
 void parserTry(PASERSSIGNATURE){
-    struct Statement *st = NULL, *try_st = NULL, *else_st = NULL, *finally_st = NULL;
+    Statement *st = NULL;
+    Statement *try_st = NULL;
+    Statement *else_st = NULL;
+    Statement *finally_st = NULL;
     StatementList *sl = NULL;
 
     again:
@@ -426,16 +442,18 @@ bool parserParameter(ParserMessage *pm, Inter *inter, Parameter **pt, bool is_fo
                 int ass) {
     Parameter *new_pt = NULL;
     Token *tmp;
+    bool last_pt = false;
     enum {
         s_1,  // only_value模式
         s_2,  // name_value模式
         s_3,  // only_args模式
     } status;
+
     if (is_dict)
         status = s_2;  // is_formal关闭对only_value的支持
     else
         status = s_1;
-    bool last_pt = false;
+
     while (!last_pt){
         tmp = NULL;
         if (!is_dict && status != s_2 && checkToken_(pm, MATHER_MUL))  // is_formal关闭对*args的支持
@@ -452,31 +470,31 @@ bool parserParameter(ParserMessage *pm, Inter *inter, Parameter **pt, bool is_fo
         }
         tmp = popAheadToken(pm);
 
-        int pt_type = only_value;
+        int pt_type = value_par;
         if (status == s_1){
             if (!checkToken_(pm, sep)){
                 if (is_list || !checkToken_(pm, ass))  // // is_list关闭对name_value的支持
                     last_pt = true;
                 else {
-                    pt_type = name_value;
+                    pt_type = name_par;
                     status = s_2;
                 }
             }
         }
         else if (status == s_2){
-            pt_type = name_value;
+            pt_type = name_par;
             if (!checkToken_(pm, ass))
                 goto error_;
         }
         else if (status == s_3){
-            pt_type = only_args;
+            pt_type = args_par;
             if (!checkToken_(pm, sep))
                 last_pt = true;
         }
 
-        if (pt_type == only_value)
+        if (pt_type == value_par)
             new_pt = connectOnlyValueParameter(tmp->data.st, new_pt);
-        else if (pt_type == name_value){
+        else if (pt_type == name_par){
             Statement *tmp_value;
             if (!callChildStatement(CALLPASERSSIGNATURE, parserPolynomial, POLYNOMIAL, &tmp_value, "Don't get a parameter value"))
                 goto error_;
@@ -484,7 +502,7 @@ bool parserParameter(ParserMessage *pm, Inter *inter, Parameter **pt, bool is_fo
             if (!checkToken_(pm, sep))
                 last_pt = true;
         }
-        else if (pt_type == only_args){
+        else if (pt_type == args_par){
             new_pt = connectOnlyArgsParameter(tmp->data.st, new_pt);
             if (is_formal)
                 status = s_2;  // 是否规定*args只出现一次
@@ -504,11 +522,14 @@ bool parserParameter(ParserMessage *pm, Inter *inter, Parameter **pt, bool is_fo
 }
 
 void parserDef(PASERSSIGNATURE){
-    struct Statement *st = NULL, *name_tmp = NULL, *code_tmp = NULL;
+    Statement *st = NULL;
+    Statement *name_tmp = NULL;
+    Statement *code_tmp = NULL;
     Parameter *pt = NULL;
     delToken(pm);
 
-    if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &name_tmp, "Don't get a function name"))
+    if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &name_tmp,
+                            "Don't get a function name"))
         goto error_;
 
     if (!checkToken_(pm, MATHER_LP)) {
@@ -543,7 +564,8 @@ void parserDef(PASERSSIGNATURE){
 }
 
 void parserCode(PASERSSIGNATURE){
-    Token *code_token = NULL, *tk = NULL;
+    Token *code_token = NULL;
+    Token *tk = NULL;
     Statement *st = makeStatement();
     while (true){
         if (!checkToken_(pm, MATHER_LC))
@@ -576,6 +598,7 @@ void parserCode(PASERSSIGNATURE){
 
     error_:
     freeToken(code_token, true, true);
+    return;
 }
 
 /**
@@ -627,8 +650,8 @@ void parserAssignment(PASERSSIGNATURE){
  * @param inter
  */
 void parserTuple(PASERSSIGNATURE){
-    struct Parameter *pt = NULL;
-    struct Statement *st = NULL;
+    Parameter *pt = NULL;
+    Statement *st = NULL;
     Token *tmp = NULL;
     if (!callChildToken(CALLPASERSSIGNATURE, parserPolynomial, POLYNOMIAL, &tmp, NULL, syntax_error))
         goto return_;
@@ -701,7 +724,7 @@ void parserFactor(PASERSSIGNATURE){
 }
 
 int tailCall(PASERSSIGNATURE, Token *left_token, Statement **st){
-    struct Parameter *pt = NULL;
+    Parameter *pt = NULL;
     if (readBackToken(pm) != MATHER_LP)
         return -1;
     delToken(pm);
@@ -742,7 +765,7 @@ int getOperation(PASERSSIGNATURE, int right_type, Statement **st, char *name){
 void parserBaseValue(PASERSSIGNATURE){
     int token_type;
     Token *value_token = NULL;
-    struct Statement *st = NULL;
+    Statement *st = NULL;
     token_type = readBackToken(pm);
     if(MATHER_NUMBER == token_type){
         writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get number\n", NULL);

parser/lexical.c

@@ -6,7 +6,7 @@
  * @param file
  * @return 返回一个字符，若为EOF则返回-1
  */
-char readChar(LexFile *file){
+signed char readChar(LexFile *file){
     if (file->back.is_back){
         file->back.is_back = false;
     }
@@ -139,19 +139,15 @@ int checkoutMather(LexMathers *mathers, int max, FILE *debug) {
         }
         writeLog_(debug, LEXICAL_CHECKOUT_DEBUG,"mathers->mathers[%d]->status == %d\n", i, mathers->mathers[i]->status);
     }
-    if (return_1) {
+    if (return_1)
         goto return_;
-    }
 
-    if (mistake_count == max){
+    if (mistake_count == max)
         return -2;
-    }
-    else if(end_count == 1){
+    else if(end_count == 1)
         return end_index;
-    }
-    else if(end_second_count == 1){
+    else if(end_second_count == 1)
         return end_second_index;
-    }
 
     return_:
     return -1;

parser/syntax.c

@@ -12,7 +12,7 @@
  * @param p
  * @param mather
  */
-void numberMather(char p, LexMather *mather){
+void numberMather(signed char p, LexMather *mather){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING || mather->status == LEXMATHER_INGPOINT){
         if ('0'<= p && '9' >= p || '.' == p && mather->status == LEXMATHER_ING){
             mather->str = memStrcpy(mather->str, 1, true, true, p);
@@ -57,7 +57,7 @@ void numberMather(char p, LexMather *mather){
  * @param p
  * @param mather
  */
-void varMather(char p, LexMather *mather){
+void varMather(signed char p, LexMather *mather){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING){
         if ('A'<= p && 'Z' >= p ||'a'<= p && 'z' >= p ||'_' == p ||
             '0'<= p && '9' >= p && mather->status == LEXMATHER_ING){
@@ -85,7 +85,7 @@ void varMather(char p, LexMather *mather){
  * @param p
  * @param mather
  */
-void stringMather(char p, LexMather *mather){
+void stringMather(signed char p, LexMather *mather){
     if (mather->status == LEXMATHER_START){
         if ('\"' == p || '\'' == p){
             mather->status = LEXMATHER_ING;
@@ -137,7 +137,7 @@ void stringMather(char p, LexMather *mather){
  * @param mather
  * @param dest_p
  */
-void strMather(char p, LexMather *mather, const char *dest_p){
+void strMather(signed char p, LexMather *mather, const char *dest_p){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING){
         if (p == dest_p[mather->len]){
             mather->str = memStrcpy(mather->str, 1, true, true, p);
@@ -162,8 +162,8 @@ void strMather(char p, LexMather *mather, const char *dest_p){
  * @param mather
  * @param dest_p
  */
-void charMather(char p, LexMather *mather, char dest_p){
-    int tmp_p = (int)p, tmp_dest = (int)dest_p;
+void charMather(signed char p, LexMather *mather, signed char dest_p){
+    int tmp_p = (int)p, tmp_dest = (int)dest_p;  // TODO-szh 去除设定
     if (tmp_p == tmp_dest && mather->status == LEXMATHER_START){
         mather->str = memStrcpy(mather->str, 1, true, true, p);
         mather->len ++;
@@ -187,7 +187,7 @@ int getMatherStatus(LexFile *file, LexMathers *mathers, FILE *debug) {
     setupMathers(mathers);
     int status = -1;
     while (status == -1){
-        char p = readChar(file);
+        signed char p = readChar(file);
         if (p == EOF)
             writeLog_(debug, LEXICAL_DEBUG, "get char: (EOF)\n", NULL);
         else if (p == '\n')

parser/token.c

@@ -12,7 +12,7 @@ Token *makeToken(){
 }
 
 Token *makeLexToken(int type, char *str, char *second_str) {
-    struct Token *tmp = makeToken();
+    Token *tmp = makeToken();
     tmp->token_type = type;
     tmp->data.str = memStrcpy(str, 0, false, false);
     tmp->data.second_str = memStrcpy(second_str, 0, false, false);
@@ -20,7 +20,7 @@ Token *makeLexToken(int type, char *str, char *second_str) {
 }
 
 Token *makeStatementToken(int type, struct Statement *st){
-    struct Token *tmp = makeToken();
+    Token *tmp = makeToken();
     tmp->token_type = type;
     tmp->data.st = st;
     return tmp;

src/operation.c

@@ -58,7 +58,9 @@ Result operationStatement(INTER_FUNCTIONSIG) {
 }
 
 Result addOperation(INTER_FUNCTIONSIG) {
-    Result left, right, result;
+    Result left;
+    Result right;
+    Result result;
     setResultOperation(&result, inter);
     getresult(left, left, inter);
     getresult(right, right, inter);
@@ -75,7 +77,9 @@ Result addOperation(INTER_FUNCTIONSIG) {
 }
 
 Result subOperation(INTER_FUNCTIONSIG) {
-    Result left, right, result;
+    Result left;
+    Result right;
+    Result result;
     setResultOperation(&result, inter);
     getresult(left, left, inter);
     getresult(right, right, inter);
@@ -87,7 +91,9 @@ Result subOperation(INTER_FUNCTIONSIG) {
 }
 
 Result mulOperation(INTER_FUNCTIONSIG) {
-    Result left, right, result;
+    Result left;
+    Result right;
+    Result result;
     setResultOperation(&result, inter);
     getresult(left, left, inter);
     getresult(right, right, inter);
@@ -113,7 +119,9 @@ Result mulOperation(INTER_FUNCTIONSIG) {
 }
 
 Result divOperation(INTER_FUNCTIONSIG) {
-    Result left, right, result;
+    Result left;
+    Result right;
+    Result result;
     setResultOperation(&result, inter);
     getresult(left, left, inter);
     getresult(right, right, inter);
@@ -125,7 +133,8 @@ Result divOperation(INTER_FUNCTIONSIG) {
 }
 
 Result assOperation(INTER_FUNCTIONSIG) {
-    Result result, times;
+    Result result;
+    Result times;
     getresult(right, result, inter);
     times = assCore(st->u.operation.left, result.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     checkResult(times);
@@ -133,7 +142,8 @@ Result assOperation(INTER_FUNCTIONSIG) {
 }
 
 Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
-    Result result, times;
+    Result result;
+    Result times;
     setResult(&result, true, inter);
     int int_times;
     if (name->type == base_var){
@@ -154,7 +164,8 @@ Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
 }
 
 Result getBaseVar(INTER_FUNCTIONSIG) {
-    Result times, result;
+    Result result;
+    Result times;
     int int_times;
     setResultOperation(&result, inter);
 

src/parameter.c

@@ -60,7 +60,7 @@ void freeArgument(Argument *pt, bool free_st) {
 
 Parameter *makeParameter(){
     Parameter *tmp = memCalloc(1, sizeof(Parameter));
-    tmp->type = only_value;
+    tmp->type = value_par;
     tmp->data.value = NULL;
     tmp->data.name = NULL;
     tmp->next = NULL;
@@ -91,7 +91,7 @@ Parameter *makeOnlyValueParameter(Statement *st){
 
 Parameter *makeNameValueParameter(Statement *value, Statement *name){
     Parameter *tmp = makeParameter();
-    tmp->type = name_value;
+    tmp->type = name_par;
     tmp->data.value = value;
     tmp->data.name = name;
     return tmp;
@@ -99,7 +99,7 @@ Parameter *makeNameValueParameter(Statement *value, Statement *name){
 
 Parameter *makeOnlyArgsParameter(Statement *st){
     Parameter *tmp = makeParameter();
-    tmp->type = only_args;
+    tmp->type = args_par;
     tmp->data.value = st;
     return tmp;
 }
@@ -161,7 +161,7 @@ Argument *listToArgument(LinkValue *list_value, INTER_FUNCTIONSIG_CORE){
 Result defaultParameter(Parameter **function_ad, Inter *inter, VarList *var_list, int *num) {
     Parameter *function = *function_ad;
     Result result;
-    while (function != NULL && function->type == name_value){
+    while (function != NULL && function->type == name_par){
         Result tmp, tmp_ass;
         if(operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(function->data.value, var_list))) {
             *function_ad = function;
@@ -225,10 +225,10 @@ Result parameterFromVar(Parameter **function_ad, VarList *function_var, INTER_FU
     while (function != NULL){
         Result tmp, tmp_ass;
         get = true;
-        Statement *name = function->type == only_value ? function->data.value : function->data.name;
+        Statement *name = function->type == value_par ? function->data.value : function->data.name;
         if(operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(name, var_list))) {
             get = false;
-            if (function->type == name_value && !operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(function->data.value, var_list)))
+            if (function->type == name_par && !operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(function->data.value, var_list)))
                 goto not_return;
             *function_ad = function;
             return tmp;
@@ -262,9 +262,9 @@ Result argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList
     Argument *call = *call_ad;
     Parameter *function = *function_ad;
     Result result;
-    while (call != NULL && function != NULL && (call->type == value_arg) && function->type != only_args){
+    while (call != NULL && function != NULL && (call->type == value_arg) && function->type != args_par){
         Result tmp_ass;
-        Statement *name = function->type == only_value ? function->data.value : function->data.name;
+        Statement *name = function->type == value_par ? function->data.value : function->data.name;
         tmp_ass = assCore(name, call->data.value, CALL_INTER_FUNCTIONSIG_CORE(function_var));
         if (tmp_ass.type == error_return) {
             *call_ad = call;
@@ -296,11 +296,11 @@ Result iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_CORE
         if(operationSafeInterStatement(&tmp, CALL_INTER_FUNCTIONSIG(call->data.value, var_list)))
             return tmp;
 
-        if (call->type == only_value)
+        if (call->type == value_par)
             base = connectOnlyValueArgument(tmp.value, base);
-        else if (call->type == name_value)
+        else if (call->type == name_par)
             base = connectNameValueArgument(tmp.value, call->data.name, base);
-        else if (call->type == only_args){
+        else if (call->type == args_par){
             Argument *tmp_at = listToArgument(tmp.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
             base = connectArgument(tmp_at, base);
         }
@@ -351,11 +351,11 @@ Result setParameter(Parameter *call_base, Parameter *function_base, VarList *fun
     while (true){
         if (call == NULL && function == NULL)
             status = finished;
-        else if ((call != NULL && function == NULL) || (call == NULL && function != NULL && function->type == only_value))
+        else if ((call != NULL && function == NULL) || (call == NULL && function != NULL && function->type == value_par))
             status = error;
-        else if (call == NULL && function->type == name_value)  // 根据前面的条件, 已经决定function不会为NULL
+        else if (call == NULL && function->type == name_par)  // 根据前面的条件, 已经决定function不会为NULL
             status = default_status;
-        else if (function->type == only_args)
+        else if (function->type == args_par)
             status = mul_par;
         else if (call->type == value_arg)
             status = match_status;

src/runbranch.c

@@ -15,9 +15,12 @@ bool checkBool(Value *value){
 
 // TODO-szh 检查rego对else的支持
 Result ifBranch(INTER_FUNCTIONSIG) {
-    Result result, else_tmp, finally_tmp;
+    Result result;
+    Result else_tmp;
+    Result finally_tmp;
     StatementList *if_list = st->u.if_branch.if_list;
-    bool set_result = true, is_rego = false;
+    bool set_result = true;
+    bool is_rego = false;
 
     var_list = pushVarList(var_list, inter);
     while (if_list != NULL){
@@ -74,9 +77,12 @@ Result ifBranch(INTER_FUNCTIONSIG) {
 }
 
 Result whileBranch(INTER_FUNCTIONSIG) {
-    Result result, else_tmp, finally_tmp;
+    Result result;
+    Result else_tmp;
+    Result finally_tmp;
     StatementList *while_list = st->u.while_branch.while_list;
-    bool set_result = true, is_break = false;
+    bool set_result = true;
+    bool is_break = false;
 
     var_list = pushVarList(var_list, inter);
     while (!is_break){
@@ -134,7 +140,11 @@ Result whileBranch(INTER_FUNCTIONSIG) {
 }
 
 Result tryBranch(INTER_FUNCTIONSIG) {
-    Result result, try_result, except_result, else_tmp, finally_tmp;
+    Result result;
+    Result try_result;
+    Result except_result;
+    Result else_tmp;
+    Result finally_tmp;
     StatementList *except_list = st->u.try_branch.except_list;
     bool set_result = true;
 
@@ -174,7 +184,8 @@ Result tryBranch(INTER_FUNCTIONSIG) {
 }
 
 Result breakCycle(INTER_FUNCTIONSIG){
-    Result result, times;
+    Result result;
+    Result times;
     int times_int = 0;
     if (st->u.break_cycle.times == NULL)
         goto not_times;
@@ -192,7 +203,8 @@ Result breakCycle(INTER_FUNCTIONSIG){
 }
 
 Result continueCycle(INTER_FUNCTIONSIG){
-    Result result, times;
+    Result result;
+    Result times;
     int times_int = 0;
     if (st->u.continue_cycle.times == NULL)
         goto not_times;
@@ -209,7 +221,8 @@ Result continueCycle(INTER_FUNCTIONSIG){
 }
 
 Result regoIf(INTER_FUNCTIONSIG){
-    Result result, times;
+    Result result;
+    Result times;
     int times_int = 0;
     if (st->u.rego_if.times == NULL)
         goto not_times;
@@ -226,7 +239,8 @@ Result regoIf(INTER_FUNCTIONSIG){
 }
 
 Result restartCode(INTER_FUNCTIONSIG){
-    Result result, times;
+    Result result;
+    Result times;
     int times_int = 0;
     if (st->u.restart.times == NULL)
         goto not_times;

src/runcall.c

@@ -1,7 +1,8 @@
 #include "__run.h"
 
 Result setFunction(INTER_FUNCTIONSIG) {
-    Result result, tmp;
+    Result result;
+    Result tmp;
     setResultOperation(&tmp, inter);
 
     tmp.value->value = makeFunctionValue(st->u.set_function.function, st->u.set_function.parameter, var_list, inter);
@@ -10,7 +11,8 @@ Result setFunction(INTER_FUNCTIONSIG) {
 }
 
 Result callFunction(INTER_FUNCTIONSIG) {
-    Result call_function, result;
+    Result result;
+    Result call_function;
 
     if (operationSafeInterStatement(&call_function, CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list)))
         return call_function;

src/statement.c

@@ -7,10 +7,12 @@ Statement *makeStatement(){
     return tmp;
 }
 
-struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right) {
+Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right) {
     Token *new_token = NULL;
     Statement *st = *st_ad, *left_st = left->data.st;
-    if (is_right && left->data.st->type == operation && left_st->u.operation.OperationType == st->u.operation.OperationType){
+    if (is_right && left->data.st->type == operation &&
+        left_st->u.operation.OperationType == st->u.operation.OperationType){
+
         st->u.operation.left = left_st->u.operation.right;
         left_st->u.operation.right = st;
         st->u.operation.right = right->data.st;

src/value.c

@@ -47,9 +47,9 @@ Value *makeFunctionValue(Statement *st, Parameter *pt, VarList *var_list, Inter
     return tmp;
 }
 
-Value *makeListValue(Argument **ad_ad, Inter *inter, int type) {
+Value *makeListValue(Argument **arg_ad, Inter *inter, int type) {
     Value *tmp;
-    Argument *at = *ad_ad;
+    Argument *at = *arg_ad;
     tmp = makeValue(inter);
     tmp->type = list;
     tmp->data.list.type = type;
@@ -61,7 +61,7 @@ Value *makeListValue(Argument **ad_ad, Inter *inter, int type) {
         tmp->data.list.list[tmp->data.list.size - 1] = at->data.value;
         at = at->next;
     }
-    *ad_ad = at;
+    *arg_ad = at;
     return tmp;
 }
 
@@ -99,7 +99,8 @@ void freeValue(Value *value, Inter *inter){
 }
 
 LinkValue *makeLinkValue(Value *value, LinkValue *linkValue, Inter *inter){
-    LinkValue *tmp, *list_tmp = inter->link_base;
+    LinkValue *tmp;
+    LinkValue *list_tmp = inter->link_base;
     tmp = memCalloc(1, sizeof(Value));
     tmp->father = linkValue;
     tmp->value = value;

src/var.c

@@ -22,7 +22,8 @@ Var *freeVar(Var *var, bool self){
 }
 
 HashTable *makeHashTable(Inter *inter) {
-    HashTable *tmp, *list_tmp = inter->hash_base;
+    HashTable *list_tmp = inter->hash_base;
+    HashTable *tmp;
     tmp = memCalloc(1, sizeof(Value));
     tmp->hashtable = (Var **)calloc(MAX_SIZE, sizeof(Var *));
     tmp->next = NULL;
@@ -184,7 +185,8 @@ VarList *copyVarListCore(VarList *base, Inter *inter){
 }
 
 VarList *copyVarList(VarList *base, bool n_new, Inter *inter){
-    VarList *new, *tmp;
+    VarList *new;
+    VarList *tmp;
     new = tmp = copyVarListCore(base, inter);
     while (base->next != NULL){
         tmp->next = copyVarListCore(base->next, inter);