feat: 加入了num等官方类

include/__macro.h

@@ -26,5 +26,4 @@
 #define CALL_OfficialFunction(arg, var_list, result, father) arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father)
 #define RegisteredFunctionSig struct LinkValue *father, INTER_FUNCTIONSIG_CORE
 #define CALL_RegisteredFunction(father, var_list) father, CALL_INTER_FUNCTIONSIG_CORE(var_list)
-
 #endif //VIRTUALMATH___MACRO_H

include/inter.h

@@ -13,6 +13,14 @@ struct Inter{
     struct VarList *var_list;
     struct InterData{
         struct Value *object;
+        struct Value *vobject;
+        struct Value *num;
+        struct Value *str;
+        struct Value *bool_;
+        struct Value *pass_;
+        struct Value *list;
+        struct Value *dict;
+        struct Value *function;
         struct Value *none;
         FILE *debug;
         FILE *error;
@@ -24,6 +32,10 @@ struct Inter{
         char *object_new;
         char *object_enter;
         char *object_exit;
+        char *object_add;
+        char *object_sub;
+        char *object_mul;
+        char *object_div;
     } data;
 };
 

include/ofunc.h

@@ -3,7 +3,15 @@
 #include "__macro.h"
 #include "io.h"
 #include "object.h"
+#include "vobject.h"
 #include "sys.h"
+#include "num.h"
+#include "str.h"
+#include "bool.h"
+#include "pass.h"
+#include "list.h"
+#include "dict.h"
+#include "function.h"
 
 struct Argument;
 struct VarList;
@@ -17,5 +25,5 @@ struct NameFunc{
 typedef struct NameFunc NameFunc;
 
 void registeredBaseFunction(struct LinkValue *father, Inter *inter);
-
+void registeredFunctionName(Inter *inter);
 #endif //VIRTUALMATH_OFUNC_H

include/value.h

@@ -57,8 +57,8 @@ struct Value{
                 enum FunctionPtType{
                     free_,  // 不包含任何隐式传递的参数
                     static_,  // 不包含self参数
-                    object_static_,  // self参数允许一切father
-                    class_static_,  // self参数不允许class
+                    object_static_,  // self参数不允许class
+                    class_static_,  // self参数允许一切father
                     object_free_,  // 同object_static_但不包含func参数
                     class_free_,  // 同object_static_但不包含func参数
                 } pt_type;
@@ -177,4 +177,5 @@ FatherValue *freeFatherValue(FatherValue *value);
 FatherValue *connectFatherValue(FatherValue *base, FatherValue *back);
 FatherValue *connectSafeFatherValue(FatherValue *base, FatherValue *back);
 bool checkAttribution(Value *self, Value *father);
+FatherValue *getFatherFromValue(Value *value, Inter *inter);
 #endif //VIRTUALMATH_VALUE_H

ofunc/include/__ofunc.h

@@ -7,5 +7,6 @@
 
 LinkValue *registeredFunctionCore(OfficialFunction of, char *name, struct LinkValue *father, INTER_FUNCTIONSIG_CORE);
 void iterNameFunc(NameFunc list[],struct LinkValue *father, INTER_FUNCTIONSIG_CORE);
+Value *makeBaseChildClass(Value *father, Inter *inter);
 
 #endif //VIRTUALMATH___OFUNC_H

ofunc/include/bool.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_BOOL_H
+#define VIRTUALMATH_BOOL_H
+#include "__macro.h"
+
+void registeredBool(RegisteredFunctionSig);
+void makeBaseBool(Inter *inter);
+#endif //VIRTUALMATH_BOOL_H

ofunc/include/dict.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_DICT_H
+#define VIRTUALMATH_DICT_H
+#include "__macro.h"
+
+void registeredDict(RegisteredFunctionSig);
+void makeBaseDict(Inter *inter);
+#endif //VIRTUALMATH_DICT_H

ofunc/include/function.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_FUNCTION_H
+#define VIRTUALMATH_FUNCTION_H
+#include "__macro.h"
+
+void registeredFunction(RegisteredFunctionSig);
+void makeBaseFunction(Inter *inter);
+#endif //VIRTUALMATH_FUNCTION_H

ofunc/include/list.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_LIST_H
+#define VIRTUALMATH_LIST_H
+#include "__macro.h"
+
+void registeredList(RegisteredFunctionSig);
+void makeBaseList(Inter *inter);
+#endif //VIRTUALMATH_BOOL_H

ofunc/include/num.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_NUM_H
+#define VIRTUALMATH_NUM_H
+#include "__macro.h"
+
+void registeredNum(RegisteredFunctionSig);
+void makeBaseNum(Inter *inter);
+#endif //VIRTUALMATH_NUM_H

ofunc/include/pass.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_PASS_H
+#define VIRTUALMATH_PASS_H
+#include "__macro.h"
+
+void registeredEllipisis(RegisteredFunctionSig);
+void makeBaseEllipisis(Inter *inter);
+#endif //VIRTUALMATH_PASS_H

ofunc/include/str.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_STR_H
+#define VIRTUALMATH_STR_H
+#include "__macro.h"
+
+void registeredStr(RegisteredFunctionSig);
+void makeBaseStr(Inter *inter);
+#endif //VIRTUALMATH_STR_H

ofunc/include/vobject.h

@@ -0,0 +1,7 @@
+#ifndef VIRTUALMATH_VOBJECT_H
+#define VIRTUALMATH_VOBJECT_H
+#include "__macro.h"
+
+void registeredVObject(RegisteredFunctionSig);
+void makeBaseVObject(Inter *inter);
+#endif //VIRTUALMATH_VOBJECT_H

ofunc/src/__ofunc.c

@@ -1,13 +1,8 @@
 #include "__ofunc.h"
 
-LinkValue *registeredFunctionCore(OfficialFunction of, char *name, struct LinkValue *father, INTER_FUNCTIONSIG_CORE) {
-    LinkValue *value = NULL;
-    LinkValue *name_ = NULL;
-    char *var_name = setStrVarName(name, false, inter);
-    name_ = makeLinkValue(makeStringValue(var_name, inter), father, inter);
-    value = makeLinkValue(makeCFunctionValue(of, var_list, inter), father, inter);
-    addFromVarList(var_name, name_, 0, value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-    memFree(var_name);
+LinkValue *registeredFunctionCore(OfficialFunction of, char *name, LinkValue *father, INTER_FUNCTIONSIG_CORE) {
+    LinkValue *value = makeLinkValue(makeCFunctionValue(of, var_list, inter), father, inter);
+    addStrVar(name, false, value, father, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     return value;
 }
 
@@ -17,3 +12,18 @@ void iterNameFunc(NameFunc list[], LinkValue *father, INTER_FUNCTIONSIG_CORE){
         value->value->data.function.function_data.pt_type = list->type;
     }
 }
+
+Value *makeBaseChildClass(Value *father, Inter *inter) {
+    FatherValue *father_value = NULL;
+    Value *num = NULL;
+    {
+        LinkValue *father_ = makeLinkValue(father, inter->base_father, inter);
+        Argument *arg = makeValueArgument(father_);
+        gc_addTmpLink(&father_->gc_status);
+        father_value = setFather(arg);
+        freeArgument(arg, true);
+        gc_freeTmpLink(&father_->gc_status);
+    }
+    num = makeClassValue(copyVarList(inter->var_list, false, inter), inter, father_value);
+    return num;
+}

ofunc/src/bool.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredBool(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.bool_, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("bool", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseBool(Inter *inter){
+    Value *bool_ = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&bool_->gc_status);
+    inter->data.bool_ = bool_;
+}

ofunc/src/dict.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredDict(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.dict, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("dict", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseDict(Inter *inter){
+    Value *dict = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&dict->gc_status);
+    inter->data.dict = dict;
+}

ofunc/src/function.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredFunction(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.function, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("function", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseFunction(Inter *inter){
+    Value *function = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&function->gc_status);
+    inter->data.function = function;
+}

ofunc/src/io.c

@@ -19,7 +19,11 @@ ResultType vm_print(OfficialFunctionSig){
 
     arg = ap[0].arg;
     for (int i=0; i < ap[0].c_count; arg = arg->next,i++)
+#if 0
+        printLinkValue(arg->data.value, "", "", stdout);
+#else
         printValue(arg->data.value->value, stdout, true);
+#endif
 
     if (ap[1].value != NULL && ap[1].value->value->type == string)
         printf("%s", ap[1].value->value->data.str.str);

ofunc/src/list.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredList(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.list, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("list", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseList(Inter *inter){
+    Value *list = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&list->gc_status);
+    inter->data.list = list;
+}

ofunc/src/num.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredNum(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.num, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("num", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseNum(Inter *inter){
+    Value *num = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&num->gc_status);
+    inter->data.num = num;
+}

ofunc/src/object.c

@@ -26,9 +26,7 @@ ResultType object_new_(OfficialFunctionSig){
         setResultOperation(result, value);
     }
 
-    char *init_name = setStrVarName(inter->data.object_init, false, inter);
-    _init_ = findFromVarList(init_name, 0, false, CALL_INTER_FUNCTIONSIG_CORE(value->value->object.var));
-    memFree(init_name);
+    _init_ = findAttributes(inter->data.object_init, false, value, inter);
 
     if (_init_ != NULL){
         Result _init_result;
@@ -51,21 +49,18 @@ ResultType object_new_(OfficialFunctionSig){
 }
 
 void registeredObject(RegisteredFunctionSig){
-    Value *object = inter->data.object;
-    VarList *object_var = object->object.var;
-    LinkValue *name_ = NULL;
-    char *name = NULL;
+    LinkValue *object = makeLinkValue(inter->data.object, inter->base_father, inter);
+    VarList *object_var = object->value->object.var;
+    VarList *object_backup = NULL;
     NameFunc tmp[] = {{"__new__", object_new_, class_static_}, {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
+    addStrVar("object", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
 
+    object_backup = object_var->next;
     object_var->next = inter->var_list;
-    iterNameFunc(tmp, father, CALL_INTER_FUNCTIONSIG_CORE(object_var));
-    object_var->next = NULL;
+    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+    object_var->next = object_backup;
 
-    name = setStrVarName("object", false, inter);
-    name_ = makeLinkValue(makeStringValue(name, inter), father, inter);
-    addFromVarList(name, name_, 0, makeLinkValue(object, father, inter), CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
-    memFree(name);
     gc_freeTmpLink(&object->gc_status);
 }
 

ofunc/src/pass.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredEllipisis(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.pass_, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("ellipsis", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseEllipisis(Inter *inter){
+    Value *pass_ = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&pass_->gc_status);
+    inter->data.pass_ = pass_;
+}

ofunc/src/str.c

@@ -0,0 +1,23 @@
+#include "__ofunc.h"
+
+void registeredStr(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.str, inter->base_father, inter);
+//    VarList *object_var = object->value->object.var;
+//    VarList *object_backup = NULL;
+//    NameFunc tmp[] = {{NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("str", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+//    object_backup = object_var->next;
+//    object_var->next = inter->var_list;
+//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+//    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseStr(Inter *inter){
+    Value *str = makeBaseChildClass(inter->data.vobject, inter);
+    gc_addStatementLink(&str->gc_status);
+    inter->data.str = str;
+}

ofunc/src/sys.c

@@ -4,10 +4,10 @@ ResultType vm_super(OfficialFunctionSig){
     Value *arg_father = NULL;
     Value *arg_child = NULL;
     LinkValue *next_father = NULL;
-    setResultCore(result);
     ArgumentParser ap[] = {{.type=name_value, .name="class_", .must=1, .long_arg=false},
                            {.type=name_value, .name="obj_", .must=1, .long_arg=false},
                            {.must=-1}};
+    setResultCore(result);
     {
         parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
         if (!run_continue(result))
@@ -46,7 +46,56 @@ ResultType vm_super(OfficialFunctionSig){
     return result->type;
 }
 
+ResultType vm_setMethodCore(OfficialFunctionSig, 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, father));
+        if (!run_continue(result))
+            return result->type;
+        freeResult(result);
+    }
+    function_value = ap[0].value;
+    function_value->value->data.function.function_data.pt_type = type;
+    result->value = function_value;
+    gc_addTmpLink(&result->value->gc_status);
+    result->type = operation_return;
+    return operation_return;
+}
+
+ResultType vm_freemethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), free_);
+}
+
+ResultType vm_staticmethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), static_);
+}
+
+ResultType vm_classmethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), class_static_);
+}
+
+ResultType vm_objectmethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), object_static_);
+}
+
+ResultType vm_classfreemethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), class_free_);
+}
+
+ResultType vm_objectfreemethod(OfficialFunctionSig){
+    return vm_setMethodCore(CALL_OfficialFunction(arg, var_list, result, father), object_free_);
+}
+
 void registeredSysFunction(RegisteredFunctionSig){
-    NameFunc tmp[] = {{"super", vm_super, free_}, {NULL, NULL}};
+    NameFunc tmp[] = {{"super", vm_super, free_},
+                      {"freemethod", vm_freemethod, free_},
+                      {"staticmethod", vm_staticmethod, free_},
+                      {"staticclassmethod", vm_classmethod, free_},
+                      {"staticobjectmethod", vm_objectmethod, free_},
+                      {"classmethod", vm_classfreemethod, free_},
+                      {"objectmethod", vm_objectfreemethod, free_},
+                      {NULL, NULL}};
     iterNameFunc(tmp, father, CALL_INTER_FUNCTIONSIG_CORE(var_list));
 }

