refactor: 把st从inter中提取出来

允许运行多段代码
parser关闭了log系统

CMakeLists.txt

@@ -14,6 +14,4 @@ AUX_SOURCE_DIRECTORY(${PROJECT_SOURCE_DIR}/gc GC_LIST)
 AUX_SOURCE_DIRECTORY(${PROJECT_SOURCE_DIR}/argument ARGUMENT_LIST)
 
 MESSAGE("project dir is ${PROJECT_SOURCE_DIR}")
-ADD_LIBRARY(VirtualMathCore STATIC ${SRC_LIST} ${GC_LIST} ${PASER_LIST} ${MEM_LIST} ${FILE_LIST} ${ARGUMENT_LIST})
-ADD_EXECUTABLE(VirtualMath main.c)
-TARGET_LINK_LIBRARIES(VirtualMath VirtualMathCore)
+ADD_EXECUTABLE(VirtualMath main.c ${SRC_LIST} ${GC_LIST} ${PASER_LIST} ${MEM_LIST} ${FILE_LIST} ${ARGUMENT_LIST})

argument/argument.c

@@ -1,26 +1,12 @@
 #include "__virtualmath.h"
 
 static const struct option long_option[]={
-        {"input",required_argument,NULL,'i'},
         {"stdout",no_argument,NULL,'s'},
-
-#if OUT_LOG
         {"log",required_argument,NULL,'l'},
-        {"debug",no_argument,&args.level,DEBUG},
-        {"ddebug",no_argument,&args.level,DEEP_DEBUG},
-        {"ldebug",no_argument,&args.level,LEXICAL_DEBUG},
-        {"lcdebug",no_argument,&args.level,LEXICAL_CHECKOUT_DEBUG},
-        {"info",no_argument,&args.level,INFO},
-#endif
-        // 最后一个元素应该全为0
         {NULL,0,NULL,0}
 };
 
-#if OUT_LOG
-static const char *short_option = "si:l:";
-#else
-const char *short_option = "si:";
-#endif
+static const char *short_option = "sl:";
 
 /**
  * 参数设置, args是全局结构体, 保存全局的参数设置
@@ -30,9 +16,7 @@ const char *short_option = "si:";
  */
 int getArgs(const int argc, char **argv)
 {
-    args.file = NULL;
     args.log_file = NULL;
-    args.level = LEXICAL_CHECKOUT_DEBUG;
     args.stdout_inter = false;
     opterr = false;
     int opt;
@@ -42,9 +26,6 @@ int getArgs(const int argc, char **argv)
         {
             case 0:
                 break;
-            case 'i':
-                args.file = memStrcpy(optarg);
-                break;
             case 'l':
                 args.log_file = memStrcpy(optarg);
                 break;
@@ -52,20 +33,12 @@ int getArgs(const int argc, char **argv)
                 args.stdout_inter = true;
                 break;
             case '?':
-                printf("[Error]: get not success args : -%c\n", (char)optopt);
+                fprintf(stderr, "[Error]: get not success args : -%c\n", (char)optopt);
                 return -1;
             default:
                 break;
         }
     }
-    if (args.file == NULL){
-        if (argc > optind){
-            args.file = memStrcpy(argv[optind]);
-        }
-        else{
-            return -1;
-        }
-    }
     return 0;
 }
 
@@ -73,6 +46,5 @@ int getArgs(const int argc, char **argv)
  * 释放args的成员而不包括其本身
  */
 void freeArgs(void){
-    memFree(args.file);
-    memFree(args.file);
+    memFree(args.log_file);
 }

include/__virtualmath.h

@@ -14,7 +14,6 @@
 #include "token.h"
 #include "syntax.h"
 #include "grammar.h"
-#include "log.h"
 #include "arguement.h"
 #include "file.h"
 
@@ -23,5 +22,4 @@ void printLinkValueGC(char *tag, Inter *inter);
 void printValueGC(char *tag, Inter *inter);
 void printVarGC(char *tag, Inter *inter);
 void printHashTableGC(char *tag, Inter *inter);
-void showLinkValue(struct LinkValue *base);
 #endif //VIRTUALMATH___VIRTUALMATH_H

include/arguement.h

@@ -2,15 +2,13 @@
 #define VIRTUALMATH_ARGUEMENT_H
 
 struct Args{
-    char *file;
     char *log_file;
-    int level;
     bool stdout_inter;
 } args;
 
 typedef struct Args Args;
 
-int getArgs(const int argc, char **argv);
+int getArgs(int argc, char **argv);
 void freeArgs(void);
 
 #endif //VIRTUALMATH_ARGUEMENT_H

include/grammar.h

