feat: 添加数字类型

取消NUMBER_TYPE宏, 使用类型vnum
同时为行文件使用类型fline

gc/gc.c

@@ -119,7 +119,7 @@ void gc_runDelAll(Inter *inter){
         gc_addTmpLink(&value->gc_status);
         if (needDel(value, inter)) {
             callDel(value, &result, inter, inter->var_list);
-            if (!run_continue_type(result.type))
+            if (!RUN_TYPE(result.type))
                 printError(&result, inter, true);
         }
         gc_freeTmpLink(&value->gc_status);
@@ -134,7 +134,7 @@ void gc_runDel(Inter *inter, VarList *var_list){
         if (value->gc_status.c_value == run_del) {
             gc_addTmpLink(&value->gc_status);
             callDel(value, &result, inter, var_list);
-            if (!run_continue_type(result.type))
+            if (!RUN_TYPE(result.type))
                 printError(&result, inter, true);
             gc_freeTmpLink(&value->gc_status);
             value->gc_status.c_value = need_free;

include/__macro.h

@@ -5,9 +5,10 @@
 // PASS语句的定义
 #define PASS
 
-#define NUMBER_TYPE long int
-#define NUMBER_FORMAT "ld"
-#define HASH_INDEX unsigned int
+#define RUN_TYPE(type) (type == not_return || type == operation_return)
+#define CHECK_RESULT(result) (result->type == not_return || result->type == operation_return)
+
+#define FREE_BASE(element, return_) do{if(element == NULL)goto return_;}while(0)
 
 #define INTER_FUNCTIONSIG_CORE struct Inter *inter, struct VarList *var_list
 #define INTER_FUNCTIONSIG_NOT_ST struct LinkValue *belong, struct Result *result, INTER_FUNCTIONSIG_CORE
@@ -17,13 +18,13 @@
 #define CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong) belong, result, CALL_INTER_FUNCTIONSIG_CORE(var_list)
 #define CALL_INTER_FUNCTIONSIG(st, var_list, result, belong) st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong)
 
-#define run_continue_type(type) (type == not_return || type == operation_return)
-#define run_continue(result) (result->type == not_return || result->type == operation_return)
+#define OFFICAL_FUNCTIONSIG struct Argument *arg, INTER_FUNCTIONSIG_NOT_ST
+#define CALL_OFFICAL_FUNCTION(arg, var_list, result, belong) arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong)
+#define REGISTERED_FUNCTIONSIG struct LinkValue *belong, INTER_FUNCTIONSIG_CORE
+#define CALL_REGISTERED_FUNCTION(belong, var_list) belong, CALL_INTER_FUNCTIONSIG_CORE(var_list)
 
-#define freeBase(element, return_) do{if(element == NULL)goto return_;}while(0)
+typedef long long vnum;
+typedef unsigned long long vhashn;
+typedef unsigned long long fline;
 
-#define OfficialFunctionSig struct Argument *arg, INTER_FUNCTIONSIG_NOT_ST
-#define CALL_OfficialFunction(arg, var_list, result, belong) arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong)
-#define RegisteredFunctionSig struct LinkValue *belong, INTER_FUNCTIONSIG_CORE
-#define CALL_RegisteredFunction(belong, var_list) belong, CALL_INTER_FUNCTIONSIG_CORE(var_list)
 #endif //VIRTUALMATH___MACRO_H

include/__virtualmath.h

@@ -2,21 +2,24 @@
 #define VIRTUALMATH___VIRTUALMATH_H
 
 #include "__macro.h"
+
 #include "mem.h"
+#include "arguement.h"
+#include "file.h"
+
 #include "gc.h"
-#include "inter.h"
 #include "value.h"
-#include "var.h"
 #include "parameter.h"
 #include "statement.h"
+#include "var.h"
+#include "inter.h"
 #include "ofunc.h"
 #include "run.h"
+
 #include "lexical.h"
 #include "token.h"
 #include "syntax.h"
 #include "grammar.h"
-#include "arguement.h"
-#include "file.h"
 
 #define DEBUG 1
 #if DEBUG

include/gc.h

@@ -1,8 +1,14 @@
 #ifndef VIRTUALMATH_GC_H
 #define VIRTUALMATH_GC_H
-
 #define START_GC true
 
+struct Inter;
+struct Value;
+struct LinkValue;
+struct HashTable;
+struct Var;
+struct VarList;
+
 struct GCStatus{
     long int tmp_link;  // tmp link的次数
     long int statement_link;  // statement link的次数
@@ -16,13 +22,6 @@ struct GCStatus{
 };
 
 typedef struct GCStatus GCStatus;
-struct Inter;
-struct Value;
-struct LinkValue;
-struct HashTable;
-struct Var;
-struct VarList;
-
 
 void resetGC(GCStatus *gcs);
 void setGC(GCStatus *gcs);

include/mem.h

@@ -9,9 +9,9 @@ extern bool memVirtualMathUseJmp;
 void *memCalloc(size_t num, size_t size);
 void *memRealloc(void *old, size_t size);
 char *memStrcpy(const char *str);
-char *memStrCharcpy(char *str, size_t nsize, int free_old, int write, ...);
+char *memStrCharcpy(char *str, size_t nsize, bool free_old, bool write, ...);
 char *memStrcat(char *first, char *second, bool free_first, bool free_last);
-char *memStrcpySelf(char *str, NUMBER_TYPE times);
+char *memStrcpySelf(char *str, long times);
 char *memStrrev(const char *str);
 
 #define memFree(p) ((p)=((p) != NULL ? (free(p), NULL) : NULL))

include/parameter.h

@@ -78,15 +78,15 @@ void freeParameter(Parameter *pt, bool free_st);
 Argument *listToArgument(LinkValue *list_value, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 
-ResultType setParameterCore(long int line, char *file, Argument *call, Parameter *function_base, VarList *function_var, INTER_FUNCTIONSIG_NOT_ST);
-ResultType setParameter(long int line, char *file, Parameter *call_base, Parameter *function_base, VarList *function_var, LinkValue *function_father, INTER_FUNCTIONSIG_NOT_ST);
+ResultType setParameterCore(fline line, char *file, Argument *call, Parameter *function_base, VarList *function_var, INTER_FUNCTIONSIG_NOT_ST);
+ResultType setParameter(fline line, char *file, Parameter *call_base, Parameter *function_base, VarList *function_var, LinkValue *function_father, INTER_FUNCTIONSIG_NOT_ST);
 ResultType iterParameter(Parameter *call, Argument **base_ad, bool is_dict, INTER_FUNCTIONSIG_NOT_ST);
 Argument *getArgument(Parameter *call, bool is_dict, INTER_FUNCTIONSIG_NOT_ST);
 
-ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST);
-ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST);
-ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMBER_TYPE *num, NUMBER_TYPE max, bool *status,
-                        INTER_FUNCTIONSIG_NOT_ST);
+ResultType defaultParameter(Parameter **function_ad, vnum *num, INTER_FUNCTIONSIG_NOT_ST);
+ResultType argumentToVar(Argument **call_ad, vnum *num, INTER_FUNCTIONSIG_NOT_ST);
+ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, vnum *num, vnum max, bool *status,
+                            INTER_FUNCTIONSIG_NOT_ST);
 ResultType argumentToParameter(Argument **call_ad, Parameter **function_ad, VarList *function_var, INTER_FUNCTIONSIG_NOT_ST);
 
 Inherit *setFatherCore(Inherit *father_tmp);

include/run.h

@@ -2,8 +2,6 @@
 #define VIRTUALMATH_RUN_H
 #include "__macro.h"
 
-enum StatementInfoStatus;
-struct Argument;
 typedef struct Result Result;
 typedef enum ResultType ResultType;
 typedef struct LinkValue LinkValue;
@@ -15,6 +13,7 @@ typedef struct VarList VarList;
 typedef struct Parameter Parameter;
 typedef struct Argument Argument;
 typedef struct DecorationStatement DecorationStatement;
+
 typedef ResultType (*VarInfo)(char **name, int *times, INTER_FUNCTIONSIG);
 
 ResultType globalIterStatement(Result *result, Inter *inter, Statement *st);
@@ -33,10 +32,10 @@ ResultType setLambda(INTER_FUNCTIONSIG);
 ResultType callBack(INTER_FUNCTIONSIG);
 ResultType elementSlice(INTER_FUNCTIONSIG);
 
-ResultType callBackCore(LinkValue *function_value, Argument *arg, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType callBackCore(LinkValue *function_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType callBackCorePt(LinkValue *function_value, Parameter *pt, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-ResultType callClass(LinkValue *class_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-ResultType callObject(LinkValue *object_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType callClass(LinkValue *class_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType callObject(LinkValue *object_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType callVMFunction(LinkValue *function_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType callCFunction(LinkValue *function_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 

include/statement.h

@@ -2,8 +2,6 @@
 #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{
@@ -221,7 +219,7 @@ struct Statement{
             } for_;
         } branch;
     } info;
-    long int line;
+    fline line;
     char *code_file;
     struct Statement *next;
 };
@@ -233,6 +231,7 @@ struct StatementList{
         while_b,
         except_b,
         for_b,
+        with_b,
     } type;
     struct Statement *condition;
     struct Statement *var;
@@ -291,7 +290,7 @@ Statement *makeFromImportStatement(Statement *file, Parameter *as, Parameter *pt
 Statement *makeDefaultVarStatement(Parameter *var, long int line, char *file_dir, enum DefaultType type);
 Statement *makeLabelStatement(Statement *var, Statement *command, char *label, long int line, char *file_dir);
 Statement *makeGotoStatement(Statement *return_, Statement *times, Statement *label, long int line, char *file_dir);
-struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, enum OperationType type, bool is_right);
+Token *setOperationFromToken(Statement **st_ad, Token *left, Token *right, enum OperationType type, bool is_right);
 
 StatementList *makeStatementList(Statement *condition, Statement *var, Statement *code, int type);
 StatementList *connectStatementList(StatementList *base, StatementList *new);

include/token.h

@@ -131,15 +131,9 @@
 #define SLICE -35
 #define FOR_BRANCH -36
 
-#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解析器所匹配
-    long int line;
+    fline line;
     struct TokenData{
         char *str;
         char *second_str;  // 针对123.4j这种形式设定的，其中second_str存储j
@@ -150,7 +144,7 @@ struct Token{
 
 struct TokenStream{
     struct Token *token_list;  // 提前存储token的列表
-    int size;
+    unsigned size;
 };
 
 struct TokenMessage{

include/value.h

@@ -7,10 +7,10 @@
 
 struct VarList;
 struct Argument;
-struct Inherit;
+struct Inter;
 
-typedef enum ResultType (*OfficialFunction)(OfficialFunctionSig);
-typedef void (*Registered)(RegisteredFunctionSig);
+typedef enum ResultType (*OfficialFunction)(OFFICAL_FUNCTIONSIG);
+typedef void (*Registered)(REGISTERED_FUNCTIONSIG);
 
 enum ValueAuthority{
     auto_aut,
@@ -40,7 +40,7 @@ struct Value{
     } object;
     union data{
         struct Number{
-            NUMBER_TYPE num;
+            vnum num;
         } num;
         struct String{
             char *str;
@@ -70,11 +70,11 @@ struct Value{
                 value_list,
             } type;
             struct LinkValue **list;
-            NUMBER_TYPE size;  // TODO-szh typedef NUMBER_TYPE
+            vnum size;  // TODO-szh typedef NUMBER_TYPE
         } list;
         struct Dict{
             struct HashTable *dict;
-            NUMBER_TYPE size;
+            vnum size;
         } dict;
         struct Bool{
             bool bool_;
@@ -109,7 +109,7 @@ struct Result{
     char *label;
     struct LinkValue *value;
     struct Error *error;
-    int times;
+    vnum times;
     struct Statement *node;
 };
 
@@ -117,7 +117,7 @@ struct Error{
     char *type;
     char *messgae;
     char *file;
-    long int line;
+    fline line;
     struct Error *next;
 };
 
@@ -126,7 +126,6 @@ struct Inherit{
     struct Inherit *next;
 };
 
-typedef struct Inter Inter;
 typedef struct Value Value;
 typedef struct LinkValue LinkValue;
 typedef struct Result Result;
@@ -142,7 +141,7 @@ LinkValue *copyLinkValue(LinkValue *value, Inter *inter);
 Value *makeNoneValue(Inter *inter);
 Value *makeBoolValue(bool bool_num, Inter *inter);
 Value *makePassValue(Inter *inter);
-Value *makeNumberValue(long num, Inter *inter);
+Value *makeNumberValue(vnum num, Inter *inter);
 Value *makeStringValue(char *str, Inter *inter);
 Value *makeVMFunctionValue(struct Statement *st, struct Parameter *pt, struct VarList *var_list, Inter *inter);
 Value *makeCFunctionValue(OfficialFunction of, VarList *var_list, Inter *inter);
@@ -154,14 +153,14 @@ void setResultCore(Result *ru);
 void setResult(Result *ru, Inter *inter, LinkValue *belong);
 void setResultBase(Result *ru, Inter *inter, LinkValue *belong);
 void setResultErrorSt(Result *ru, Inter *inter, char *error_type, char *error_message, Statement *st, LinkValue *belong, bool new);
-void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, long int line, char *file, LinkValue *belong, bool new);
+void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, fline line, char *file, LinkValue *belong, bool new);
 void setResultOperationNone(Result *ru, Inter *inter, LinkValue *belong);
 void setResultOperation(Result *ru, LinkValue *value);
 void setResultOperationBase(Result *ru, LinkValue *value);
 void freeResult(Result *ru);
 void freeResultSafe(Result *ru);
 
-Error *makeError(char *type, char *message, long int line, char *file);
+Error *makeError(char *type, char *message, fline line, char *file);
 void freeError(Result *base);
 Error *connectError(Error *new, Error *base);
 void printError(Result *result, Inter *inter, bool free);

include/var.h

@@ -1,7 +1,7 @@
 #ifndef VIRTUALMATH_VAR_H
 #define VIRTUALMATH_VAR_H
 
-#define MAX_SIZE (1024)
+#define MAX_SIZE (8)
 
 struct Var{
     GCStatus gc_status;
@@ -22,7 +22,7 @@ struct HashTable{
 
 struct DefaultVar{
     char *name;
-    NUMBER_TYPE times;
+    vnum times;
     struct DefaultVar *next;
 };
 
@@ -53,12 +53,12 @@ void freeHashTable(HashTable **value);
 VarList *makeVarList(Inter *inter, bool make_hash);
 VarList *freeVarList(VarList *vl);
 
-HASH_INDEX time33(char *key);
+vhashn time33(char *key);
 LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht);
-LinkValue *findFromVarList(char *name, NUMBER_TYPE times, VarOperation operating, INTER_FUNCTIONSIG_CORE);
+LinkValue *findFromVarList(char *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE);
 void addVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht);
 void updateHashTable(HashTable *update, HashTable *new, Inter *inter);
-void addFromVarList(char *name, LinkValue *name_, NUMBER_TYPE times, LinkValue *value, INTER_FUNCTIONSIG_CORE);
+void addFromVarList(char *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE);
 
 VarList *pushVarList(VarList *base, Inter *inter);
 VarList *popVarList(VarList *base);
@@ -68,9 +68,9 @@ VarList *connectVarListBack(VarList *base, VarList *back);
 bool comparVarList(VarList *dest, VarList *src);
 VarList *makeObjectVarList(Inherit *value, Inter *inter, VarList *base);
 
-NUMBER_TYPE findDefault(DefaultVar *base, char *name);
-DefaultVar *connectDefaultVar(DefaultVar *base, char *name, NUMBER_TYPE times);
+vnum findDefault(DefaultVar *base, char *name);
+DefaultVar *connectDefaultVar(DefaultVar *base, char *name, vnum times);
 DefaultVar *freeDefaultVar(DefaultVar *dv);
-DefaultVar *makeDefaultVar(char *name, NUMBER_TYPE times);
+DefaultVar *makeDefaultVar(char *name, vnum times);
 
 #endif //VIRTUALMATH_VAR_H

memory/mem.c

@@ -78,7 +78,7 @@ char *memStrcat(char *first, char *second, bool free_first, bool free_last) {
     return new;
 }
 
-char *memStrcpySelf(char *str, NUMBER_TYPE times){
+char *memStrcpySelf(char *str, long times){
     bool need_free = false;
     char *new_str = NULL;
     if (times < 0){
@@ -86,7 +86,7 @@ char *memStrcpySelf(char *str, NUMBER_TYPE times){
         times = -times;
         need_free = true;
     }
-    for (NUMBER_TYPE i=0; i < times; i++)
+    for (long i=0; i < times; i++)
         new_str = memStrcat(new_str, str, true, false);
     if (need_free)
         memFree(str);

ofunc/include/bool.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_BOOL_H
 #include "__macro.h"
 
-void registeredBool(RegisteredFunctionSig);
+void registeredBool(REGISTERED_FUNCTIONSIG);
 void makeBaseBool(Inter *inter);
 #endif //VIRTUALMATH_BOOL_H

ofunc/include/dict.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_DICT_H
 #include "__macro.h"
 
-void registeredDict(RegisteredFunctionSig);
+void registeredDict(REGISTERED_FUNCTIONSIG);
 void makeBaseDict(Inter *inter);
 #endif //VIRTUALMATH_DICT_H

ofunc/include/dictiter.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_DICTITER_H
 #include "__macro.h"
 
-void registeredDictIter(RegisteredFunctionSig);
+void registeredDictIter(REGISTERED_FUNCTIONSIG);
 void makeBaseDictIter(Inter *inter);
 #endif //VIRTUALMATH_DICTITER_H

ofunc/include/function.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_FUNCTION_H
 #include "__macro.h"
 
-void registeredFunction(RegisteredFunctionSig);
+void registeredFunction(REGISTERED_FUNCTIONSIG);
 void makeBaseFunction(Inter *inter);
 #endif //VIRTUALMATH_FUNCTION_H

ofunc/include/io.h

@@ -2,5 +2,5 @@
 #define VIRTUALMATH_IO_H
 #include "__base.h"
 
-void registeredIOFunction(RegisteredFunctionSig);
+void registeredIOFunction(REGISTERED_FUNCTIONSIG);
 #endif //VIRTUALMATH_IO_H

ofunc/include/list.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_LIST_H
 #include "__macro.h"
 
-void registeredList(RegisteredFunctionSig);
+void registeredList(REGISTERED_FUNCTIONSIG);
 void makeBaseList(Inter *inter);
 #endif //VIRTUALMATH_BOOL_H

ofunc/include/listiter.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_LISTITER_H
 #include "__macro.h"
 
-void registeredListIter(RegisteredFunctionSig);
+void registeredListIter(REGISTERED_FUNCTIONSIG);
 void makeBaseListIter(Inter *inter);
 #endif //VIRTUALMATH_LISTITER_H

ofunc/include/num.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_NUM_H
 #include "__macro.h"
 
-void registeredNum(RegisteredFunctionSig);
+void registeredNum(REGISTERED_FUNCTIONSIG);
 void makeBaseNum(Inter *inter);
 #endif //VIRTUALMATH_NUM_H

ofunc/include/object.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_OBJECT_H
 #include "__macro.h"
 
-void registeredObject(RegisteredFunctionSig);
+void registeredObject(REGISTERED_FUNCTIONSIG);
 void makeBaseObject(Inter *inter);
 #endif //VIRTUALMATH_OBJECT_H

ofunc/include/pass.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_PASS_H
 #include "__macro.h"
 
-void registeredEllipisis(RegisteredFunctionSig);
+void registeredEllipisis(REGISTERED_FUNCTIONSIG);
 void makeBaseEllipisis(Inter *inter);
 #endif //VIRTUALMATH_PASS_H

ofunc/include/str.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_STR_H
 #include "__macro.h"
 
-void registeredStr(RegisteredFunctionSig);
+void registeredStr(REGISTERED_FUNCTIONSIG);
 void makeBaseStr(Inter *inter);
 #endif //VIRTUALMATH_STR_H

ofunc/include/sys.h

@@ -3,5 +3,5 @@
 #include "__macro.h"
 
 
-void registeredSysFunction(RegisteredFunctionSig);
+void registeredSysFunction(REGISTERED_FUNCTIONSIG);
 #endif //VIRTUALMATH_SYS_H

ofunc/include/vobject.h

@@ -2,6 +2,6 @@
 #define VIRTUALMATH_VOBJECT_H
 #include "__macro.h"
 
-void registeredVObject(RegisteredFunctionSig);
+void registeredVObject(REGISTERED_FUNCTIONSIG);
 void makeBaseVObject(Inter *inter);
 #endif //VIRTUALMATH_VOBJECT_H

ofunc/src/bool.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-void registeredBool(RegisteredFunctionSig){
+void registeredBool(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.bool_, inter->base_father, inter);
 //    VarList *object_var = object->value->object.var;
 //    VarList *object_backup = NULL;

ofunc/src/dict.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-ResultType dict_down(OfficialFunctionSig){
+ResultType dict_down(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
@@ -8,7 +8,7 @@ ResultType dict_down(OfficialFunctionSig){
     LinkValue *element = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -26,7 +26,7 @@ ResultType dict_down(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType dict_keys(OfficialFunctionSig){
+ResultType dict_keys(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     Argument *list = NULL;
@@ -34,7 +34,7 @@ ResultType dict_keys(OfficialFunctionSig){
     LinkValue *element = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
     if (ap[0].value->value->type != dict){
@@ -53,12 +53,12 @@ ResultType dict_keys(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType dict_iter(OfficialFunctionSig){
+ResultType dict_iter(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -77,7 +77,7 @@ ResultType dict_iter(OfficialFunctionSig){
     return result->type;
 }
 
-void registeredDict(RegisteredFunctionSig){
+void registeredDict(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.dict, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

ofunc/src/dictiter.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-ResultType dictiter_init(OfficialFunctionSig){
+ResultType dictiter_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=name_value, .name="dict_", .must=1, .long_arg=false},
                            {.must=-1}};
@@ -8,7 +8,7 @@ ResultType dictiter_init(OfficialFunctionSig){
     LinkValue *list_iter = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
     if (ap[1].value->value->type != dict){
@@ -29,7 +29,7 @@ ResultType dictiter_init(OfficialFunctionSig){
         freeResult(result);
         callBackCore(keys, NULL, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         gc_freeTmpLink(&keys->gc_status);
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             return error_return;
         }
         list = result->value;
@@ -43,7 +43,7 @@ ResultType dictiter_init(OfficialFunctionSig){
         callBackCore(listiter_class, list_arg, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         freeArgument(list_arg, true);
 
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             gc_freeTmpLink(&listiter_class->gc_status);
             gc_freeTmpLink(&list->gc_status);
             return error_return;
@@ -62,14 +62,14 @@ ResultType dictiter_init(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType dictiter_next(OfficialFunctionSig){
+ResultType dictiter_next(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *list_ = NULL;
     LinkValue *list_next = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     list_ = findAttributes("__list", false, ap[0].value, inter);
     if (list_ == NULL){
@@ -87,14 +87,14 @@ ResultType dictiter_next(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType dictiter_down(OfficialFunctionSig){
+ResultType dictiter_down(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *dict_ = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     dict_ = findAttributes("__dict", false, ap[0].value, inter);
     if (dict_->value->type != dict){
@@ -107,7 +107,7 @@ ResultType dictiter_down(OfficialFunctionSig){
     return result->type;
 }
 
-void registeredDictIter(RegisteredFunctionSig){
+void registeredDictIter(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.dict_iter, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

ofunc/src/function.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-void registeredFunction(RegisteredFunctionSig){
+void registeredFunction(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.function, inter->base_father, inter);
 //    VarList *object_var = object->value->object.var;
 //    VarList *object_backup = NULL;

ofunc/src/io.c

@@ -1,25 +1,25 @@
 #include "__ofunc.h"
-ResultType vm_printCore(OfficialFunctionSig, int type);
+ResultType vm_printCore(OFFICAL_FUNCTIONSIG, int type);
 
-ResultType vm_print(OfficialFunctionSig){
-    return vm_printCore(CALL_OfficialFunction(arg, var_list, result, belong), 2);
+ResultType vm_print(OFFICAL_FUNCTIONSIG){
+    return vm_printCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), 2);
 }
 
-ResultType vm_printAll(OfficialFunctionSig){
-    return vm_printCore(CALL_OfficialFunction(arg, var_list, result, belong), 1);
+ResultType vm_printAll(OFFICAL_FUNCTIONSIG){
+    return vm_printCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), 1);
 }
 
-ResultType vm_printLink(OfficialFunctionSig){
-    return vm_printCore(CALL_OfficialFunction(arg, var_list, result, belong), 0);
+ResultType vm_printLink(OFFICAL_FUNCTIONSIG){
+    return vm_printCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), 0);
 }
 
-ResultType vm_printCore(OfficialFunctionSig, int type){
+ResultType vm_printCore(OFFICAL_FUNCTIONSIG, int type){
     setResultCore(result);
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=true},
                            {.type=name_value, .name="end", .must=0, .value=NULL},
                            {.must=-1}};
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -44,7 +44,7 @@ ResultType vm_printCore(OfficialFunctionSig, int type){
     return result->type;
 }
 
-void registeredIOFunction(RegisteredFunctionSig){
+void registeredIOFunction(REGISTERED_FUNCTIONSIG){
     NameFunc tmp[] = {{"print", vm_print, free_},
                       {"print_link", vm_printLink, free_},
                       {"print_all", vm_printAll, free_},

ofunc/src/list.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-ResultType list_slice(OfficialFunctionSig){
+ResultType list_slice(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=0, .long_arg=false},
@@ -12,7 +12,7 @@ ResultType list_slice(OfficialFunctionSig){
     long stride;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -81,7 +81,7 @@ ResultType list_slice(OfficialFunctionSig){
     return error_return;
 }
 
-ResultType list_down_assignment(OfficialFunctionSig){
+ResultType list_down_assignment(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
@@ -90,7 +90,7 @@ ResultType list_down_assignment(OfficialFunctionSig){
     long index;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -114,7 +114,7 @@ ResultType list_down_assignment(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType list_down(OfficialFunctionSig){
+ResultType list_down(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
@@ -123,7 +123,7 @@ ResultType list_down(OfficialFunctionSig){
     LinkValue *element = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -147,12 +147,12 @@ ResultType list_down(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType list_iter(OfficialFunctionSig){
+ResultType list_iter(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -171,7 +171,7 @@ ResultType list_iter(OfficialFunctionSig){
     return result->type;
 }
 
-void registeredList(RegisteredFunctionSig){
+void registeredList(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.list, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

ofunc/src/listiter.c

@@ -1,13 +1,13 @@
 #include "__ofunc.h"
 
-ResultType listiter_init(OfficialFunctionSig){
+ResultType listiter_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.type=name_value, .name="list_", .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *index = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
     if (ap[1].value->value->type != list){
@@ -21,14 +21,14 @@ ResultType listiter_init(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType listiter_next(OfficialFunctionSig){
+ResultType listiter_next(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *list_ = NULL;
     LinkValue *index = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     list_ = findAttributes("__list", false, ap[0].value, inter);
     index = findAttributes("__index", false, ap[0].value, inter);
@@ -39,7 +39,7 @@ ResultType listiter_next(OfficialFunctionSig){
 
     freeResult(result);
     elementDownOne(list_, index, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         setResultError(result, inter, "StopIterException", "Stop Iter", 0, "sys", belong, true);
     else {
         index->value->data.num.num ++;
@@ -48,7 +48,7 @@ ResultType listiter_next(OfficialFunctionSig){
     return result->type;
 }
 
-void registeredListIter(RegisteredFunctionSig){
+void registeredListIter(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.list_iter, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

ofunc/src/num.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-void registeredNum(RegisteredFunctionSig){
+void registeredNum(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.num, inter->base_father, inter);
 //    VarList *object_var = object->value->object.var;
 //    VarList *object_backup = NULL;

ofunc/src/object.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-ResultType object_new_(OfficialFunctionSig){
+ResultType object_new_(OFFICAL_FUNCTIONSIG){
     LinkValue *value = NULL;
     LinkValue *_init_ = NULL;
     setResultCore(result);
@@ -32,7 +32,7 @@ ResultType object_new_(OfficialFunctionSig){
         gc_addTmpLink(&_init_->gc_status);
         callBackCore(_init_, arg, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &_init_result, value));
         gc_freeTmpLink(&_init_->gc_status);
-        if (!run_continue_type(_init_result.type)){
+        if (!RUN_TYPE(_init_result.type)){
             freeResult(result);
             *result = _init_result;
             goto return_;
@@ -45,7 +45,7 @@ ResultType object_new_(OfficialFunctionSig){
     return result->type;
 }
 
-void registeredObject(RegisteredFunctionSig){
+void registeredObject(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.object, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

ofunc/src/pass.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-void registeredEllipisis(RegisteredFunctionSig){
+void registeredEllipisis(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.pass_, inter->base_father, inter);
 //    VarList *object_var = object->value->object.var;
 //    VarList *object_backup = NULL;

ofunc/src/str.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-void registeredStr(RegisteredFunctionSig){
+void registeredStr(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.str, inter->base_father, inter);
 //    VarList *object_var = object->value->object.var;
 //    VarList *object_backup = NULL;

ofunc/src/sys.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-ResultType vm_super(OfficialFunctionSig){
+ResultType vm_super(OFFICAL_FUNCTIONSIG){
     Value *arg_father = NULL;
     Value *arg_child = NULL;
     LinkValue *next_father = NULL;
@@ -9,7 +9,7 @@ ResultType vm_super(OfficialFunctionSig){
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
 
@@ -44,13 +44,13 @@ ResultType vm_super(OfficialFunctionSig){
     return result->type;
 }
 
-ResultType vm_setMethodCore(OfficialFunctionSig, enum FunctionPtType type){
+ResultType vm_setMethodCore(OFFICAL_FUNCTIONSIG, enum FunctionPtType type){
     LinkValue *function_value = NULL;
     ArgumentParser ap[] = {{.type=name_value, .name="func", .must=1, .long_arg=false}, {.must=-1}};
     setResultCore(result);
     {
         parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             return result->type;
         freeResult(result);
     }
@@ -62,31 +62,31 @@ ResultType vm_setMethodCore(OfficialFunctionSig, enum FunctionPtType type){
     return operation_return;
 }
 
-ResultType vm_freemethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), free_);
+ResultType vm_freemethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), free_);
 }
 
-ResultType vm_staticmethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), static_);
+ResultType vm_staticmethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), static_);
 }
 
-ResultType vm_classmethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), class_static_);
+ResultType vm_classmethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), class_static_);
 }
 
-ResultType vm_objectmethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), object_static_);
+ResultType vm_objectmethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), object_static_);
 }
 
-ResultType vm_classfreemethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), class_free_);
+ResultType vm_classfreemethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), class_free_);
 }
 
-ResultType vm_objectfreemethod(OfficialFunctionSig){
-    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, belong), object_free_);
+ResultType vm_objectfreemethod(OFFICAL_FUNCTIONSIG){
+    return vm_setMethodCore(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), object_free_);
 }
 
-void registeredSysFunction(RegisteredFunctionSig){
+void registeredSysFunction(REGISTERED_FUNCTIONSIG){
     NameFunc tmp[] = {{"super", vm_super, free_},
                       {"freemethod", vm_freemethod, free_},
                       {"staticmethod", vm_staticmethod, free_},

ofunc/src/vobject.c

@@ -50,7 +50,7 @@ void vobject_div_base(LinkValue *belong, Result *result, struct Inter *inter, Va
         setResultError(result, inter, "TypeException", "Get Not Support Value", 0, "sys", belong, true);
 }
 
-ResultType vobject_opt_core(OfficialFunctionSig, base_opt func){
+ResultType vobject_opt_core(OFFICAL_FUNCTIONSIG, base_opt func){
     Value *left = NULL;
     Value *right = NULL;
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
@@ -59,7 +59,7 @@ ResultType vobject_opt_core(OfficialFunctionSig, base_opt func){
     setResultCore(result);
     {
         parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             return result->type;
         freeResult(result);
     }
@@ -72,23 +72,23 @@ ResultType vobject_opt_core(OfficialFunctionSig, base_opt func){
     return result->type;
 }
 
-ResultType vobject_add(OfficialFunctionSig){
-    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, belong), vobject_add_base);
+ResultType vobject_add(OFFICAL_FUNCTIONSIG){
+    return vobject_opt_core(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), vobject_add_base);
 }
 
-ResultType vobject_sub(OfficialFunctionSig){
-    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, belong), vobject_sub_base);
+ResultType vobject_sub(OFFICAL_FUNCTIONSIG){
+    return vobject_opt_core(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), vobject_sub_base);
 }
 
-ResultType vobject_mul(OfficialFunctionSig){
-    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, belong), vobject_mul_base);
+ResultType vobject_mul(OFFICAL_FUNCTIONSIG){
+    return vobject_opt_core(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), vobject_mul_base);
 }
 
-ResultType vobject_div(OfficialFunctionSig){
-    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, belong), vobject_div_base);
+ResultType vobject_div(OFFICAL_FUNCTIONSIG){
+    return vobject_opt_core(CALL_OFFICAL_FUNCTION(arg, var_list, result, belong), vobject_div_base);
 }
 
-void registeredVObject(RegisteredFunctionSig){
+void registeredVObject(REGISTERED_FUNCTIONSIG){
     LinkValue *object = makeLinkValue(inter->data.vobject, inter->base_father, inter);
     VarList *object_var = object->value->object.var;
     VarList *object_backup = NULL;

parser/grammar.c

@@ -10,7 +10,7 @@ ParserMessage *makeParserMessage(char *file_dir) {
 }
 
 void freeParserMessage(ParserMessage *pm, bool self) {
-    freeBase(pm, return_);
+    FREE_BASE(pm, return_);
     freeTokenMessage(pm->tm, true, true);
     memFree(pm->status_message);
     memFree(pm->file);
@@ -632,7 +632,7 @@ void parserWith(PASERSSIGNATURE){
         goto error_;
     if (!callParserCode(CALLPASERSSIGNATURE, &code_tmp, "Don't get a with code", line))
         goto error_;
-    sl = makeConnectStatementList(sl, condition_tmp, var_tmp, code_tmp, if_b);
+    sl = connectStatementList(sl, makeStatementList(condition_tmp, var_tmp, code_tmp, with_b));
     condition_tmp = NULL;
     var_tmp = NULL;
     code_tmp = NULL;
@@ -725,7 +725,7 @@ void parserIf(PASERSSIGNATURE){
                 freeStatement(var_tmp);
                 goto error_;
             }
-            sl = makeConnectStatementList(sl, condition_tmp, var_tmp, code_tmp, if_b);
+            sl = connectStatementList(sl, makeStatementList(condition_tmp, var_tmp, code_tmp, if_b));
             goto again;
         }
         case MATHER_DO: {
@@ -735,7 +735,7 @@ void parserIf(PASERSSIGNATURE){
             long int tmp_line = delToken(pm);
             if (!callParserCode(CALLPASERSSIGNATURE, &code_tmp, "Don't get a if...do code", tmp_line))
                 goto error_;
-            sl = makeConnectStatementList(sl, NULL, NULL, code_tmp, do_b);
+            sl = connectStatementList(sl, makeStatementList(NULL, NULL, code_tmp, do_b));
             goto again;
         }
         case MATHER_ELSE: {
@@ -927,7 +927,7 @@ void parserTry(PASERSSIGNATURE){
                 freeStatement(var_tmp);
                 goto error_;
             }
-            sl = makeConnectStatementList(sl, condition_tmp, var_tmp, code_tmp, except_b);
+            sl = connectStatementList(sl, makeStatementList(condition_tmp, var_tmp, code_tmp, except_b));
             goto again;
         }
         case MATHER_ELSE: {

parser/include/__token.h

@@ -3,18 +3,5 @@
 
 #include "__virtualmath.h"
 
-#if OUT_LOG && OUT_TOKEN_LOG
-#define MACRO_printTokenStream(...) printTokenStream(__VA_ARGS__)
-#else
-#define MACRO_printTokenStream(...) PASS
-#undef printTokenEnter
-#define printTokenEnter(...) PASS
-#endif
-
-#if OUT_LOG && OUT_PASERS_LOG
-#define writeLog_(...) writeLog(__VA_ARGS__)
-#else
-#define writeLog_(...) PASS
-#endif
 
 #endif //VIRTUALMATH___TOKEN_H

parser/lexical.c

@@ -41,7 +41,7 @@ LexFile *makeLexFile(char *dir){
 }
 
 void freeLexFile(LexFile *file) {
-    freeBase(file, return_);
+    FREE_BASE(file, return_);
     if (!file->is_std)
         fclose(file->file);
     memFree(file);
@@ -84,7 +84,7 @@ LexMathers *makeMathers(int size){
 }
 
 void freeMathers(LexMathers *mathers) {
-    freeBase(mathers, return_);
+    FREE_BASE(mathers, return_);
     for(int i=0;i < mathers->size; i++)
         freeMather(mathers->mathers[i]);
     memFree(mathers->mathers);

parser/token.c

@@ -1,4 +1,4 @@
-#include "__token.h"
+#include "__virtualmath.h"
 
 Token *makeToken(long int line) {
     Token *tmp = memCalloc(1, sizeof(Token));
@@ -28,7 +28,7 @@ Token *makeStatementToken(int type, struct Statement *st){
 
 long freeToken(Token *tk, bool free_st) {
     long int line = 0;
-    freeBase(tk, return_);
+    FREE_BASE(tk, return_);
     line = tk->line;
     memFree(tk->data.str);
     memFree(tk->data.second_str);
@@ -47,7 +47,7 @@ TokenStream *makeTokenStream(){
 }
 
 void freeToekStream(TokenStream *ts, bool free_st) {
-    freeBase(ts, return_);
+    FREE_BASE(ts, return_);
     for (Token *tmp = ts->token_list, *tmp_next=NULL; tmp != NULL; tmp = tmp_next){
         tmp_next = tmp->next;
         freeToken(tmp, free_st);

src/__run.c

@@ -69,9 +69,9 @@ char *setStrVarName(char *old, bool free_old, Inter *inter) {
     return memStrcat(inter->data.var_str_prefix, old, false, free_old);
 }
 
-char *setNumVarName(NUMBER_TYPE num, struct Inter *inter) {
+char *setNumVarName(vnum num, struct Inter *inter) {
     char name[50];
-    snprintf(name, 50, "%"NUMBER_FORMAT, num);
+    snprintf(name, 50, "%lld", num);
     return memStrcat(inter->data.var_num_prefix, name, false, false);
 }
 
@@ -135,7 +135,7 @@ void updateFunctionYield(Statement *function_st, Statement *node){
     function_st->info.have_info = true;
 }
 
-ResultType setFunctionArgument(Argument **arg, LinkValue *function_value, long line, char *file, INTER_FUNCTIONSIG_NOT_ST){
+ResultType setFunctionArgument(Argument **arg, LinkValue *function_value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST){
     Argument *tmp = NULL;
     enum FunctionPtType pt_type = function_value->value->data.function.function_data.pt_type;
     setResultCore(result);
@@ -229,7 +229,7 @@ void addAttributes(char *name, bool free_old, LinkValue *value, LinkValue *belon
     addStrVar(name, free_old, value, belong, inter, belong->value->object.var);
 }
 
-ResultType elementDownOne(LinkValue *element, LinkValue *index, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType elementDownOne(LinkValue *element, LinkValue *index, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *_func_ = NULL;
     setResultCore(result);
     gc_addTmpLink(&element->gc_status);
@@ -252,7 +252,7 @@ ResultType elementDownOne(LinkValue *element, LinkValue *index, long int line, c
     return result->type;
 }
 
-ResultType getIter(LinkValue *value, int status, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType getIter(LinkValue *value, int status, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *_func_ = NULL;
     setResultCore(result);
     if (status == 1)

src/include/__run.h

@@ -10,7 +10,7 @@
 #endif
 
 char *setStrVarName(char *old, bool free_old, struct Inter *inter);
-char *setNumVarName(NUMBER_TYPE num, struct Inter *inter);
+char *setNumVarName(vnum num, struct Inter *inter);
 char *getNameFromValue(Value *value, struct Inter *inter);
 ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
 ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
@@ -28,13 +28,13 @@ void newWithBranchYield(Statement *branch_st, Statement *node, StatementList *sl
 void newForBranchYield(Statement *branch_st, Statement *node, StatementList *sl_node, VarList *new_var, enum StatementInfoStatus status,
                        Inter *inter, LinkValue *iter);
 
-ResultType setFunctionArgument(struct Argument **arg, LinkValue *function_value, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType setFunctionArgument(struct Argument **arg, LinkValue *function_value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 void freeFunctionArgument(Argument *arg, Argument *base);
 LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE);
 LinkValue *checkStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE);
 void addStrVar(char *name, bool free_old, LinkValue *value, LinkValue *father, INTER_FUNCTIONSIG_CORE);
 LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *inter);
 void addAttributes(char *name, bool free_old, LinkValue *value, LinkValue *belong, Inter *inter);
-ResultType elementDownOne(LinkValue *element, LinkValue *index, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-ResultType getIter(LinkValue *value, int status, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType elementDownOne(LinkValue *element, LinkValue *index, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+ResultType getIter(LinkValue *value, int status, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 #endif //VIRTUALMATH___RUN_H

src/inter.c

@@ -125,7 +125,7 @@ void freeBaseInterData(struct Inter *inter){
 }
 
 void freeInter(Inter *inter, bool show_gc) {
-    freeBase(inter, return_);
+    FREE_BASE(inter, return_);
     gc_runDelAll(inter);
     freeBaseInterData(inter);
 #if DEBUG

src/ofunc.c

@@ -17,7 +17,7 @@ static Registered base_func_list[] = {registeredIOFunction,
 
 void registeredBaseFunction(struct LinkValue *father, Inter *inter){
     for (Registered *list = base_func_list; *list != NULL; list++)
-        (*list)(CALL_RegisteredFunction(father, inter->var_list));
+        (*list)(CALL_REGISTERED_FUNCTION(father, inter->var_list));
 }
 
 void registeredFunctionName(Inter *inter){

src/parameter.c

@@ -2,7 +2,7 @@
 
 
 #define returnResult(result) do{ \
-if (!run_continue(result)) { \
+if (!CHECK_RESULT(result)) { \
 goto return_; \
 } \
 }while(0)
@@ -186,14 +186,14 @@ Argument *listToArgument(LinkValue *list_value, long line, char *file, INTER_FUN
     LinkValue *iter = NULL;
     setResultCore(result);
     getIter(list_value, 1, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return NULL;
     iter = result->value;
     result->value = NULL;
     while (true) {
         freeResult(result);
         getIter(iter, 0, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             freeResult(result);
             break;
         }
@@ -209,7 +209,7 @@ Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUN
     LinkValue *iter = NULL;
     setResultCore(result);
     getIter(dict_value, 1, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         return NULL;
     iter = result->value;
     result->value = NULL;
@@ -219,7 +219,7 @@ Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUN
 
         freeResult(result);
         getIter(iter, 0, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             freeResult(result);
             break;
         }
@@ -228,7 +228,7 @@ Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUN
         freeResult(result);
 
         elementDownOne(iter, name_, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             gc_freeTmpLink(&name_->gc_status);
             goto return_;
         }
@@ -252,7 +252,7 @@ Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUN
  * @param num
  * @return
  */
-ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType defaultParameter(Parameter **function_ad, vnum *num, INTER_FUNCTIONSIG_NOT_ST) {
     Parameter *function = *function_ad;
     setResultCore(result);
 
@@ -264,7 +264,7 @@ ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUN
         value = result->value;
         freeResult(result);
         assCore(function->data.name, value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto return_;
     }
     setResult(result, inter, belong);
@@ -282,7 +282,7 @@ ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUN
  * @param num
  * @return
  */
-ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType argumentToVar(Argument **call_ad, vnum *num, INTER_FUNCTIONSIG_NOT_ST) {
     Argument *call = *call_ad;
     setResultCore(result);
 
@@ -293,7 +293,7 @@ ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG
         }
         freeResult(result);
         assCore(call->data.name, call->data.value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto return_;
     }
     setResult(result, inter, belong);
@@ -312,7 +312,7 @@ ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG
  * @param num
  * @return
  */
-ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMBER_TYPE *num, NUMBER_TYPE max, bool *status,
+ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, vnum *num, vnum max, bool *status,
                             INTER_FUNCTIONSIG_NOT_ST) {
     Parameter *function = *function_ad;
     bool get = true;
@@ -335,7 +335,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
 
         freeResult(result);
         getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, belong));
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             memFree(str_name);
             *function_ad = function;
             return result->type;
@@ -370,7 +370,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
         freeResult(result);
         assCore(name, value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result, belong));
 
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             *function_ad = function;
             return result->type;
         }
@@ -404,7 +404,7 @@ ResultType argumentToParameter(Argument **call_ad, Parameter **function_ad, VarL
     for (PASS; call != NULL && function != NULL && (call->type == value_arg) && function->type != args_par; call = call->next, function = function->next){
         Statement *name = function->type == value_par ? function->data.value : function->data.name;
         assCore(name, call->data.value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto return_;
         freeResult(result);
     }
@@ -501,7 +501,7 @@ Argument * getArgument(Parameter *call, bool is_dict, INTER_FUNCTIONSIG_NOT_ST)
  * @param var_list
  * @return
  */
-ResultType setParameter(long int line, char *file, Parameter *call_base, Parameter *function_base, VarList *function_var, LinkValue *function_father, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType setParameter(fline line, char *file, Parameter *call_base, Parameter *function_base, VarList *function_var, LinkValue *function_father, INTER_FUNCTIONSIG_NOT_ST) {
     Argument *self_tmp = makeValueArgument(function_father);
     Argument *father_tmp = makeValueArgument(function_father->belong);
     Argument *call = NULL;
@@ -509,7 +509,7 @@ ResultType setParameter(long int line, char *file, Parameter *call_base, Paramet
     call = getArgument(call_base, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     self_tmp->next = father_tmp;
     father_tmp->next = call;
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         freeArgument(call, false);
         return result->type;
     }
@@ -520,7 +520,7 @@ ResultType setParameter(long int line, char *file, Parameter *call_base, Paramet
     return result->type;
 }
 
-ResultType setParameterCore(long int line, char *file, Argument *call, Parameter *function_base, VarList *function_var,
+ResultType setParameterCore(fline line, char *file, Argument *call, Parameter *function_base, VarList *function_var,
                         INTER_FUNCTIONSIG_NOT_ST) {
     Parameter *function = NULL;
     Parameter *tmp_function = NULL;  // 释放使用
@@ -569,19 +569,19 @@ ResultType setParameterCore(long int line, char *file, Argument *call, Parameter
                 break;
             }
             case default_status: {
-                NUMBER_TYPE num = 0;
+                vnum num = 0;
                 defaultParameter(&function, &num, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result, belong));
                 returnResult(result);
                 break;
             }
             case self_ass: {
-                NUMBER_TYPE set_num = 0;
-                NUMBER_TYPE get_num = 0;
+                vnum set_num = 0;
+                vnum get_num = 0;
                 bool dict_status = false;
                 VarList *tmp = makeVarList(inter, true);
 
                 argumentToVar(&call, &set_num, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result, belong));
-                if (!run_continue(result)) {
+                if (!CHECK_RESULT(result)) {
                     freeVarList(tmp);
                     goto return_;
                 }
@@ -589,7 +589,7 @@ ResultType setParameterCore(long int line, char *file, Argument *call, Parameter
                 freeResult(result);
                 parameterFromVar(&function, function_var, &get_num, set_num, &dict_status, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result, belong));
                 freeVarList(tmp);
-                if (!run_continue(result))
+                if (!CHECK_RESULT(result))
                     goto return_;
 
                 if (!dict_status && set_num > get_num)
@@ -694,7 +694,7 @@ int parserArgumentUnion(ArgumentParser ap[], Argument *arg, INTER_FUNCTIONSIG_NO
         }
 
         status = parserNameArgument(ap, arg, &bak, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             return -1;
         if (status == -3){
             if (parserArgumentNameDefault(ap)->must != -1){
@@ -735,8 +735,8 @@ Argument *parserValueArgument(ArgumentParser *ap, Argument *arg, int *status, Ar
 
 int parserNameArgument(ArgumentParser ap[], Argument *arg, ArgumentParser **bak, INTER_FUNCTIONSIG_NOT_ST){
     VarList *tmp = NULL;
-    NUMBER_TYPE set_num = 0;
-    NUMBER_TYPE get_num = 0;
+    vnum set_num = 0;
+    vnum get_num = 0;
     int return_;
     setResultCore(result);
 
@@ -750,7 +750,7 @@ int parserNameArgument(ArgumentParser ap[], Argument *arg, ArgumentParser **bak,
 
     tmp = makeVarList(inter, true);
     argumentToVar(&arg, &set_num, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result, belong));
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         return_ = -1;
         goto return_;
     }

src/run.c

@@ -103,7 +103,7 @@ ResultType runStatement(INTER_FUNCTIONSIG) {
             break;
     }
 
-    if (run_continue_type(type) && result->value->aut == auto_aut)
+    if (RUN_TYPE(type) && result->value->aut == auto_aut)
         result->value->aut = st->aut;
     result->node = st;
     gc_run(inter, var_list, 1, 0, 0, var_list);
@@ -139,11 +139,11 @@ ResultType iterStatement(INTER_FUNCTIONSIG) {
                     break;
                 }
                 type = runLabel(CALL_INTER_FUNCTIONSIG(label_st, var_list, result, belong));
-                if (!run_continue_type(type))
+                if (!RUN_TYPE(type))
                     break;
                 base_st = label_st->next;
             }
-            else if (!run_continue_type(type))
+            else if (!RUN_TYPE(type))
                 break;
             else
                 base_st = base_st->next;
@@ -180,11 +180,11 @@ ResultType globalIterStatement(Result *result, Inter *inter, Statement *st) {
                     break;
                 }
                 type = runLabel(CALL_INTER_FUNCTIONSIG(label_st, var_list, result, belong));
-                if (!run_continue_type(type))
+                if (!RUN_TYPE(type))
                     break;
                 base_st = label_st->next;
             }
-            else if (!run_continue_type(type))
+            else if (!RUN_TYPE(type))
                 break;
             else
                 base_st = base_st->next;
@@ -203,7 +203,7 @@ ResultType globalIterStatement(Result *result, Inter *inter, Statement *st) {
 bool operationSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
     type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
-    if (run_continue_type(type))
+    if (RUN_TYPE(type))
         return false;
     else if (type != return_code && type != error_return)
         setResultErrorSt(result, inter, "ResultException", "Get Not Support Result", st, belong, true);
@@ -213,7 +213,7 @@ bool operationSafeInterStatement(INTER_FUNCTIONSIG){
 bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
     type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
-    if (run_continue_type(type))
+    if (RUN_TYPE(type))
         return false;
     if (type == rego_return){
         result->times--;
@@ -228,7 +228,7 @@ bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG){
 bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
     type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
-    if (run_continue_type(type))
+    if (RUN_TYPE(type))
         return false;
     if (type == break_return || type == continue_return){
         result->times--;
@@ -243,7 +243,7 @@ bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG){
 bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
     type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
-    if (run_continue_type(type))
+    if (RUN_TYPE(type))
         return false;
     if (type == restart_return || type == goto_return)
         result->times--;

src/runbranch.c

@@ -121,7 +121,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
             freeResult(result);
             if (if_list->var != NULL) {
                 assCore(if_list->var, condition_value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-                if (!run_continue(result)){
+                if (!CHECK_RESULT(result)){
                     set_result = false;
                     goto not_else;
                 }
@@ -260,7 +260,7 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
         freeResult(result);
         if (while_list->var != NULL){
             assCore(while_list->var, condition_value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-            if (!run_continue(result)){
+            if (!CHECK_RESULT(result)){
                 set_result = false;
                 goto not_else;
             }
@@ -394,7 +394,7 @@ ResultType forBranch(INTER_FUNCTIONSIG) {
 
         getIter(tmp, 1, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         gc_freeTmpLink(&tmp->gc_status);
-        if (!run_continue(result)) {
+        if (!CHECK_RESULT(result)) {
             set_result = false;
             goto not_else;
         }
@@ -421,7 +421,7 @@ ResultType forBranch(INTER_FUNCTIONSIG) {
         {
             LinkValue *element = NULL;
             getIter(iter, 0, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-            if (!run_continue(result)) {
+            if (!CHECK_RESULT(result)) {
                 freeResult(result);
                 break;
             }
@@ -430,7 +430,7 @@ ResultType forBranch(INTER_FUNCTIONSIG) {
             freeResult(result);
             assCore(for_list->var, element, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             gc_freeTmpLink(&element->gc_status);
-            if (!run_continue(result)){
+            if (!CHECK_RESULT(result)){
                 set_result = false;
                 goto not_else;
             }
@@ -583,7 +583,7 @@ ResultType withBranch(INTER_FUNCTIONSIG) {
             gc_addTmpLink(&_enter_->gc_status);
             gc_addTmpLink(&_exit_->gc_status);
             callBackCore(_enter_, NULL, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, value));
-            if (!run_continue(result)) {
+            if (!CHECK_RESULT(result)) {
                 set_result = false;
                 gc_freeTmpLink(&value->gc_status);
                 gc_freeTmpLink(&_enter_->gc_status);
@@ -595,7 +595,7 @@ ResultType withBranch(INTER_FUNCTIONSIG) {
             enter_value = result->value;
             freeResult(result);
             assCore(with_list->var, enter_value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(new, result, belong));
-            if (!run_continue(result)) {
+            if (!CHECK_RESULT(result)) {
                 set_result = false;
                 popVarList(new);
                 gc_freeTmpLink(&value->gc_status);
@@ -633,7 +633,7 @@ ResultType withBranch(INTER_FUNCTIONSIG) {
 
     if (_exit_ != NULL) {
         callBackCore(_exit_, NULL, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &exit_tmp, value));
-        if (!run_continue_type(exit_tmp.type)) {
+        if (!RUN_TYPE(exit_tmp.type)) {
             if (!set_result)
                 freeResult(result);
             set_result = false;
@@ -744,7 +744,7 @@ ResultType tryBranch(INTER_FUNCTIONSIG) {
     freeResult(result);
     if (except_list->var != NULL){
         assCore(except_list->var, error_value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result)){
+        if (!CHECK_RESULT(result)){
             set_result = false;
             goto not_else;
         }
@@ -991,7 +991,7 @@ ResultType runLabel(INTER_FUNCTIONSIG) {
     if (st->u.label_.as != NULL)
         assCore(st->u.label_.as, goto_value, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     gc_freeTmpLink(&goto_value->gc_status);
-    if (st->u.label_.as != NULL && !run_continue(result))
+    if (st->u.label_.as != NULL && !CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);

src/runcall.c

@@ -9,7 +9,7 @@ ResultType setClass(INTER_FUNCTIONSIG) {
     setResultCore(result);
 
     call = getArgument(st->u.set_class.father, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto error_;
 
     class_belong = setFather(call);
@@ -24,13 +24,13 @@ ResultType setClass(INTER_FUNCTIONSIG) {
     functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.set_class.st, tmp->value->object.var, result, tmp));
     inter->data.default_pt_type = pt_type_bak;
     tmp->value->object.var->next = belong_var;
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto error_;
 
     freeResult(result);
     if (st->u.set_class.decoration != NULL){
         setDecoration(st->u.set_class.decoration, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto error_;
         gc_freeTmpLink(&tmp->gc_status);
         tmp = result->value;
@@ -39,7 +39,7 @@ ResultType setClass(INTER_FUNCTIONSIG) {
     }
 
     assCore(st->u.set_class.name, tmp, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (run_continue(result))
+    if (CHECK_RESULT(result))
         setResult(result, inter, belong);
 
     gc_freeTmpLink(&tmp->gc_status);
@@ -63,7 +63,7 @@ ResultType setFunction(INTER_FUNCTIONSIG) {
     gc_addTmpLink(&tmp->gc_status);
     if (st->u.set_function.decoration != NULL){
         setDecoration(st->u.set_function.decoration, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto error_;
         gc_freeTmpLink(&tmp->gc_status);
         tmp = result->value;
@@ -71,7 +71,7 @@ ResultType setFunction(INTER_FUNCTIONSIG) {
         freeResult(result);
     }
     assCore(st->u.set_function.name, tmp, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto error_;
     setResult(result, inter, belong);
     gc_freeTmpLink(&tmp->gc_status);
@@ -144,7 +144,7 @@ ResultType callBackCorePt(LinkValue *function_value, Parameter *pt, long line, c
     gc_addTmpLink(&function_value->gc_status);
 
     arg = getArgument(pt, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);
@@ -156,7 +156,7 @@ ResultType callBackCorePt(LinkValue *function_value, Parameter *pt, long line, c
     return result->type;
 }
 
-ResultType callBackCore(LinkValue *function_value, Argument *arg, long line, char *file, INTER_FUNCTIONSIG_NOT_ST){
+ResultType callBackCore(LinkValue *function_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST){
     setResultCore(result);
     gc_addTmpLink(&function_value->gc_status);
     if (function_value->value->type == function && function_value->value->data.function.type == vm_function)
@@ -173,7 +173,7 @@ ResultType callBackCore(LinkValue *function_value, Argument *arg, long line, cha
     return result->type;
 }
 
-ResultType callClass(LinkValue *class_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType callClass(LinkValue *class_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *_new_ = findAttributes(inter->data.object_new, false, class_value, inter);
     setResultCore(result);
 
@@ -188,7 +188,7 @@ ResultType callClass(LinkValue *class_value, Argument *arg, long int line, char
     return result->type;
 }
 
-ResultType callObject(LinkValue *object_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+ResultType callObject(LinkValue *object_value, Argument *arg, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *_call_ = findAttributes(inter->data.object_call, false, object_value, inter);
     setResultCore(result);
 
@@ -211,7 +211,7 @@ ResultType callCFunction(LinkValue *function_value, Argument *arg, long int line
     gc_addTmpLink(&function_value->gc_status);
 
     setFunctionArgument(&arg, function_value, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     of = function_value->value->data.function.of;
@@ -219,7 +219,7 @@ ResultType callCFunction(LinkValue *function_value, Argument *arg, long int line
     gc_freeze(inter, var_list, function_var, true);
 
     freeResult(result);
-    of(CALL_OfficialFunction(arg, function_var, result, function_value->belong));
+    of(CALL_OFFICAL_FUNCTION(arg, function_var, result, function_value->belong));
 
     gc_freeze(inter, var_list, function_var, false);
     freeFunctionArgument(arg, bak);
@@ -244,7 +244,7 @@ ResultType callVMFunction(LinkValue *function_value, Argument *arg, long int lin
     gc_freeze(inter, var_list, function_var, true);
 
     setFunctionArgument(&arg, function_value, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);
@@ -252,7 +252,7 @@ ResultType callVMFunction(LinkValue *function_value, Argument *arg, long int lin
     setParameterCore(line, file, arg, func_pt, function_var, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, function_value->belong));
     freeFunctionArgument(arg, bak);
     gc_freeTmpLink(&function_var->hashtable->gc_status);
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         gc_freeze(inter, var_list, function_var, false);
         funtion_st = function_value->value->data.function.function;
         if (yield_run)
@@ -303,7 +303,7 @@ ResultType setDecoration(DecorationStatement *ds, LinkValue *value, INTER_FUNCTI
         callBackCorePt(decall, pt, ds->decoration->line, ds->decoration->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         gc_freeTmpLink(&decall->gc_status);
         freeParameter(pt, true);
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             break;
 
         gc_freeTmpLink(&value->gc_status);

src/runfile.c

@@ -31,7 +31,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
     }
 
     functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(new_st, var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         setResultErrorSt(result, inter, NULL, NULL, st, belong, false);
 
     return_:
@@ -77,7 +77,7 @@ ResultType importFileCore(VarList **new_object, char **file_dir, INTER_FUNCTIONS
     }
 
     globalIterStatement(result, import_inter, run_st);
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         freeInter(import_inter, false);
         result->value = makeLinkValue(inter->base, belong, inter);  // 重新设定none值
         setResultErrorSt(result, inter, NULL, NULL, st, belong, false);
@@ -101,7 +101,7 @@ ResultType importFile(INTER_FUNCTIONSIG) {
     LinkValue *import_value = NULL;
     setResultCore(result);
     importFileCore(&new_object, &file_dir, CALL_INTER_FUNCTIONSIG(st->u.import_file.file, var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);
@@ -128,13 +128,13 @@ ResultType fromImportFile(INTER_FUNCTIONSIG) {
     Parameter *as = st->u.from_import_file.as != NULL ? st->u.from_import_file.as : st->u.from_import_file.pt;
     setResultCore(result);
     importFileCore(&new_object, &file_dir, CALL_INTER_FUNCTIONSIG(st->u.from_import_file.file, var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);
     if (pt != NULL) {
         setParameter(st->line, st->code_file, pt, as, var_list, belong, CALL_INTER_FUNCTIONSIG_NOT_ST(new_object, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto return_;
     }
     else

src/runoperation.c

@@ -68,7 +68,7 @@ ResultType blockOperation(INTER_FUNCTIONSIG) {
         else
             popVarList(var_list);
     }
-    if (run_continue(result) && st->aut != auto_aut)
+    if (CHECK_RESULT(result) && st->aut != auto_aut)
         result->value->aut = st->aut;
     return result->type;
 }
@@ -89,7 +89,7 @@ ResultType pointOperation(INTER_FUNCTIONSIG) {
 
     gc_freeze(inter, var_list, object, true);
     operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, object, result, left));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
     else if ((left->aut == public_aut || left->aut == auto_aut) && (result->value->aut != public_aut && result->value->aut != auto_aut))
         setResultErrorSt(result, inter, "PermissionsException", "Wrong Permissions: access variables as public", st,
@@ -158,7 +158,7 @@ ResultType varAss(Statement *name, LinkValue *value, bool check_aut, INTER_FUNCT
     int int_times = 0;
     LinkValue *var_value = NULL;
     getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, belong));
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         memFree(str_name);
         return result->type;
     }
@@ -207,12 +207,12 @@ ResultType listAss(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST)
 
     pt = makeArgsParameter(tmp_st);
     call = getArgument(pt, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result))
+    if (!CHECK_RESULT(result))
         goto return_;
 
     freeResult(result);
     setParameterCore(name->line, name->code_file, call, name->u.base_list.list, var_list, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (run_continue(result)){
+    if (CHECK_RESULT(result)){
         Argument *tmp = call;
         LinkValue *new_value = makeLinkValue(makeListValue(&tmp, inter, value_tuple), belong, inter);
         freeResult(result);
@@ -238,7 +238,7 @@ ResultType downAss(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST)
         Argument *arg = makeValueArgument(value);
         gc_addTmpLink(&_down_assignment_->gc_status);
         arg->next = getArgument(pt, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             goto daerror_;
 
         freeResult(result);
@@ -280,7 +280,7 @@ ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
 
     freeResult(result);
     var_info(&name, &int_times, CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         memFree(name);
         return result->type;
     }
@@ -353,7 +353,7 @@ ResultType getList(INTER_FUNCTIONSIG) {
     setResultCore(result);
     at = getArgument(st->u.base_list.list, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     at_tmp = at;
-    if (!run_continue(result)){
+    if (!CHECK_RESULT(result)){
         freeArgument(at_tmp, false);
         return result->type;
     }
@@ -372,14 +372,14 @@ ResultType getDict(INTER_FUNCTIONSIG) {
     setResultCore(result);
     at = getArgument(st->u.base_dict.dict, true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     at_tmp = at;
-    if (!run_continue(result)){
+    if (!CHECK_RESULT(result)){
         freeArgument(at_tmp, false);
         return result->type;
     }
 
     freeResult(result);
     Value *tmp_value = makeDictValue(&at, true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    if (!run_continue(result)) {
+    if (!CHECK_RESULT(result)) {
         freeArgument(at_tmp, false);
         return result->type;
     }
@@ -406,7 +406,7 @@ ResultType setDefault(INTER_FUNCTIONSIG){
         int times = 0;
         freeResult(result);
         getVarInfo(&name, &times, CALL_INTER_FUNCTIONSIG(pt->data.value, var_list, result, belong));
-        if (!run_continue(result))
+        if (!CHECK_RESULT(result))
             break;
         if (type != default_)
             times = base;

src/statement.c

@@ -349,7 +349,7 @@ void connectStatement(Statement *base, Statement *new){
 
 void freeStatement(Statement *st){
     Statement *next_tmp = NULL;
-    freeBase(st, return_);
+    FREE_BASE(st, return_);
     for (PASS; st != NULL; st = next_tmp){
         next_tmp = st->next;
         switch (st->type) {

src/value.c

@@ -59,7 +59,7 @@ Value *makePassValue(Inter *inter){
     return tmp;
 }
 
-Value *makeNumberValue(NUMBER_TYPE num, Inter *inter) {
+Value *makeNumberValue(vnum num, Inter *inter) {
     Inherit *object_father = getInheritFromValue(inter->data.num, inter);
     VarList *new_var = copyVarList(inter->data.num->object.out_var, false, inter);
     Value *tmp;
@@ -159,7 +159,7 @@ Value *makeDictValue(Argument **arg_ad, bool new_hash, INTER_FUNCTIONSIG_NOT_ST)
 
 void freeValue(Value **value) {
     Value *free_value = *value;
-    freeBase(free_value, return_);
+    FREE_BASE(free_value, return_);
     for (VarList *tmp = free_value->object.var; tmp != NULL; tmp = freeVarList(tmp))
         PASS;
     for (VarList *tmp = free_value->object.out_var; tmp != NULL; tmp = freeVarList(tmp))
@@ -216,7 +216,7 @@ LinkValue *makeLinkValue(Value *value, LinkValue *belong, Inter *inter){
 
 void freeLinkValue(LinkValue **value) {
     LinkValue *free_value = *value;
-    freeBase(free_value, return_);
+    FREE_BASE(free_value, return_);
 
     if ((*value)->gc_next != NULL)
         (*value)->gc_next->gc_last = (*value)->gc_last;
@@ -259,7 +259,7 @@ void setResultErrorSt(Result *ru, Inter *inter, char *error_type, char *error_me
     setResultError(ru, inter, error_type, error_message, st->line, st->code_file, belong, new);
 }
 
-void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, long int line, char *file, LinkValue *belong, bool new) {
+void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, fline line, char *file, LinkValue *belong, bool new) {
     if (!new && ru->type != error_return)
         return;
     if (new) {
@@ -310,7 +310,7 @@ void freeResultSafe(Result *ru){
 void printValue(Value *value, FILE *debug, bool print_father) {
     switch (value->type){
         case number:
-            fprintf(debug, "%"NUMBER_FORMAT"", value->data.num.num);
+            fprintf(debug, "%lld", value->data.num.num);
             break;
         case string:
             fprintf(debug, "%s", value->data.str.str);
@@ -401,7 +401,7 @@ void printLinkValue(LinkValue *value, char *first, char *last, FILE *debug){
     fprintf(debug, "%s", last);
 }
 
-Error *makeError(char *type, char *message, long int line, char *file) {
+Error *makeError(char *type, char *message, fline line, char *file) {
     Error *tmp = memCalloc(1, sizeof(Error));
     tmp->line = line;
     tmp->type = memStrcpy(type);
@@ -431,9 +431,9 @@ 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)
-            fprintf(inter->data.inter_stderr, "Error Backtracking:  On Line: %ld In file: %s Error ID: %p\n", base->line, base->file, base);
+            fprintf(inter->data.inter_stderr, "Error Backtracking:  On Line: %lld In file: %s Error ID: %p\n", base->line, base->file, base);
         else
-            fprintf(inter->data.inter_stderr, "%s\n%s\nOn Line: %ld\nIn File: %s\nError ID: %p\n", base->type, base->messgae, base->line, base->file, base);
+            fprintf(inter->data.inter_stderr, "%s\n%s\nOn Line: %lld\nIn File: %s\nError ID: %p\n", base->type, base->messgae, base->line, base->file, base);
     }
     if (free)
         freeError(result);
@@ -468,7 +468,7 @@ Inherit *copyInherit(Inherit *value){
 }
 
 Inherit *freeInherit(Inherit *value){
-    freeBase(value, error_);
+    FREE_BASE(value, error_);
     Inherit *next = value->next;
     memFree(value);
     return next;

src/var.c

@@ -30,7 +30,7 @@ Var *makeVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter) {
 
 void freeVar(Var **var) {
     Var *free_value = *var;
-    freeBase(free_value, return_);
+    FREE_BASE(free_value, return_);
     memFree(free_value->name);
 
     if ((*var)->gc_next != NULL)
@@ -67,7 +67,7 @@ HashTable *makeHashTable(Inter *inter) {
 
 void freeHashTable(HashTable **value) {
     HashTable *free_value = *value;
-    freeBase(free_value, return_);
+    FREE_BASE(free_value, return_);
     memFree(free_value->hashtable);
 
     if ((*value)->gc_next != NULL)
@@ -91,7 +91,7 @@ VarList *makeVarList(Inter *inter, bool make_hash) {
 
 VarList *freeVarList(VarList *vl) {
     VarList *next_var = NULL;
-    freeBase(vl, return_);
+    FREE_BASE(vl, return_);
     next_var = vl->next;
     for (PASS; vl->default_var != NULL; vl->default_var = freeDefaultVar(vl->default_var))
         PASS;
@@ -100,7 +100,7 @@ VarList *freeVarList(VarList *vl) {
     return next_var;
 }
 
-DefaultVar *makeDefaultVar(char *name, NUMBER_TYPE times) {
+DefaultVar *makeDefaultVar(char *name, vnum times) {
     DefaultVar *tmp;
     tmp = memCalloc(1, sizeof(DefaultVar));
     tmp->name = memStrcpy(name);
@@ -116,7 +116,7 @@ DefaultVar *freeDefaultVar(DefaultVar *dv) {
     return next;
 }
 
-DefaultVar *connectDefaultVar(DefaultVar *base, char *name, NUMBER_TYPE times) {
+DefaultVar *connectDefaultVar(DefaultVar *base, char *name, vnum times) {
     for (DefaultVar **tmp = &base; PASS; tmp = &(*tmp)->next){
         if (*tmp == NULL){
             *tmp = makeDefaultVar(name, times);
@@ -130,7 +130,7 @@ DefaultVar *connectDefaultVar(DefaultVar *base, char *name, NUMBER_TYPE times) {
     return base;
 }
 
-NUMBER_TYPE findDefault(DefaultVar *base, char *name) {
+vnum findDefault(DefaultVar *base, char *name) {
     for (DefaultVar **tmp = &base; *tmp != NULL; tmp = &(*tmp)->next)
         if (eqString((*tmp)->name, name))
             return (*tmp)->times;
@@ -142,11 +142,11 @@ NUMBER_TYPE findDefault(DefaultVar *base, char *name) {
  * @param key
  * @return
  */
-HASH_INDEX time33(char *key){ // hash function
-    HASH_INDEX hash = 5381;
+vhashn time33(char *key){ // hash function
+    vhashn hash = 5381;
     while(*key)
-        hash += (hash << (HASH_INDEX)5) + (*key++);
-    return (hash & (HASH_INDEX)0x7FFFFFFF) % MAX_SIZE;
+        hash += (hash << (vhashn)5) + (*key++);
+    return (hash & (vhashn)0x7FFFFFFF) % MAX_SIZE;
 }
 
 void addVarCore(Var **base, char *name, LinkValue *value, LinkValue *name_, Inter *inter) {
@@ -163,7 +163,7 @@ void addVarCore(Var **base, char *name, LinkValue *value, LinkValue *name_, Inte
 }
 
 void addVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht) {
-    HASH_INDEX index = time33(name);
+    vhashn index = time33(name);
     addVarCore(&ht->hashtable[index], name, value, name_, inter);
 }
 
@@ -176,7 +176,7 @@ void updateHashTable(HashTable *update, HashTable *new, Inter *inter) {
 
 LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht) {
     LinkValue *tmp = NULL;
-    HASH_INDEX index = time33(name);
+    vhashn index = time33(name);
 
     for (Var **base = &ht->hashtable[index]; *base != NULL; base = &(*base)->next){
         if (eqString((*base)->name, name)){
@@ -200,10 +200,10 @@ LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *
  * @param var_list
  * @return
  */
-LinkValue *findFromVarList(char *name, NUMBER_TYPE times, VarOperation operating, INTER_FUNCTIONSIG_CORE) {
+LinkValue *findFromVarList(char *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE) {
     LinkValue *tmp = NULL;
-    NUMBER_TYPE base = findDefault(var_list->default_var, name) + times;
-    for (NUMBER_TYPE i = 0; i < base && var_list->next != NULL; i++)
+    vnum base = findDefault(var_list->default_var, name) + times;
+    for (vnum i = 0; i < base && var_list->next != NULL; i++)
         var_list = var_list->next;
     if (operating == del_var && var_list != NULL)
         tmp = findVar(name, true, inter, var_list->hashtable);
@@ -213,9 +213,9 @@ LinkValue *findFromVarList(char *name, NUMBER_TYPE times, VarOperation operating
     return tmp;
 }
 
-void addFromVarList(char *name, LinkValue *name_, NUMBER_TYPE times, LinkValue *value, INTER_FUNCTIONSIG_CORE) {
-    NUMBER_TYPE base = findDefault(var_list->default_var, name) + times;
-    for (NUMBER_TYPE i = 0; i < base && var_list->next != NULL; i++)
+void addFromVarList(char *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE) {
+    vnum base = findDefault(var_list->default_var, name) + times;
+    for (vnum i = 0; i < base && var_list->next != NULL; i++)
         var_list = var_list->next;
     addVar(name, value, name_, inter, var_list->hashtable);
 }