ofunc/src/vobject.c

@@ -0,0 +1,115 @@
+#include "__ofunc.h"
+
+typedef void (*base_opt)(LinkValue *, Result *, struct Inter *, Value *, Value *);
+
+void vobject_add_base(LinkValue *father, Result *result, struct Inter *inter, Value *left, Value *right) {
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
+    if (left->type == number && right->type == number)
+        result->value->value = makeNumberValue(left->data.num.num + right->data.num.num, inter);
+    else if(left->type == string && right->type == string){
+        char *new_string = memStrcat(left->data.str.str, right->data.str.str, false, false);
+        result->value->value = makeStringValue(new_string, inter);
+        memFree(new_string);
+    }
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", 0, "sys", father, true);
+}
+
+void vobject_sub_base(LinkValue *father, Result *result, struct Inter *inter, Value *left, Value *right) {
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
+    if (left->type == number && right->type == number)
+        result->value->value = makeNumberValue(left->data.num.num - right->data.num.num, inter);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", 0, "sys", father, true);
+}
+
+void vobject_mul_base(LinkValue *father, Result *result, struct Inter *inter, Value *left, Value *right) {
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
+    if (left->type == number && right->type == number)
+        result->value->value = makeNumberValue(left->data.num.num * right->data.num.num, inter);
+    else if(left->type == number && right->type == string) {
+        Value *tmp = left;
+        left = right;
+        right = tmp;
+        goto mul_str;
+    }
+    else if(left->type == string && right->type == number) mul_str: {
+        char *new_string = memStrcpySelf(left->data.str.str, right->data.num.num);
+        result->value->value = makeStringValue(new_string, inter);
+        memFree(new_string);
+    }
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", 0, "sys", father, true);
+}
+
+void vobject_div_base(LinkValue *father, Result *result, struct Inter *inter, Value *left, Value *right) {
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
+    if (left->type == number && right->type == number)
+        result->value->value = makeNumberValue(left->data.num.num / right->data.num.num, inter);
+    else
+        setResultError(result, inter, "TypeException", "Get Not Support Value", 0, "sys", father, true);
+}
+
+ResultType vobject_opt_core(OfficialFunctionSig, base_opt func){
+    Value *left = NULL;
+    Value *right = NULL;
+    ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
+                           {.type=name_value, .name="left", .must=1, .long_arg=false},
+                           {.must=-1}};
+    setResultCore(result);
+    {
+        parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
+        if (!run_continue(result))
+            return result->type;
+        freeResult(result);
+    }
+
+    left = ap[0].value->value;
+    right = ap[1].value->value;
+
+    func(father, result, inter, left, right);
+
+    return result->type;
+}
+
+ResultType vobject_add(OfficialFunctionSig){
+    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, father), vobject_add_base);
+}
+
+ResultType vobject_sub(OfficialFunctionSig){
+    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, father), vobject_sub_base);
+}
+
+ResultType vobject_mul(OfficialFunctionSig){
+    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, father), vobject_mul_base);
+}
+
+ResultType vobject_div(OfficialFunctionSig){
+    return vobject_opt_core(CALL_OfficialFunction(arg, var_list, result, father), vobject_div_base);
+}
+
+void registeredVObject(RegisteredFunctionSig){
+    LinkValue *object = makeLinkValue(inter->data.vobject, inter->base_father, inter);
+    VarList *object_var = object->value->object.var;
+    VarList *object_backup = NULL;
+    NameFunc tmp[] = {{"__add__", vobject_add, object_free_},
+                      {"__sub__", vobject_sub, object_free_},
+                      {"__mul__", vobject_mul, object_free_},
+                      {"__div__", vobject_div, object_free_},
+                      {NULL, NULL}};
+    gc_addTmpLink(&object->gc_status);
+    addStrVar("vobject", false, object, father, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
+
+    object_backup = object_var->next;
+    object_var->next = inter->var_list;
+    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+    object_var->next = object_backup;
+
+    gc_freeTmpLink(&object->gc_status);
+}
+
+void makeBaseVObject(Inter *inter){
+    Value *vobject = makeClassValue(copyVarList(inter->var_list, false, inter), inter, NULL);
+    gc_addStatementLink(&vobject->gc_status);
+    inter->data.vobject = vobject;
+}

src/__run.c

@@ -174,11 +174,33 @@ ResultType setFunctionArgument(Argument **arg, LinkValue *function_value, long l
 }
 
 void freeFunctionArgument(Argument *arg, Argument *base) {
-    for (Argument *tmp = arg; tmp != NULL && tmp->next != NULL; tmp = tmp->next) {
+    for (Argument *tmp = arg; tmp != NULL; tmp = tmp->next) {
         if (tmp->next == base) {
             tmp->next = NULL;
             freeArgument(arg, true);
             break;
         }
     }
-}
+}
+
+LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
+    LinkValue *tmp = NULL;
+    char *name_ = setStrVarName(name, free_old, inter);
+    tmp = findFromVarList(name_, 0, false, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    memFree(name_);
+    return tmp;
+}
+
+void addStrVar(char *name, bool free_old, LinkValue *value, LinkValue *father, INTER_FUNCTIONSIG_CORE){
+    char *var_name = setStrVarName(name, free_old, inter);
+    LinkValue *name_ = makeLinkValue(makeStringValue(var_name, inter), father, inter);
+    addFromVarList(var_name, name_, 0, value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    memFree(var_name);
+}
+
+LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *inter) {
+    LinkValue *attr = findStrVar(name, free_old, CALL_INTER_FUNCTIONSIG_CORE(value->value->object.var));
+    if (attr != NULL && attr->father->value != value->value && checkAttribution(value->value, attr->father->value))
+        attr->father = value;
+    return attr;
+}

src/include/__run.h

@@ -29,5 +29,7 @@ void newWithBranchYield(Statement *branch_st, Statement *node, StatementList *sl
 
 ResultType setFunctionArgument(struct Argument **arg, LinkValue *function_value, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 void freeFunctionArgument(Argument *arg, Argument *base);
-
+LinkValue *findStrVar(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);
 #endif //VIRTUALMATH___RUN_H

src/inter.c

@@ -28,7 +28,7 @@ Inter *makeInter(char *debug, LinkValue *father) {
         tmp->data.error = stderr;
     }
 
-    makeBaseObject(tmp);
+    registeredFunctionName(tmp);
 
     tmp->data.none = makeNoneValue(tmp);
     gc_addStatementLink(&tmp->data.none->gc_status);
@@ -47,6 +47,9 @@ Inter *makeInter(char *debug, LinkValue *father) {
 
 void setBaseInterData(struct Inter *inter){
     inter->data.object = NULL;
+    inter->data.vobject = NULL;
+    inter->data.num = NULL;
+    inter->data.str = NULL;
     inter->data.none = NULL;
     inter->data.var_str_prefix = memStrcpy("str_");
     inter->data.var_num_prefix = memStrcpy("num_");
@@ -55,11 +58,23 @@ void setBaseInterData(struct Inter *inter){
     inter->data.object_enter = memStrcpy("__enter__");
     inter->data.object_exit = memStrcpy("__exit__");
     inter->data.object_new = memStrcpy("__new__");
+    inter->data.object_add = memStrcpy("__add__");
+    inter->data.object_sub = memStrcpy("__sub__");
+    inter->data.object_mul = memStrcpy("__mul__");
+    inter->data.object_div = memStrcpy("__div__");
+
 }
 
 void freeBaseInterData(struct Inter *inter){
-    gc_freeStatementLink(&inter->data.none->gc_status);
     gc_freeStatementLink(&inter->data.object->gc_status);
+    gc_freeStatementLink(&inter->data.vobject->gc_status);
+    gc_freeStatementLink(&inter->data.num->gc_status);
+    gc_freeStatementLink(&inter->data.str->gc_status);
+    gc_freeStatementLink(&inter->data.bool_->gc_status);
+    gc_freeStatementLink(&inter->data.function->gc_status);
+    gc_freeStatementLink(&inter->data.pass_->gc_status);
+    gc_freeStatementLink(&inter->data.list->gc_status);
+    gc_freeStatementLink(&inter->data.dict->gc_status);
     memFree(inter->data.var_num_prefix);
     memFree(inter->data.var_str_prefix);
     memFree(inter->data.var_defualt);
@@ -67,6 +82,10 @@ void freeBaseInterData(struct Inter *inter){
     memFree(inter->data.object_enter);
     memFree(inter->data.object_exit);
     memFree(inter->data.object_new);
+    memFree(inter->data.object_add);
+    memFree(inter->data.object_sub);
+    memFree(inter->data.object_mul);
+    memFree(inter->data.object_div);
 
     memFree(inter->data.log_dir);
     if (inter->data.log_dir != NULL) {
@@ -160,8 +179,8 @@ void printLinkValueGC(char *tag, Inter *inter, long *tmp_link, long *st_link) {
     long st = 0;
     printf("%s\n", tag);
     while (base != NULL) {
-        tmp += base->gc_status.tmp_link;
-        st += base->gc_status.statement_link;
+        tmp += labs(base->gc_status.tmp_link);
+        st += labs(base->gc_status.statement_link);
         printf("inter->link_base.tmp_link       = %ld :: %p\n", base->gc_status.tmp_link, base);
         printf("inter->link_base.statement_link = %ld :: %p\n", base->gc_status.statement_link, base);
         printf("inter->link_base.link           = %ld :: %p\n", base->gc_status.link, base);
@@ -184,8 +203,8 @@ void printValueGC(char *tag, Inter *inter, long *tmp_link, long *st_link) {
     long st = 0;
     printf("%s\n", tag);
     while (base != NULL) {
-        tmp += base->gc_status.tmp_link;
-        st += base->gc_status.statement_link;
+        tmp += labs(base->gc_status.tmp_link);
+        st += labs(base->gc_status.statement_link);
         printf("inter->link_base.tmp_link       = %ld :: %p\n", base->gc_status.tmp_link, base);
         printf("inter->link_base.statement_link = %ld :: %p\n", base->gc_status.statement_link, base);
         printf("inter->link_base.link           = %ld :: %p\n", base->gc_status.link, base);
@@ -225,7 +244,7 @@ void printHashTableGC(char *tag, Inter *inter, long *tmp_link) {
     long tmp = 0;
     printf("%s\n", tag);
     while (base != NULL) {
-        tmp += base->gc_status.tmp_link;
+        tmp += labs(base->gc_status.tmp_link);
         printf("inter->link_base.tmp_link       = %ld :: %p\n", base->gc_status.tmp_link, base);
         printf("inter->link_base.statement_link = %ld :: %p\n", base->gc_status.statement_link, base);
         printf("inter->link_base.link           = %ld :: %p\n", base->gc_status.link, base);

src/ofunc.c

@@ -1,11 +1,31 @@
 #include "__run.h"
 
 static Registered base_func_list[] = {registeredIOFunction,
-                                      registeredObject,
                                       registeredSysFunction,
+                                      registeredObject,
+                                      registeredVObject,
+                                      registeredNum,
+                                      registeredStr,
+                                      registeredBool,
+                                      registeredEllipisis,
+                                      registeredFunction,
+                                      registeredDict,
+                                      registeredList,
                                       NULL};
 
 void registeredBaseFunction(struct LinkValue *father, Inter *inter){
     for (Registered *list = base_func_list; *list != NULL; list++)
         (*list)(CALL_RegisteredFunction(father, inter->var_list));
 }
+
+void registeredFunctionName(Inter *inter){
+    makeBaseObject(inter);
+    makeBaseVObject(inter);
+    makeBaseNum(inter);
+    makeBaseStr(inter);
+    makeBaseBool(inter);
+    makeBaseEllipisis(inter);
+    makeBaseFunction(inter);
+    makeBaseDict(inter);
+    makeBaseList(inter);
+}

src/parameter.c

@@ -754,9 +754,7 @@ Argument *parserArgumentValueCore(Argument *arg, ArgumentParser *ap){
 }
 
 int parserArgumentVar(ArgumentParser *ap, Inter *inter, VarList *var_list){
-    char *str_name = setStrVarName(ap->name, false, inter);
-    LinkValue *value = findFromVarList(str_name, 0, true, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-    memFree(str_name);
+    LinkValue *value = findStrVar(ap->name, false, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     ap->value = value;
     if (value != NULL)
         return 1;

src/runbranch.c

@@ -377,18 +377,11 @@ ResultType withBranch(INTER_FUNCTIONSIG) {
             freeResult(result);
         } else {
             LinkValue *enter_value = NULL;
-            char *enter_name = NULL;
-            char *exit_name = NULL;
             value = result->value;
             result->value = NULL;
 
-            enter_name = setStrVarName(inter->data.object_enter, false, inter);
-            exit_name = setStrVarName(inter->data.object_exit, false, inter);
-            _enter_ = findFromVarList(enter_name, 0, false, CALL_INTER_FUNCTIONSIG_CORE(value->value->object.var));
-            _exit_ = findFromVarList(exit_name, 0, false, CALL_INTER_FUNCTIONSIG_CORE(value->value->object.var));
-            memFree(enter_name);
-            memFree(exit_name);
-
+            _enter_ = findAttributes(inter->data.object_enter, false, value, inter);
+            _exit_ = findAttributes(inter->data.object_exit, false, value, inter);
             freeResult(result);
             if (_enter_ == NULL || _exit_ == NULL) {
                 gc_freeTmpLink(&value->gc_status);

src/runcall.c

@@ -147,13 +147,9 @@ ResultType callBackCore(LinkValue *function_value, Argument *arg, long line, cha
 }
 
 ResultType callClass(LinkValue *class_value, Argument *arg, long int line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
-    LinkValue *_new_ = NULL;
+    LinkValue *_new_ = findAttributes(inter->data.object_new, false, class_value, inter);
     setResultCore(result);
 
-    char *init_name = setStrVarName(inter->data.object_new, false, inter);
-    _new_ = findFromVarList(init_name, 0, false, CALL_INTER_FUNCTIONSIG_CORE(class_value->value->object.var));
-    memFree(init_name);
-
     if (_new_ != NULL){
         _new_->father = class_value;
         gc_addTmpLink(&_new_->gc_status);

src/runfile.c

@@ -107,13 +107,8 @@ ResultType importFile(INTER_FUNCTIONSIG) {
     }
     if (st->u.import_file.as != NULL)
         assCore(st->u.import_file.as, import_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
-    else {
-        char *name = splitDir(file_dir);
-        char *value_name = setStrVarName(name, false, inter);
-        addFromVarList(value_name, makeLinkValue(makeStringValue(value_name, inter), father, inter), 0, import_value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
-        memFree(name);
-        memFree(value_name);
-    }
+    else
+        addStrVar(splitDir(file_dir), true, import_value, father, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     setResult(result, inter, father);
 
     return_:

src/runoperation.c

@@ -1,9 +1,7 @@
 #include "__run.h"
 
-ResultType addOperation(INTER_FUNCTIONSIG);
-ResultType subOperation(INTER_FUNCTIONSIG);
-ResultType mulOperation(INTER_FUNCTIONSIG);
-ResultType divOperation(INTER_FUNCTIONSIG);
+static bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG);
+static ResultType operationCore(INTER_FUNCTIONSIG, char *name);
 ResultType assOperation(INTER_FUNCTIONSIG);
 ResultType pointOperation(INTER_FUNCTIONSIG);
 ResultType blockOperation(INTER_FUNCTIONSIG);
@@ -19,16 +17,16 @@ ResultType operationStatement(INTER_FUNCTIONSIG) {
     setResultCore(result);
     switch (st->u.operation.OperationType) {
         case OPT_ADD:
-            addOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            operationCore(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), inter->data.object_add);
             break;
         case OPT_SUB:
-            subOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            operationCore(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), inter->data.object_sub);
             break;
         case OPT_MUL:
-            mulOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            operationCore(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), inter->data.object_mul);
             break;
         case OPT_DIV:
-            divOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            operationCore(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), inter->data.object_div);
             break;
         case OPT_ASS:
             assOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
@@ -46,115 +44,7 @@ ResultType operationStatement(INTER_FUNCTIONSIG) {
     return result->type;
 }
 
-bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG){
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.left, var_list, result, father)) || result->value->value->type == none)
-        return true;
-    *left = *result;
-    setResultCore(result);
-
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result, father)) || result->value->value->type == none)
-        return true;
-    *right = *result;
-    return false;
-}
-
-ResultType addOperation(INTER_FUNCTIONSIG) {
-    Result left;
-    Result right;
-    setResultCore(&left);
-    setResultCore(&right);
-
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
-        return result->type;
-
-    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
-    if (left.value->value->type == number && right.value->value->type == number)
-        result->value->value = makeNumberValue(left.value->value->data.num.num + right.value->value->data.num.num, inter);
-    else if(left.value->value->type == string && right.value->value->type == string){
-        char *new_string = memStrcat(left.value->value->data.str.str, right.value->value->data.str.str, false, false);
-        result->value->value = makeStringValue(new_string, inter);
-        memFree(new_string);
-    }
-    else
-        setResultErrorSt(result, inter, "TypeException", "Get Not Support Value", st, father, true);
-
-    freeResult(&left);
-    freeResult(&right);
-    return result->type;
-}
-
-ResultType subOperation(INTER_FUNCTIONSIG) {
-    Result left;
-    Result right;
-    setResultCore(&left);
-    setResultCore(&right);
-
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
-        return result->type;
-
-    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
-    if (left.value->value->type == number && right.value->value->type == number)
-        result->value->value = makeNumberValue(left.value->value->data.num.num - right.value->value->data.num.num, inter);
-    else
-        setResultErrorSt(result, inter, "TypeException", "Get Not Support Value", st, father, true);
-
-    freeResult(&left);
-    freeResult(&right);
-    return result->type;
-}
-
-ResultType mulOperation(INTER_FUNCTIONSIG) {
-    Result left;
-    Result right;
-    setResultCore(&left);
-    setResultCore(&right);
-
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
-        return result->type;
-
-    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
-    if (left.value->value->type == number && right.value->value->type == number)
-        result->value->value = makeNumberValue(left.value->value->data.num.num * right.value->value->data.num.num, inter);
-    else if(left.value->value->type == number && right.value->value->type == string) {
-        Result tmp = left;
-        left = right;
-        right = tmp;
-        goto mul_str;
-    }
-    else if(left.value->value->type == string && right.value->value->type == number) mul_str: {
-        char *new_string = memStrcpySelf(left.value->value->data.str.str, right.value->value->data.num.num);
-        result->value->value = makeStringValue(new_string, inter);
-        memFree(new_string);
-    }
-    else
-        setResultErrorSt(result, inter, "TypeException", "Get Not Support Value", st, father, true);
-
-    freeResult(&left);
-    freeResult(&right);
-    return result->type;
-}
-
-ResultType divOperation(INTER_FUNCTIONSIG) {
-    Result left;
-    Result right;
-    setResultCore(&left);
-    setResultCore(&right);
-
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
-        return result->type;
-
-    setResultOperationBase(result, makeLinkValue(NULL, father, inter));
-    if (left.value->value->type == number && right.value->value->type == number)
-        result->value->value = makeNumberValue(left.value->value->data.num.num / right.value->value->data.num.num, inter);
-    else
-        setResultErrorSt(result, inter, "TypeException", "Get Not Support Value", st, father, true);
-
-    freeResult(&left);
-    freeResult(&right);
-    return result->type;
-}
-
-ResultType blockOperation(INTER_FUNCTIONSIG) {  // TODO-szh 处理yield
+ResultType blockOperation(INTER_FUNCTIONSIG) {
     Statement *info_st = st->u.operation.left;
     bool yield_run;
     if ((yield_run = popStatementVarList(st, &var_list, var_list, inter)))
@@ -185,14 +75,14 @@ ResultType blockOperation(INTER_FUNCTIONSIG) {  // TODO-szh 处理yield
 
 ResultType pointOperation(INTER_FUNCTIONSIG) {
     LinkValue *left;
-
+    VarList *object = NULL;
+    VarList *out_var = NULL;
     if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.left, var_list, result, father)) || result->value->value->type == none)
         return result->type;
-
     left = result->value;
+
     setResultCore(result);
-    VarList *object = left->value->object.var;
-    VarList *out_var = NULL;
+    object = left->value->object.var;
     for (out_var = object; out_var->next != NULL; out_var = out_var->next)
         PASS;
     out_var->next = left->value->object.out_var;
@@ -208,16 +98,9 @@ ResultType pointOperation(INTER_FUNCTIONSIG) {
         setResultErrorSt(result, inter, "PermissionsException", "Wrong Permissions: access variables as protect", st,
                          father, true);
 
-    if (result->value->father->value != left->value && checkAttribution(left->value, result->value->father->value)) {
-        /**
-         * 若获得的值的father是left的father, 则将获得值的father调整为left (拷贝)
-         */
-        LinkValue *return_value = copyLinkValue(result->value, inter);
-        return_value->father = left;
-        gc_freeTmpLink(&result->value->gc_status);
-        gc_addTmpLink(&return_value->gc_status);
-        result->value = return_value;
-    }
+    if (result->value->father->value != left->value && checkAttribution(left->value, result->value->father->value))
+        result->value->father = left;
+
     return_:
     gc_freeze(inter, var_list, object, false);
     if (out_var != NULL)
@@ -282,12 +165,13 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
     else{
         char *str_name = NULL;
         int int_times = 0;
+        LinkValue *var_value = NULL;
         getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, father));
         if (!run_continue(result)) {
             memFree(str_name);
             return result->type;
         }
-        LinkValue *var_value = copyLinkValue(value, inter);
+        var_value = copyLinkValue(value, inter);
         if (var_value->aut == auto_aut)
             var_value->aut = name->aut;
         addFromVarList(str_name, result->value, int_times, var_value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
@@ -459,3 +343,45 @@ ResultType setDefault(INTER_FUNCTIONSIG){
     }
     return result->type;
 }
+
+bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG){
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.left, var_list, result, father)) || result->value->value->type == none)
+        return true;
+    *left = *result;
+    setResultCore(result);
+
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result, father)) || result->value->value->type == none)
+        return true;
+    *right = *result;
+    setResultCore(result);
+    return false;
+}
+
+ResultType operationCore(INTER_FUNCTIONSIG, char *name) {
+    Result left;
+    Result right;
+    LinkValue *_func_ = NULL;
+    setResultCore(&left);
+    setResultCore(&right);
+
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
+        return result->type;
+
+    _func_ = findAttributes(name, false, left.value, inter);
+    if (_func_ != NULL){
+        Argument *arg = makeValueArgument(right.value);
+        gc_addTmpLink(&_func_->gc_status);
+        callBackCore(_func_, arg, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
+        gc_freeTmpLink(&_func_->gc_status);
+        freeArgument(arg, true);
+    }
+    else {
+        char *message = memStrcat("Don't find ", name, false, false);
+        setResultErrorSt(result, inter, "TypeException", message, st, father, true);
+        memFree(message);
+    }
+
+    freeResult(&left);
+    freeResult(&right);
+    return result->type;
+}

src/value.c

@@ -6,9 +6,10 @@ Value *makeObject(Inter *inter, VarList *object, VarList *out_var, FatherValue *
     setGC(&tmp->gc_status);
     tmp->type = object_;
     tmp->gc_next = NULL;
-
     if (inter->data.object != NULL && father == NULL)
         father = makeFatherValue(makeLinkValue(inter->data.object, NULL, inter));
+    if (out_var == NULL && father != NULL)
+        out_var = copyVarList(father->value->value->object.out_var, false, inter);
     tmp->object.var = makeObjectVarList(father, inter, object);
     tmp->object.out_var = out_var;
     tmp->object.father = father;
@@ -40,44 +41,53 @@ Value *makeNoneValue(Inter *inter) {
 }
 
 Value *makeBoolValue(bool bool_num, Inter *inter) {
+    FatherValue *object_father = getFatherFromValue(inter->data.bool_, inter);
+    VarList *new_var = copyVarList(inter->data.bool_->object.out_var, false, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->type = bool_;
     tmp->data.bool_.bool_ = bool_num;
     return tmp;
 }
 
 Value *makePassValue(Inter *inter){
+    FatherValue *object_father = getFatherFromValue(inter->data.pass_, inter);
+    VarList *new_var = copyVarList(inter->data.pass_->object.out_var, false, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->type = pass_;
     return tmp;
 }
 
 Value *makeNumberValue(NUMBER_TYPE num, Inter *inter) {
+    FatherValue *object_father = getFatherFromValue(inter->data.num, inter);
+    VarList *new_var = copyVarList(inter->data.num->object.out_var, false, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->type = number;
     tmp->data.num.num = num;
     return tmp;
 }
 
 Value *makeStringValue(char *str, Inter *inter) {
+    FatherValue *object_father = getFatherFromValue(inter->data.str, inter);
+    VarList *new_var = copyVarList(inter->data.str->object.out_var, false, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->type = string;
     tmp->data.str.str = memStrcpy(str);
     return tmp;
 }
 
 
-void setFunctionData(Value *value) {
+static void setFunctionData(Value *value) {  // TODO-szh 内嵌到 inter 中
     value->data.function.function_data.pt_type = object_static_;
 }
 
 Value *makeVMFunctionValue(Statement *st, Parameter *pt, VarList *var_list, Inter *inter) {
+    FatherValue *object_father = getFatherFromValue(inter->data.function, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, var_list, NULL);
+    tmp = makeObject(inter, NULL, var_list, object_father);
     tmp->type = function;
     tmp->data.function.type = vm_function;
     tmp->data.function.function = copyStatement(st);
@@ -88,8 +98,9 @@ Value *makeVMFunctionValue(Statement *st, Parameter *pt, VarList *var_list, Inte
 }
 
 Value *makeCFunctionValue(OfficialFunction of, VarList *var_list, Inter *inter) {
+    FatherValue *object_father = getFatherFromValue(inter->data.function, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, copyVarList(var_list, false, inter), NULL);
+    tmp = makeObject(inter, NULL, copyVarList(var_list, false, inter), object_father);
     tmp->type = function;
     tmp->data.function.type = c_function;
     tmp->data.function.function = NULL;
@@ -107,9 +118,11 @@ Value *makeClassValue(VarList *var_list, Inter *inter, FatherValue *father) {
 }
 
 Value *makeListValue(Argument **arg_ad, Inter *inter, enum ListType type) {
+    FatherValue *object_father = getFatherFromValue(inter->data.list, inter);
+    VarList *new_var = copyVarList(inter->data.list->object.out_var, false, inter);
     Value *tmp;
     Argument *at = *arg_ad;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->type = list;
     tmp->data.list.type = type;
     tmp->data.list.list = NULL;
@@ -124,8 +137,10 @@ Value *makeListValue(Argument **arg_ad, Inter *inter, enum ListType type) {
 }
 
 Value *makeDictValue(Argument **arg_ad, bool new_hash, INTER_FUNCTIONSIG_NOT_ST) {
+    FatherValue *object_father = getFatherFromValue(inter->data.dict, inter);
+    VarList *new_var = copyVarList(inter->data.dict->object.out_var, false, inter);
     Value *tmp;
-    tmp = makeObject(inter, NULL, NULL, NULL);
+    tmp = makeObject(inter, NULL, new_var, object_father);
     tmp->data.dict.size = 0;
     tmp->type = dict;
     if (new_hash) {
@@ -146,11 +161,11 @@ void freeValue(Value **value) {
     Value *free_value = *value;
     freeBase(free_value, return_);
     for (VarList *tmp = free_value->object.var; tmp != NULL; tmp = freeVarList(tmp))
-            PASS;
+        PASS;
     for (VarList *tmp = free_value->object.out_var; tmp != NULL; tmp = freeVarList(tmp))
-            PASS;
+        PASS;
     for (struct FatherValue *tmp = free_value->object.father; tmp != NULL; tmp = freeFatherValue(tmp))
-            PASS;
+        PASS;
     switch (free_value->type) {
         case string:
             memFree(free_value->data.str.str);
@@ -472,6 +487,17 @@ FatherValue *connectSafeFatherValue(FatherValue *base, FatherValue *back){
     reutrn_: return base;
 }
 
+FatherValue *getFatherFromValue(Value *value, Inter *inter){
+    FatherValue *object_father = NULL;
+    LinkValue *num_father = makeLinkValue(value, inter->base_father, inter);
+    Argument *father_arg = makeValueArgument(num_father);
+    gc_addTmpLink(&num_father->gc_status);
+    object_father = setFather(father_arg);
+    freeArgument(father_arg, true);
+    gc_freeTmpLink(&num_father->gc_status);
+    return object_father;
+}
+
 /**
  * 检查 father 是否为 self 的父亲
  * @param self