@@ -4,9 +4,6 @@
 
 struct ParserMessage{
     struct TokenMessage *tm;
-    FILE *paser_debug;
-    FILE *grammar_debug;
-    int count;
     enum ParserMessageStatus{
         success = 1,
         syntax_error,
@@ -19,7 +16,7 @@ struct ParserMessage{
 
 typedef struct ParserMessage ParserMessage;
 
-ParserMessage *makeParserMessage(char *file_dir, char *debug);
+ParserMessage *makeParserMessage(char *file_dir);
 void freeParserMessage(ParserMessage *pm, bool self);
 void parserCommandList(ParserMessage *pm, Inter *inter, bool global, Statement *st);
 // PASERSSIGNATURE 位于__grammar

include/inter.h

@@ -9,7 +9,6 @@ struct Inter{
     struct HashTable *hash_base;
     struct Var *base_var;
 
-    struct Statement *statement;
     struct VarList *var_list;
     struct InterData{
         FILE *debug;
@@ -23,11 +22,13 @@ struct Inter{
 };
 
 typedef struct Inter Inter;
+typedef struct Statement Statement;
 
-Inter *makeInter(char *code_file, char *debug);
+Inter *makeInter(char *debug);
 void freeInter(Inter *inter, bool self, bool show_gc);
 void setBaseInterData(struct Inter *inter);
-Inter *newInter(char *code_file, char *debug_dir,struct Result *global_result, int *status);
-Inter *runBaseInter(char *code_file, char *debug_dir, int *status);
+int runCodeBlock(char *code_file, Inter *inter);
+void runParser(char *code_file, Inter *inter, Statement **st);
+void runCode(Statement *st, Inter *inter);
 void mergeInter(Inter *new, Inter *base);
 #endif //VIRTUALMATH_INTER_H

include/lexical.h

@@ -8,7 +8,6 @@ struct LexFile{
         bool is_back;
         int p;
     } back;
-    long int count;
     long int line;
 };
 
@@ -51,5 +50,5 @@ void freeMather(LexMather *mather, bool self);
 LexMathers *makeMathers(int size);
 void freeMathers(LexMathers *mathers, bool self);
 void setupMathers(LexMathers *mathers);
-int checkoutMather(LexMathers *mathers, int max, FILE *debug);
+int checkoutMather(LexMathers *mathers, int max);
 #endif //VIRTUALMATH_LEXICAL_H

include/log.h

@@ -1,63 +0,0 @@
-#ifndef VIRTUALMATH_LOG_H
-#define VIRTUALMATH_LOG_H
-#include "__macro.h"
-
-#define DEEP_DEBUG -3
-#define LEXICAL_CHECKOUT_DEBUG -3
-#define LEXICAL_DEBUG -2
-#define GRAMMAR_DEBUG -1
-#define DEBUG 0
-#define INFO 1
-#define WARNING 2
-#define ERROR 3
-
-#ifndef OUT_INTER_LOG
-#define OUT_INTER_LOG true
-#endif
-
-#ifndef OUT_TOKEN_LOG
-#define OUT_TOKEN_LOG true
-#endif
-
-#ifndef OUT_PASERS_LOG
-#define OUT_PASERS_LOG true
-#endif
-
-#ifndef OUT_GRAMMER_LOG
-#define OUT_GRAMMER_LOG true
-#endif
-
-#ifndef OUT_LOG
-#define OUT_LOG true
-#endif
-
-#if OUT_LOG
-#define writeLog(file, info_level, message, ...) do{ \
-if (file == NULL || info_level < args.level){ \
-break; \
-} \
-else{ \
-fprintf(file, message, __VA_ARGS__); \
-} \
-} while(0)
-
-#else
-/* 不输出日志 */
-#define writeLog(...) PASS
-#define doubleLog(...) PASS
-#endif
-
-#ifdef __unix__
-#define GRAMMAR_LOG "/grammar.log"
-#define PASERS_LOG "/pasers.log"
-#define LEXICAL_LOG "/lexical.log"
-#define INTER_LOG "/inter.log"
-#define INTER_ERROR "/error.log"
-#else
-#define GRAMMAR_LOG "\grammar.log"
-#define PASERS_LOG "\pasers.log"
-#define LEXICAL_LOG "\lexical.log"
-#define INTER_LOG "\inter.log"
-#define INTER_ERROR "\error.log"
-#endif
-#endif //VIRTUALMATH_LOG_H

include/run.h

@@ -13,7 +13,7 @@ typedef struct Parameter Parameter;
 
 typedef ResultType (*VarInfo)(char **name, int *times, INTER_FUNCTIONSIG);
 
-ResultType globalIterStatement(Inter *inter, Result *result, LinkValue *base_father);
+ResultType globalIterStatement(Result *result, LinkValue *base_father, Inter *inter, Statement *st);
 bool operationSafeInterStatement(INTER_FUNCTIONSIG);
 bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG);
 bool functionSafeInterStatement(INTER_FUNCTIONSIG);

include/statement.h

@@ -2,6 +2,8 @@
 #define VIRTUALMATH_STATEMENT_H
 #include "__macro.h"
 
+#define makeConnectStatementList(base, condition, var, code, type) connectStatementList(base, makeStatementList(condition, var, code, type))
+
 struct Statement{
     enum ValueAuthority aut;
     enum StatementType{
@@ -164,6 +166,7 @@ struct StatementList{
     struct StatementList *next;
 };
 
+typedef struct Token Token;
 typedef struct Statement Statement;
 typedef struct StatementList StatementList;
 
@@ -201,6 +204,5 @@ StatementList *makeStatementList(Statement *condition, Statement *var, Statement
 StatementList *connectStatementList(StatementList *base, StatementList *new);
 void freeStatementList(StatementList *base);
 StatementList *copyStatementList(StatementList *sl);
-#define makeConnectStatementList(base, condition, var, code, type) connectStatementList(base, makeStatementList(condition, var, code, type))
 
 #endif //VIRTUALMATH_STATEMENT_H

include/token.h

@@ -1,6 +1,8 @@
 #ifndef VIRTUALMATH_TOKEN_H
 #define VIRTUALMATH_TOKEN_H
 
+#include <__macro.h>
+
 #define MATHER_ERROR_ -1
 #define MATHER_NUMBER 0
 #define MATHER_STRING 1
@@ -126,7 +128,6 @@ struct Token{
         char *second_str;  // 针对123.4j这种形式设定的，其中second_str存储j
         struct Statement *st;
     } data;
-    struct Token *last;
     struct Token *next;
 };
 
@@ -139,14 +140,15 @@ struct TokenMessage{
     struct TokenStream *ts;
     struct LexFile *file;
     struct LexMathers *mathers;
-    FILE *debug;
 };
 
+typedef struct LexFile LexFile;
+typedef struct LexMathers LexMathers;
 typedef struct Token Token;
 typedef struct TokenStream TokenStream;
 typedef struct TokenMessage TokenMessage;
 
-TokenMessage *makeTokenMessage(char *file_dir, char *debug);
+TokenMessage *makeTokenMessage(char *file_dir);
 void freeTokenMessage(TokenMessage *tm, bool self, bool free_st);
 
 Token *makeToken(long int line);
@@ -154,12 +156,8 @@ long freeToken(Token *tk, bool self, bool free_st);
 Token *makeLexToken(int type, char *str, char *second_str, long int line);
 Token *makeStatementToken(int type, struct Statement *st);
 
-extern Token *getToken(LexFile *file, LexMathers *mathers, FILE *debug);
-void addBackToken(TokenStream *ts, Token *new_tk, FILE *debug);
-Token *popNewToken(TokenMessage *tm, FILE *debug);
-
-// token 可视化函数
-void printTokenStream(TokenStream *ts, FILE *debug, int type);
-void printToken(Token *tk, FILE *debug, int type);
+extern Token *getToken(LexFile *file, LexMathers *mathers);
+void addBackToken(TokenStream *ts, Token *new_tk);
+Token *popNewToken(TokenMessage *tm);
 
 #endif //VIRTUALMATH_TOKEN_H

include/virtualmath.h

@@ -1,12 +0,0 @@
-#ifndef VIRTUALMATH_VIRTUALMATH_H
-#define VIRTUALMATH_VIRTUALMATH_H
-#include "macro.h"
-#include "arguement.h"
-
-extern jmp_buf memVirtualMath_Env;
-extern bool memVirtualMathUseJmp;
-typedef struct Inter Inter;
-typedef struct Result Result;
-Inter *runBaseInter(char *code_file, char *debug_dir, int *status);
-void freeInter(Inter *inter, bool self, bool show_gc);
-#endif //VIRTUALMATH_VIRTUALMATH_H

main.c

@@ -1,8 +1,8 @@
-#include "virtualmath.h"
+#include "__virtualmath.h"
 
 int main(int argc, char *argv[]) {
-    Inter *global_inter = NULL;
-    int status = 1;
+    Inter *inter = NULL;
+
     memVirtualMathUseJmp = true;
     if (setjmp(memVirtualMath_Env) == -1)  // 遇到内存错误
         return 2;
@@ -10,15 +10,20 @@ int main(int argc, char *argv[]) {
     if (getArgs(argc, argv))
         goto args_error;
 
-    global_inter = runBaseInter(args.file, args.log_file, &status);
+    inter = makeInter(args.log_file);
+    for (int status=0; status == 0 && argv[optind] != NULL; optind++)
+        status = runCodeBlock(argv[optind], inter);
+    freeInter(inter, true, true);
 
-    freeInter(global_inter, true, true);
     args_error: freeArgs();
-    return status;
+    return 0;
 }
 
 
 /**
+ * TODO-szh 变量控制
+ * TODO-szh 断言
+ * TODO-szh 代码块
  * TODO-szh 类super语句
  * TODO-szh const声明
  * TODO-szh 生成语法树

parser/__grammar.c

@@ -23,26 +23,22 @@ inline void twoOperation(PASERSSIGNATURE, PasersFunction callBack, GetSymbolFunc
         long int line = 0;
 
         if (readBackToken(pm) != self_type){
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: call %s(left)\n", self_name, call_name);
+            
             if (!callChildStatement(CALLPASERSSIGNATURE, callBack, call_type, &st, NULL))
                 goto return_;
             addStatementToken(self_type, st, pm);
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG,
-                      "%s: get %s(left) success[push %s]\n", self_name, call_name, self_name);
             continue;
         }
-        left_token = popAheadToken(pm);
+        left_token = popNewToken(pm->tm);
         line = left_token->line;
 
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: call symbol\n", self_name);
+        
         if (getSymbol(CALLPASERSSIGNATURE, readBackToken(pm), &st))
             delToken(pm);
         else{
             backToken_(pm, left_token);
             goto return_;
         }
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG,
-                  "%s: get symbol success\n%s: call %s[right]\n", self_name, self_name, call_name);
 
         callBack(CALLPASERSSIGNATURE);  // 获得右值
         if (!call_success(pm) || readBackToken(pm) != call_type){  // 若非正确数值
@@ -51,15 +47,11 @@ inline void twoOperation(PASERSSIGNATURE, PasersFunction callBack, GetSymbolFunc
             freeStatement(st);
             goto return_;
         }
-        right_token = popAheadToken(pm);
+        right_token = popNewToken(pm->tm);
         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);
         is_right_ = is_right;  // 第一次is_right不生效
     }
-    return_:
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: return\n", self_name);
+    return_: return;
 }
 
 /**
@@ -81,15 +73,13 @@ inline void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction
         struct Statement *st = NULL;
 
         if (readBackToken(pm) != self_type){
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: call %s(left)\n", self_name, call_name);
+            
             if (!callChildStatement(CALLPASERSSIGNATURE, callBack, call_type, &st, NULL))
                 goto return_;
             addStatementToken(self_type, st, pm);
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG,
-                      "%s: get %s(left) success[push %s]\n", self_name, call_name, self_name);
             continue;
         }
-        left_token = popAheadToken(pm);
+        left_token = popNewToken(pm->tm);
 
         int tail_status = tailFunction(CALLPASERSSIGNATURE, left_token, &st);
         if (tail_status == -1){
@@ -103,10 +93,9 @@ inline void tailOperation(PASERSSIGNATURE, PasersFunction callBack, TailFunction
 
         addStatementToken(self_type, st, pm);
         freeToken(left_token, true, false);
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: call tail success\n", self_name);
+        
     }
-    return_:
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "%s: return\n", self_name);
+    return_: return;
 }
 
 /**
@@ -142,23 +131,15 @@ void syntaxError(ParserMessage *pm, int status, long int line, int num, ...) {
 }
 
 int readBackToken(ParserMessage *pm){
-    writeLog(pm->grammar_debug, GRAMMAR_DEBUG, "token operation number : %d\n", pm->count);
-    writeLog(pm->paser_debug, DEBUG, "\ntoken operation number : %d\n", pm->count);
-    pm->count ++;
-    Token *tmp = popNewToken(pm->tm, pm->paser_debug);
+    Token *tmp = popNewToken(pm->tm);
     if (tmp->token_type == -2){
         freeToken(tmp, true, false);
         syntaxError(pm, lexical_error, tmp->line, 1, "lexical make some error");
     }
-    addBackToken(pm->tm->ts, tmp, pm->paser_debug);
+    addBackToken(pm->tm->ts, tmp);
     return tmp->token_type;
 }
 
-Token *popAheadToken(ParserMessage *pm){
-    doubleLog(pm, GRAMMAR_DEBUG, DEBUG, "token operation number : %d\n", pm->count ++);
-    return popNewToken(pm->tm, pm->paser_debug);
-}
-
 bool checkToken(ParserMessage *pm, int type){
     if (readBackToken(pm) != type)
         return false;
@@ -168,20 +149,19 @@ bool checkToken(ParserMessage *pm, int type){
 
 bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st,
                          char *log_message, bool must_operation, char *error_message) {
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, log_message, NULL);
     Token *tmp_token = NULL;
     *st = NULL;
     parserControl(CALLPASERSSIGNATURE, callBack, type, must_operation, error_message);
     if (!call_success(pm) || readBackToken(pm) != type)
         return false;
-    tmp_token = popAheadToken(pm);
+    tmp_token = popNewToken(pm->tm);
     *st = tmp_token->data.st;
     freeToken(tmp_token, true, false);
     return true;
 }
 
 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);
 }
 
@@ -194,7 +174,7 @@ bool callParserCode(PASERSSIGNATURE, Statement **st, char *message, long int lin
             syntaxError(pm, syntax_error, line, 1, message);
         return false;
     }
-    tmp = popAheadToken(pm);
+    tmp = popNewToken(pm->tm);
     *st = tmp->data.st;
     freeToken(tmp, true, false);
     return true;
@@ -215,13 +195,13 @@ bool callChildToken(PASERSSIGNATURE, PasersFunction callBack, int type, Token **
     callBack(CALLPASERSSIGNATURE);
     if (!call_success(pm) || readBackToken(pm) != type) {
         if (message != NULL) {
-            *tmp = popAheadToken(pm);
+            *tmp = popNewToken(pm->tm);
             syntaxError(pm, error_type, (*tmp)->line, 1, message);
-            backToken_(pm ,(*tmp));
+            backToken_(pm, (*tmp));
         }
         return false;
     }
-    *tmp = popAheadToken(pm);
+    *tmp = popNewToken(pm->tm);
     return true;
 }
 
@@ -299,7 +279,7 @@ bool parserParameter(PASERSSIGNATURE, Parameter **pt, bool is_formal, bool is_li
             }
             break;
         }
-        tmp = popAheadToken(pm);
+        tmp = popNewToken(pm->tm);
 
         int pt_type = value_par;
         if (status == s_1){

parser/grammar.c

@@ -1,47 +1,20 @@
 #include "__grammar.h"
 
-ParserMessage *makeParserMessage(char *file_dir, char *debug){
+ParserMessage *makeParserMessage(char *file_dir) {
     ParserMessage *tmp = memCalloc(1, sizeof(ParserMessage));
     tmp->file = file_dir;
-    tmp->tm = makeTokenMessage(file_dir, debug);
+    tmp->tm = makeTokenMessage(file_dir);
     tmp->status = success;
     tmp->status_message = NULL;
-    tmp->count = 0;
-#if OUT_LOG
-    if (debug != NULL){
-        char *debug_dir = memStrcat(debug, PASERS_LOG, false, false), *grammar_dir = memStrcat(debug, GRAMMAR_LOG, false,
-                                                                                               false);
-        if (access(debug_dir, F_OK) != 0 || access(debug_dir, W_OK) == 0)
-            tmp->paser_debug = fopen(debug_dir, "w");
-        if (access(grammar_dir, F_OK) != 0 || access(debug_dir, W_OK) == 0)
-            tmp->grammar_debug = fopen(grammar_dir, "w");
-        memFree(debug_dir);
-        memFree(grammar_dir);
-    }
-    else{
-        tmp->paser_debug = NULL;
-        tmp->grammar_debug = NULL;
-    }
-#else
-    tmp->paser_debug = NULL;
-    tmp->grammar_debug = NULL;
-#endif
     return tmp;
 }
 
 void freeParserMessage(ParserMessage *pm, bool self) {
     freeBase(pm, return_);
     freeTokenMessage(pm->tm, true, true);
-#if OUT_LOG
-    if (pm->paser_debug != NULL)
-        fclose(pm->paser_debug);
-    if (pm->grammar_debug != NULL)
-        fclose(pm->grammar_debug);
-#endif
     memFree(pm->status_message);
-    if (self){
+    if (self)
         memFree(pm);
-    }
     return_:
     return;
 }
@@ -63,19 +36,16 @@ void parserCommandList(PASERSSIGNATURE, bool global, Statement *st) {
     while (true){
         token_type = readBackToken(pm);
         if (token_type == MATHER_EOF){
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: <EOF>\n", NULL);
             delToken(pm);
             goto return_;
         }
         else if (token_type == MATHER_ENTER || token_type == MATHER_SEMICOLON){
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: <ENTER>/<SEMICOLON>\n", NULL);
             delToken(pm);
             continue;
         }
         else{
             Token *command_token = NULL;
             int stop;
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: call command\n", NULL);
             if (!callChildToken(CALLPASERSSIGNATURE, parserCommand, COMMAND, &command_token, command_message, command_list_error))
                 goto return_;
 
@@ -90,18 +60,14 @@ void parserCommandList(PASERSSIGNATURE, bool global, Statement *st) {
                 else{
                     connectStatement(st, command_token->data.st);
                     freeToken(command_token, true, false);
-                    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG,
-                            "Command List: get command success[at !global end]\n", NULL);
                 }
                 goto return_;
             }
             connectStatement(st, command_token->data.st);
             freeToken(command_token, true, false);
-            writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: get command success\n", NULL);
         }
     }
-    return_:
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command List: return\n", NULL);
+    return_: return;
 }
 
 /**
@@ -195,9 +161,8 @@ void parserCommand(PASERSSIGNATURE){
     if (!status)
         goto return_;
     addStatementToken(COMMAND, st, pm);
-    return_:
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Command: get return\n", NULL);
-}
+    return_: return;
+    }
 
 /**
  * import 匹配
@@ -275,7 +240,7 @@ void parserControl(PASERSSIGNATURE, MakeControlFunction callBack, int type, bool
         syntaxError(pm, syntax_error, line, 1, message);
         goto return_;
     }
-    tmp = popAheadToken(pm);
+    tmp = popNewToken(pm->tm);
     opt = tmp->data.st;
     freeToken(tmp, true, false);
     st = callBack(opt, line, pm->file);
@@ -619,9 +584,6 @@ void parserDef(PASERSSIGNATURE){
         syntaxError(pm, syntax_error, line, 1, "Don't get a function/class ) after parameter");
         goto error_;
     }
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "parserDef: get function title success\n", NULL);
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "parserDef: call parserCode\n", NULL);
-
     if (!callParserCode(CALLPASERSSIGNATURE, &code_tmp, "Don't get a function code", line)) {
         syntaxError(pm, syntax_error, line, 1, "Don't get a function code");
         goto error_;
@@ -664,12 +626,10 @@ void parserCode(PASERSSIGNATURE) {
             goto return_;
     }
     st = makeStatement(line, pm->file);
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "parserCode: call parserCommandList\n", NULL);
     parserCommandList(CALLPASERSSIGNATURE, false, st);
     if (!call_success(pm))
         goto error_;
 
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "parserCode: call parserCommandList success\n", NULL);
     if (!checkToken(pm, MATHER_RC)) {
         syntaxError(pm, syntax_error, line, 1, "Don't get the }");  // 使用{的行号
         goto error_;
@@ -691,15 +651,11 @@ void parserCode(PASERSSIGNATURE) {
  */
 void parserOperation(PASERSSIGNATURE){
     Statement *operation_st = NULL;
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Operation: call assignment\n", NULL);
     if (!callChildStatement(CALLPASERSSIGNATURE, parserAssignment, ASSIGNMENT, &operation_st, NULL))
         goto return_;
 
     addStatementToken(OPERATION, operation_st, pm);
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Operation: get polynomial success\n", NULL);
-
     return_:
-    writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Operation: return\n", NULL);
     return;
 }
 
@@ -895,24 +851,20 @@ int getOperation(PASERSSIGNATURE, int right_type, Statement **st, char *name){
 }
 
 void parserBaseValue(PASERSSIGNATURE){
-    Token *value_token = popAheadToken(pm);
+    Token *value_token = popNewToken(pm->tm);
     Statement *st = NULL;
     if (MATHER_NUMBER == value_token->token_type){
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get number [%s]\n", value_token->data.str);
         st = makeBaseStrValueStatement(value_token->data.str, number_str, value_token->line, pm->file);
     }
     else if (MATHER_STRING == value_token->token_type){
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get string [%s]\n", value_token->data.str);
         Value *tmp_value = makeStringValue(value_token->data.str, inter);
         st = makeBaseStrValueStatement(value_token->data.str, string_str, value_token->line, pm->file);
     }
     else if (MATHER_VAR == value_token->token_type){
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get var [%s]\n", value_token->data.str);
         st = makeBaseVarStatement(value_token->data.str, NULL, value_token->line, pm->file);
     }
     else if (MATHER_SVAR == value_token->token_type){
         Statement *svar_st = NULL;
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: get super var\n", NULL);
         if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &svar_st, NULL)){
             freeToken(value_token, true, true);
             syntaxError(pm, syntax_error, value_token->line, 1, "Don't get super var after $");
@@ -923,8 +875,6 @@ void parserBaseValue(PASERSSIGNATURE){
     else if (MATHER_LB == value_token->token_type){
         int tmp;
         Statement *tmp_st = NULL;
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get operation\n", NULL);
-
         tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RB, &tmp_st, "base value");
         if (tmp == 0){
             freeToken(value_token, true, true);
@@ -936,11 +886,9 @@ void parserBaseValue(PASERSSIGNATURE){
             syntaxError(pm, syntax_error, value_token->line, 1, "Don't get ] from list/var");
             goto return_;
         }
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get operation success\n", NULL);
-
         if (MATHER_VAR == readBackToken(pm)){
             Token *var_token;
-            var_token = popAheadToken(pm);
+            var_token = popNewToken(pm->tm);
             st = makeBaseVarStatement(var_token->data.str, tmp_st, var_token->line, pm->file);
             freeToken(var_token, true, false);
         }
@@ -956,7 +904,6 @@ void parserBaseValue(PASERSSIGNATURE){
         }
     }
     else if (MATHER_LP == value_token->token_type){
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get operation\n", NULL);
         int tmp = getOperation(CALLPASERSSIGNATURE, MATHER_RP, &st, "base value");
         if (tmp == 0){
             freeToken(value_token, true, true);
@@ -970,7 +917,6 @@ void parserBaseValue(PASERSSIGNATURE){
         }
     }
     else if (MATHER_LC == value_token->token_type){
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "base value: get dict\n", NULL);
         Parameter *pt = NULL;
         if (!parserParameter(CALLPASERSSIGNATURE, &pt, false, false, true, MATHER_COMMA, MATHER_COLON)) {
             freeToken(value_token, true, true);
@@ -1009,7 +955,6 @@ void parserBaseValue(PASERSSIGNATURE){
         }
     }
     else{
-        writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "Base Value: else\n", NULL);
         backToken_(pm, value_token);
         goto return_;
     }

parser/include/__grammar.h

@@ -5,24 +5,9 @@
 #define PASERSSIGNATURE ParserMessage *pm, Inter *inter /*pasers函数的统一签名*/
 #define CALLPASERSSIGNATURE pm, inter /*pasers函数调用的统一实参*/
 
-#if OUT_LOG && OUT_PASERS_LOG
-#define doubleLog(pm, grammar_level, pasers_level, message, ...) do{ \
-writeLog(pm->grammar_debug, grammar_level, message, __VA_ARGS__); \
-writeLog(pm->paser_debug, pasers_level, "\n"message, __VA_ARGS__); \
-} while(0)
-#else
-#define doubleLog(...) PASS
-#endif
-
-#if OUT_LOG && OUT_GRAMMER_LOG
-#define writeLog_(...) writeLog(__VA_ARGS__)
-#else
-#define writeLog_(...) PASS
-#endif
-
-#define addStatementToken(type, st, pm) addBackToken(pm->tm->ts, makeStatementToken(type, st), pm->paser_debug)
-#define delToken(pm) (freeToken(popAheadToken(pm), true, false))
-#define backToken_(pm, token) addBackToken(pm->tm->ts, (token), pm->paser_debug)
+#define addStatementToken(type, st, pm) addBackToken(pm->tm->ts, makeStatementToken(type, st))
+#define delToken(pm) (freeToken(popNewToken(pm->tm), true, false))
+#define backToken_(pm, token) addBackToken(pm->tm->ts, (token))
 #define addLexToken(pm, type) backToken_(pm, makeLexToken(type, NULL, NULL, 0))
 #define addToken_ backToken_
 #define call_success(pm) (pm->status == success)
@@ -33,8 +18,7 @@ typedef Statement *(*MakeControlFunction)(Statement *, long int, char *);
 typedef int (*TailFunction)(PASERSSIGNATURE, Token *, Statement **);
 
 void parserCommand(PASERSSIGNATURE);
-void parserControl(PASERSSIGNATURE, MakeControlFunction callBack, int type, bool must_operation,
-                   char *message);
+void parserControl(PASERSSIGNATURE, MakeControlFunction callBack, int type, bool must_operation, char *message);
 void parserDef(PASERSSIGNATURE);
 void parserIf(PASERSSIGNATURE);
 void parserWhile(PASERSSIGNATURE);
@@ -53,7 +37,6 @@ void parserImport(PASERSSIGNATURE);
 void syntaxError(ParserMessage *pm, int status,long int line , int num, ...);
 
 int readBackToken(ParserMessage *pm);
-Token *popAheadToken(ParserMessage *pm);
 bool checkToken(ParserMessage *pm, int type);
 
 bool commandCallControl_(PASERSSIGNATURE, MakeControlFunction callBack, int type, Statement **st,

parser/include/__lexical.h

@@ -1,11 +0,0 @@
-#ifndef VIRTUALMATH___LEXICAL_H
-#define VIRTUALMATH___LEXICAL_H
-#include "__virtualmath.h"
-
-#if OUT_LOG && OUT_TOKEN_LOG
-#define writeLog_(...) writeLog(__VA_ARGS__)
-#else
-#define writeLog_(...) PASS
-#endif
-
-#endif //VIRTUALMATH___LEXICAL_H

parser/include/__syntax.h

@@ -1,12 +0,0 @@
-#ifndef VIRTUALMATH___SYNTAX_H
-#define VIRTUALMATH___SYNTAX_H
-#include "__virtualmath.h"
-
-#if OUT_LOG && OUT_TOKEN_LOG
-#define writeLog_(...) writeLog(__VA_ARGS__)
-#else
-#define writeLog_(...) PASS
-#undef printTokenEnter
-#define printTokenEnter(...) PASS
-#endif
-#endif //VIRTUALMATH___SYNTAX_H

parser/lexical.c

@@ -1,4 +1,4 @@
-#include "__lexical.h"
+#include "__virtualmath.h"
 
 /**
  * 从文件中读取一个字节，并处理is_back
@@ -30,7 +30,6 @@ LexFile *makeLexFile(char *dir){
     tmp->file = fopen(dir, "r");
     tmp->back.is_back = false;
     tmp->back.p = EOF;
-    tmp->count = 0;
     tmp->line = 1;
     return tmp;
 }
@@ -120,7 +119,7 @@ void setupMathers(LexMathers *mathers){
  * @param max
  * @return
  */
-int checkoutMather(LexMathers *mathers, int max, FILE *debug) {
+int checkoutMather(LexMathers *mathers, int max) {
     bool return_1 = false;
     int mistake_count = 0;
     int end_count = 0, end_index = -1;
@@ -140,7 +139,6 @@ int checkoutMather(LexMathers *mathers, int max, FILE *debug) {
         else{
             return_1 = true;
         }
-        writeLog_(debug, LEXICAL_CHECKOUT_DEBUG,"mathers->mathers[%d]->status == %d\n", i, mathers->mathers[i]->status);
     }
     if (return_1)
         goto return_;

parser/syntax.c

@@ -1,4 +1,4 @@
-#include "__syntax.h"
+#include "__virtualmath.h"
 
 /**
  * 匹配一个数字字面量
@@ -153,17 +153,11 @@ void charMather(int p, LexMather *mather, int dest_p){
  * @param mathers
  * @return
  */
-int getMatherStatus(LexFile *file, LexMathers *mathers, FILE *debug) {
+int getMatherStatus(LexFile *file, LexMathers *mathers) {
     setupMathers(mathers);
     int status = -1;
     while (status == -1){
         int p = readChar(file);
-        if (p == EOF)
-            writeLog_(debug, LEXICAL_DEBUG, "get char: (EOF)\n", NULL);
-        else if (p == '\n')
-            writeLog_(debug, LEXICAL_DEBUG, "get char: (\\n)\n", NULL);
-        else
-            writeLog_(debug, LEXICAL_DEBUG, "get char: '%c'\n", p);
         numberMather(p ,mathers->mathers[MATHER_NUMBER]);
         stringMather(p ,mathers->mathers[MATHER_STRING]);
         varMather(p ,mathers->mathers[MATHER_VAR]);
@@ -253,8 +247,7 @@ int getMatherStatus(LexFile *file, LexMathers *mathers, FILE *debug) {
         strMatherMacro(MATHER_RAISE, "raise");
         strMatherMacro(MATHER_FROM, "from");
 
-        status = checkoutMather(mathers, MATHER_MAX, debug);
-        writeLog_(debug, LEXICAL_DEBUG, "get status: %d\n", status);
+        status = checkoutMather(mathers, MATHER_MAX);
     }
     backChar(file);
     return status;
@@ -266,21 +259,16 @@ int getMatherStatus(LexFile *file, LexMathers *mathers, FILE *debug) {
  * @param mathers
  * @return
  */
-Token *getToken(LexFile *file, LexMathers *mathers, FILE *debug) {
+Token *getToken(LexFile *file, LexMathers *mathers) {
     int status = MATHER_SPACE;
     Token *tmp;
-    writeLog_(debug, DEBUG, "get token: [%ld]\n", file->count);
     while (status == MATHER_SPACE)
-        status = getMatherStatus(file, mathers, debug);
+        status = getMatherStatus(file, mathers);
     if (status == -2){
-        writeLog_(debug, ERROR, "lexical ERROR\n", NULL);
         tmp = makeLexToken(MATHER_ERROR_, NULL, NULL, file->line);
         goto return_;
     }
     tmp = makeLexToken(status, mathers->mathers[status]->str, mathers->mathers[status]->second_str, file->line);
-    printTokenEnter(tmp, debug, DEBUG, "new token: ");
-    writeLog_(debug, DEBUG, "\n", NULL);
     return_:
-    file->count ++;
     return tmp;
 }

parser/token.c

@@ -8,7 +8,6 @@ Token *makeToken(long int line) {
     tmp->data.second_str = NULL;
     tmp->line = line;
     tmp->next = NULL;
-    tmp->last = NULL;
     return tmp;
 }
 
@@ -63,24 +62,11 @@ void freeToekStream(TokenStream *ts, bool self, bool free_st) {
     return;
 }
 
-TokenMessage *makeTokenMessage(char *file_dir, char *debug) {
+TokenMessage *makeTokenMessage(char *file_dir) {
     TokenMessage *tm = memCalloc(1, sizeof(TokenMessage));
     tm->file = makeLexFile(file_dir);
     tm->mathers = makeMathers(MATHER_MAX);
     tm->ts = makeTokenStream();
-#if OUT_LOG
-    if (debug != NULL){
-        char *debug_dir = memStrcat(debug, LEXICAL_LOG, false, false);
-        if (access(debug_dir, F_OK) != 0 || access(debug_dir, W_OK) == 0)
-            tm->debug = fopen(debug_dir, "w");
-        memFree(debug_dir);
-    }
-    else{
-        tm->debug = NULL;
-    }
-#else
-    tm->debug = NULL;
-#endif
     return tm;
 }
 
@@ -88,13 +74,8 @@ void freeTokenMessage(TokenMessage *tm, bool self, bool free_st) {
     freeLexFile(tm->file, true);
     freeToekStream(tm->ts, true, free_st);
     freeMathers(tm->mathers, true);
-#if OUT_LOG
-    if (tm->debug != NULL)
-        fclose(tm->debug);
-#endif
-    if (self){
+    if (self)
         free(tm);
-    }
 }
 
 /**
@@ -102,17 +83,11 @@ void freeTokenMessage(TokenMessage *tm, bool self, bool free_st) {
  * @param ts
  * @param new_tk
  */
-void addBackToken(TokenStream *ts, Token *new_tk, FILE *debug) {
-    printTokenEnter(new_tk, debug, DEBUG, "add Token: ");
+void addBackToken(TokenStream *ts, Token *new_tk) {
     Token *tmp = ts->token_list;
-
     ts->token_list = new_tk;
     new_tk->next = tmp;
-    new_tk->last = NULL;
-    if (tmp != NULL)
-        tmp->last = new_tk;
     ts->size ++;
-    MACRO_printTokenStream(ts, debug, DEEP_DEBUG);
 }
 
 /**
@@ -120,61 +95,19 @@ void addBackToken(TokenStream *ts, Token *new_tk, FILE *debug) {
  * @param ts
  * @return
  */
-Token *popToken(TokenStream *ts, FILE *debug) {
+Token *popToken(TokenStream *ts) {
     Token *tmp = ts->token_list;
     ts->token_list = tmp->next;
     tmp->next = NULL;
-    tmp->last = NULL;
-    if (ts->token_list != NULL)
-        ts->token_list->last = NULL;
     ts->size --;
-    printTokenEnter(tmp, debug, DEBUG, "pop Token: ");
-    MACRO_printTokenStream(ts, debug, DEEP_DEBUG);
     return tmp;
 }
 
-Token *popNewToken(TokenMessage *tm, FILE *debug) {
+Token *popNewToken(TokenMessage *tm) {
     Token *tmp;
-    writeLog_(debug, DEBUG, "pop new token : ", NULL);
-    if (tm->ts->size == 0){
-        tmp = getToken(tm->file, tm->mathers, tm->debug);
-    }
-    else{
-        tmp = popToken(tm->ts, debug);
-    }
-    writeLog_(debug, DEBUG, "get token: %ld\nnew token: ", tm->file->count);
-    printToken(tmp, debug, DEBUG);
-    writeLog_(debug, DEBUG, "\n", NULL);
+    if (tm->ts->size == 0)
+        tmp = getToken(tm->file, tm->mathers);
+    else
+        tmp = popToken(tm->ts);
     return tmp;
-}
-
-void printToken(Token *tk, FILE *debug, int type) {
-    if (tk->token_type >= 0) {
-        char *tmp = tk->data.str, *second_tmp = tk->data.second_str;
-        if (tmp != NULL && !strcmp(tmp, "\n"))
-            tmp = "\\n";
-        if (second_tmp != NULL && !strcmp(second_tmp, "\n"))
-            second_tmp = "\\n";
-        if (tmp != NULL && tmp[0] == EOF)
-            tmp = "(EOF)";
-        writeLog_(debug, type, "<token str = ('%s','%s'), type = %d>", tmp, second_tmp, tk->token_type);
-    }
-    else{
-        writeLog_(debug, type, "<token statement, type = %d>", tk->token_type);
-    }
-
-}
-
-void printTokenStream(TokenStream *ts, FILE *debug, int type) {
-    writeLog_(debug, type, "token_list: ", NULL);
-    Token *tmp = ts->token_list;
-    int i = 0;
-    while (tmp != NULL){
-        if (i > 0)
-            writeLog_(debug, type, "-", NULL);
-        printToken(tmp, debug, type);
-        tmp = tmp->next;
-        i++;
-    }
-    writeLog_(debug, type, "\n", NULL);
 }

src/inter.c

@@ -1,57 +1,23 @@
 #include "__virtualmath.h"
 
-Inter *runBaseInter(char *code_file, char *debug_dir, int *status) {
-    Result global_result;
-    setResultCore(&global_result);
-    return newInter(code_file, debug_dir, &global_result, 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){
-        *status = 1;
-        return NULL;
-    }
-
-    if (checkFile(debug_dir) != 2)
-        debug_dir = NULL;
-
-    global_inter = makeInter(code_file, debug_dir);
-    pm = makeParserMessage(code_file, debug_dir);
-
-    parserCommandList(pm, global_inter, true, global_inter->statement);
-    if (pm->status != success){
-        writeLog(stderr, ERROR, "Syntax Error: %s\n", pm->status_message);
-        goto return_;
-    }
-
-    type = globalIterStatement(global_inter, global_result, NULL);
-    if (type == error_return)
-        printError(global_result, global_inter, true);
-
-    return_:
-    freeParserMessage(pm, true);
-    return global_inter;
-}
-
-Inter *makeInter(char *code_file, char *debug) {
+Inter *makeInter(char *debug) {
     Inter *tmp = memCalloc(1, sizeof(Inter));
+    Value *none_value = NULL;
     setBaseInterData(tmp);
     tmp->base = NULL;
     tmp->link_base = NULL;
     tmp->hash_base = NULL;
     tmp->base_var = NULL;
 
-    tmp->statement = makeStatement(0, code_file);
     tmp->var_list = makeVarList(tmp);
     tmp->data.log_dir = memStrcpy(debug);
 
     if (debug != NULL && !args.stdout_inter){
-        char *debug_dir = memStrcat(debug, INTER_LOG, false, false), *error_dir = memStrcat(debug, INTER_ERROR, false, false);
+#ifdef __unix__
+        char *debug_dir = memStrcat(debug, "/inter.log", false, false), *error_dir = memStrcat(debug, "/inter_error.log", false, false);
+#else // __unix__
+        char *debug_dir = memStrcat(debug, "\inter.log", false, false), *error_dir = memStrcat(debug, "\inter_error.log", false, false);
+#endif // __unix__
         tmp->data.debug = fopen(debug_dir, "w");
         tmp->data.error = fopen(error_dir, "w");
         memFree(debug_dir);
@@ -61,8 +27,7 @@ Inter *makeInter(char *code_file, char *debug) {
         tmp->data.debug = stdout;
         tmp->data.error = stderr;
     }
-
-    Value *none_value = makeNoneValue(tmp);  // 注册None值
+    none_value = makeNoneValue(tmp);  // 注册None值
     gc_addStatementLink(&none_value->gc_status);
     return tmp;
 }
@@ -101,29 +66,47 @@ void freeInter(Inter *inter, bool self, bool show_gc) {
             PASS;
     }
 
-    freeStatement(inter->statement);  // Statement放在Value前面释放, 因为base_value的释放需要处理gc_status
     freeVarList(inter->var_list, true);
-
+    freeBaseInterData(inter);
     while (inter->base != NULL)
         freeValue(&inter->base);
-
     while (inter->base_var != NULL)
         freeVar(&inter->base_var);
-
     while (inter->link_base != NULL)
         freeLinkValue(&inter->link_base);
-
     while (inter->hash_base != NULL)
         freeHashTable(&inter->hash_base);
-
-    freeBaseInterData(inter);
-
     if (self)
         memFree(inter);
     return_:
     return;
 }
 
+void mergeInter(Inter *new, Inter *base){
+    Value **base_value = NULL;
+    LinkValue **base_linkValue = NULL;
+    HashTable **base_hash = NULL;
+    Var **base_var = NULL;
+
+    for (base_value = &base->base; *base_value != NULL; base_value = &(*base_value)->gc_next)
+            PASS;
+    for (base_linkValue = &base->link_base; *base_linkValue != NULL; base_linkValue = &(*base_linkValue)->gc_next)
+            PASS;
+    for (base_hash = &base->hash_base; *base_hash != NULL; base_hash = &(*base_hash)->gc_next)
+            PASS;
+    for (base_var = &base->base_var; *base_var != NULL; base_var = &(*base_var)->gc_next)
+            PASS;
+
+    *base_value = new->base;
+    *base_linkValue = new->link_base;
+    *base_hash = new->hash_base;
+    *base_var = new->base_var;
+
+    freeVarList(new->var_list, true);
+    freeBaseInterData(new);
+    memFree(new);
+}
+
 /* ***********************DEBUG 专用函数*********************************** */
 
 void printLinkValueGC(char *tag, Inter *inter){
@@ -183,39 +166,4 @@ void printHashTableGC(char *tag, Inter *inter){
         base = base->gc_next;
     }
     printf("printHashTableGC TAG : END\n");
-}
-
-void showLinkValue(struct LinkValue *base){
-    printf("tmp_link       = %ld :: %p\n", base->gc_status.tmp_link, base);
-    printf("statement_link = %ld :: %p\n", base->gc_status.statement_link, base);
-    printf("link           = %ld :: %p\n", base->gc_status.link, base);
-    printLinkValue(base, "value = ", "\n", stdout);
-    printf("--------------------------\n");
-}
-
-void mergeInter(Inter *new, Inter *base){
-    Value **base_value = NULL;
-    LinkValue **base_linkValue = NULL;
-    HashTable **base_hash = NULL;
-    Var **base_var = NULL;
-
-    for (base_value = &base->base; *base_value != NULL; base_value = &(*base_value)->gc_next)
-        PASS;
-    for (base_linkValue = &base->link_base; *base_linkValue != NULL; base_linkValue = &(*base_linkValue)->gc_next)
-        PASS;
-    for (base_hash = &base->hash_base; *base_hash != NULL; base_hash = &(*base_hash)->gc_next)
-        PASS;
-    for (base_var = &base->base_var; *base_var != NULL; base_var = &(*base_var)->gc_next)
-        PASS;
-
-    *base_value = new->base;
-    *base_linkValue = new->link_base;
-    *base_hash = new->hash_base;
-    *base_var = new->base_var;
-
-    new->base = NULL;
-    new->link_base = NULL;
-    new->hash_base = NULL;
-    new->base_var = NULL;
-    freeInter(new, true, false);
-}
+}

src/parameter.c

@@ -554,7 +554,6 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
             }
             case error:
             error_:  // Statement 处理
-                writeLog(inter->data.debug, ERROR, "setParameter error\n", NULL);
                 setResultError(result, inter, "ArgumentException", "Set Argument error", 0, father, true);
                 goto return_;
             default:

src/run.c

@@ -125,14 +125,14 @@ ResultType iterStatement(INTER_FUNCTIONSIG) {
  * @param inter
  * @return
  */
-ResultType globalIterStatement(Inter *inter, Result *result, LinkValue *base_father) {
+ResultType globalIterStatement(Result *result, LinkValue *base_father, Inter *inter, Statement *st) {
     LinkValue *father = makeLinkValue(makeObject(inter, copyVarList(inter->var_list, false, inter), NULL, NULL), base_father, inter);
     Statement *base_st = NULL;
     VarList *var_list = NULL;
     enum ResultType type;
 
     do {
-        for (base_st = inter->statement, var_list = inter->var_list; base_st != NULL; base_st = base_st->next) {
+        for (base_st = st, 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, father));
             if (!run_continue_type(type))

src/runfile.c

@@ -23,7 +23,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
     }
 
     new_st = makeStatement(0, file_dir);
-    pm = makeParserMessage(file_dir, NULL);
+    pm = makeParserMessage(file_dir);
     parserCommandList(pm, inter, true, new_st);
     if (pm->status != success){
         setResultError(result, inter, "IncludeSyntaxException", pm->status_message, st, father, true);
@@ -43,6 +43,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
 ResultType importFileCore(VarList **new_object, char **file_dir, INTER_FUNCTIONSIG) {
     Inter *import_inter = NULL;
     ParserMessage *pm = NULL;
+    Statement *run_st = NULL;
     setResultCore(result);
     if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
         goto return_;
@@ -59,27 +60,32 @@ ResultType importFileCore(VarList **new_object, char **file_dir, INTER_FUNCTIONS
         goto return_;
     }
 
-    import_inter = makeInter(*file_dir, NULL);
-    pm = makeParserMessage(*file_dir, NULL);
-    parserCommandList(pm, import_inter, true, import_inter->statement);
+
+    import_inter = makeInter(NULL);
+    pm = makeParserMessage(*file_dir);
+    run_st = makeStatement(0, *file_dir);
+    parserCommandList(pm, import_inter, true, run_st);
     if (pm->status != success) {
         freeInter(import_inter, true, false);
         setResultError(result, inter, "ImportSyntaxException", pm->status_message, st, father, true);
         goto return_;
     }
-    globalIterStatement(import_inter, result, father);
+
+    globalIterStatement(result, father, import_inter, run_st);
     if (!run_continue(result)) {
         freeInter(import_inter, true, false);
         result->value = makeLinkValue(inter->base, father, inter);  // 重新设定none值
         setResultError(result, inter, NULL, NULL, st, father, false);
         goto return_;
     }
+
     *new_object = import_inter->var_list;
     import_inter->var_list = NULL;
     mergeInter(import_inter, inter);
     setResult(result, inter, father);
 
     return_:
+    freeStatement(run_st);
     freeParserMessage(pm, true);
     return result->type;
 }

src/value.c

@@ -246,53 +246,53 @@ void freeResultSave(Result *ru){
 void printValue(Value *value, FILE *debug){
     switch (value->type){
         case number:
-            writeLog(debug, INFO, "%"NUMBER_FORMAT"", value->data.num.num);
+            fprintf(debug, "%"NUMBER_FORMAT"", value->data.num.num);
             break;
         case string:
-            writeLog(debug, INFO, "'%s'", value->data.str.str);
+            fprintf(debug, "'%s'", value->data.str.str);
             break;
         case function:
-            writeLog(debug, INFO, "function on <%p>", value);
+            fprintf(debug, "function on <%p>", value);
             break;
         case list:
-            writeLog(debug, INFO, "list on <%p> size : %d  [ ", value, (int)value->data.list.size);
+            fprintf(debug, "list on <%p> size : %d  [ ", value, (int)value->data.list.size);
             for (int i=0;i < value->data.list.size;i++){
                 if (i > 0)
-                    writeLog(debug, INFO, ", ", NULL);
+                    fprintf(debug, ", ", NULL);
 
                 printLinkValue(value->data.list.list[i], "", "", debug);
             }
-            writeLog(debug, INFO, " ]", NULL);
+            fprintf(debug, " ]", 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);
+            fprintf(debug, "dict on <%p> size : %d  { ", value, (int) value->data.dict.size);
             for (int i = 0; i < MAX_SIZE; i++) {
                 for (tmp = value->data.dict.dict->hashtable[i]; tmp != NULL; tmp = tmp->next) {
                     if (print_comma)
-                        writeLog(debug, INFO, ", ", NULL);
+                        fprintf(debug, ", ", NULL);
                     else
                         print_comma = true;
                     printLinkValue(tmp->name_, "", "", debug);
-                    writeLog(debug, INFO, " ['%s'] : ", tmp->name);
+                    fprintf(debug, " ['%s'] : ", tmp->name);
                     printLinkValue(tmp->value, "", "", debug);
                 }
             }
-            writeLog(debug, INFO, " }", NULL);
+            fprintf(debug, " }", NULL);
             break;
         }
         case none:
-            writeLog(debug, INFO, "<None>", NULL);
+            fprintf(debug, "<None>", NULL);
             break;
         case class:
-            writeLog(debug, INFO, "class on <%p>", value);
+            fprintf(debug, "class on <%p>", value);
             break;
         case object_:
-            writeLog(debug, INFO, "object on <%p>", value);
+            fprintf(debug, "object on <%p>", value);
             break;
         default:
-            writeLog(debug, INFO, "default on <%p>", value);
+            fprintf(debug, "default on <%p>", value);
             break;
     }
 }
@@ -300,14 +300,14 @@ void printValue(Value *value, FILE *debug){
 void printLinkValue(LinkValue *value, char *first, char *last, FILE *debug){
     if (value == NULL)
         return;
-    writeLog(debug, INFO, "%s", first);
+    fprintf(debug, "%s", first);
     if (value->father != NULL) {
         printLinkValue(value->father, "", "", debug);
-        writeLog(debug, INFO, " . ", NULL);
+        fprintf(debug, " . ", NULL);
     }
     if (value->value != NULL)
         printValue(value->value, debug);
-    writeLog(debug, INFO, "%s", last);
+    fprintf(debug, "%s", last);
 }
 
 Error *makeError(char *type, char *message, long int line, char *file) {
@@ -339,12 +339,10 @@ void freeError(Result *base){
 
 void printError(Result *result, Inter *inter, bool free) {
     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);
-        }
+        if (base->next != NULL)
+            fprintf(inter->data.error, "Error Backtracking:  On Line: %ld In file: %s Error ID: %p\n", base->line, base->file, base);
+        else
+            fprintf(inter->data.error, "%s\n%s\nOn Line: %ld\nIn File: %s\nError ID: %p\n", base->type, base->messgae, base->line, base->file, base);
     }
     if (free)
         freeError(result);

src/virtualmath.c

@@ -0,0 +1,35 @@
+#include "__virtualmath.h"
+
+int runCodeBlock(char *code_file, Inter *inter) {
+    Statement *pst = NULL;
+    if (checkFile(code_file) != 1)
+        return -1;
+    runParser(code_file, inter, &pst);
+    if (pst != NULL) {
+        runCode(pst, inter);
+        freeStatement(pst);
+    }
+    return 0;
+}
+
+void runParser(char *code_file, Inter *inter, Statement **st) {
+    ParserMessage *pm = makeParserMessage(code_file);
+    *st = makeStatement(0, code_file);
+    parserCommandList(pm, inter, true, *st);
+    if (pm->status != success) {
+        fprintf(stderr, "Syntax Error: %s\n", pm->status_message);
+        freeStatement(*st);
+        *st = NULL;
+    }
+    freeParserMessage(pm, true);
+}
+
+void runCode(Statement *st, Inter *inter) {
+    Result result;
+    ResultType type;
+    setResultCore(&result);
+    type = globalIterStatement(&result, NULL, inter, st);
+    if (type == error_return)
+        printError(&result, inter, true);
+    freeResult(&result);
+}