feat: OOP成员访问操作

允许使用.符号访问object
一切数据均为object
允许使用class关键字定义类
CALL_INTER系列形参增加father参数

gc/freeze.c

@@ -31,10 +31,13 @@ void gc_freezeValue(Value *value, bool is_lock){
 
     if (setIterAlready(&value->gc_status))
         return;
-
+    gc_freezeVarList(value->object.var, is_lock);
     switch (value->type) {
         case function:
-            gc_freezeVarList(value->data.function.var, is_lock);
+            gc_freezeVarList(value->data.function.out_var, is_lock);
+            break;
+        case class:
+            gc_freezeVarList(value->data.class.out_var, is_lock);
             break;
         case list:
             for (int i=0;i < value->data.list.size;i++)
@@ -49,10 +52,8 @@ void gc_freezeValue(Value *value, bool is_lock){
 }
 
 void gc_freezeVarList(VarList *vl, bool is_lock){
-    while (vl != NULL) {
+    for (PASS; vl != NULL; vl = vl->next)
         gc_freezeHashTable(vl->hashtable, is_lock);
-        vl = vl->next;
-    }
 }
 
 void gc_freezeHashTable(HashTable *ht, bool is_lock){
@@ -67,33 +68,28 @@ void gc_freezeHashTable(HashTable *ht, bool is_lock){
     if (setIterAlready(&ht->gc_status))
         return;
 
-    for (int i=0;i < MAX_SIZE;i++){
+    for (int i=0;i < MAX_SIZE;i++)
         gc_freezeVar(ht->hashtable[i], is_lock);
-    }
 }
 
 void gc_freezeVar(Var *var, bool is_lock){
-    while (var != NULL){
+    for (PASS; var != NULL; var = var->next){
         gc_freezeLinkValue(var->name_, is_lock);
         gc_freezeLinkValue(var->value, is_lock);
-        var = var->next;
     }
 }
 
 void iterFreezeVarList(VarList *freeze, VarList *base, bool is_lock){
-    while (freeze != NULL){
-        VarList *tmp = base;
+    for (PASS; freeze != NULL; freeze = freeze->next){
         bool need_freeze = true;
-        while (tmp != NULL){
+        for (VarList *tmp = base; tmp != NULL;tmp = tmp->next){
             if (tmp->hashtable == freeze->hashtable){
                 need_freeze = false;
                 break;
             }
-            tmp = tmp->next;
         }
         if (need_freeze)
             gc_freezeHashTable(freeze->hashtable, is_lock);
-        freeze = freeze->next;
     }
 }
 

gc/gc.c

@@ -16,9 +16,10 @@ void gc_iterValue(Value *value){
     gcAddLink(&value->gc_status);
     if (setIterAlready(&value->gc_status))
         return;
+    gc_varList(value->object.var);
     switch (value->type) {
         case function:
-            gc_var_list(value->data.function.var);
+            gc_varList(value->data.function.out_var);
             break;
         case list:
             for (int i=0;i < value->data.list.size;i++)
@@ -27,16 +28,17 @@ void gc_iterValue(Value *value){
         case dict:
             gc_iterHashTable(value->data.dict.dict);
             break;
+        case class:
+            gc_varList(value->data.class.out_var);
+            break;
         default:
             break;
     }
 }
 
-void gc_var_list(VarList *vl){
-    while (vl != NULL){
+void gc_varList(VarList *vl){
+    for (PASS; vl != NULL; vl = vl->next)
         gc_iterHashTable(vl->hashtable);
-        vl = vl->next;
-    }
 }
 
 void gc_iterHashTable(HashTable *ht){
@@ -45,87 +47,61 @@ void gc_iterHashTable(HashTable *ht){
     gcAddLink(&ht->gc_status);
     if (setIterAlready(&ht->gc_status))
         return;
-    for (int i=0;i < MAX_SIZE;i++){
+    for (int i=0;i < MAX_SIZE;i++)
         gc_iterVar(ht->hashtable[i]);
-    }
 }
 
 void gc_iterVar(Var *var){
-    while (var != NULL){
+    for (PASS; var != NULL; var = var->next){
         gc_iterLinkValue(var->name_);
         gc_iterLinkValue(var->value);
-        var = var->next;
     }
 }
 
 void gc_resetBase(Inter *inter){
-    Value *value_base = inter->base;
-    while (value_base != NULL){
+    for (Value *value_base = inter->base; value_base != NULL; value_base = value_base->next)
         resetGC(&value_base->gc_status);
-        value_base = value_base->next;
-    }
 
-    LinkValue *link_base = inter->link_base;
-    while (link_base != NULL){
+    for (LinkValue *link_base = inter->link_base; link_base != NULL; link_base = link_base->next)
         resetGC(&link_base->gc_status);
-        link_base = link_base->next;
-    }
 
-    HashTable *hash_base = inter->hash_base;
-    while (hash_base != NULL){
+    for (HashTable *hash_base = inter->hash_base; hash_base != NULL; hash_base = hash_base->next)
         resetGC(&hash_base->gc_status);
-        hash_base = hash_base->next;
-    }
 }
 
 void gc_checkBase(Inter *inter){
-    Value *value_base = inter->base;
-    while (value_base != NULL){
+    for (Value *value_base = inter->base; value_base != NULL; value_base = value_base->next)
         if (!needFree(&value_base->gc_status) && !value_base->gc_status.continue_)
             gc_iterValue(value_base);
-        value_base = value_base->next;
-    }
 
-    LinkValue *link_base = inter->link_base;
-    while (link_base != NULL){
+    for (LinkValue *link_base = inter->link_base; link_base != NULL; link_base = link_base->next)
         if (!needFree(&link_base->gc_status) && !link_base->gc_status.continue_)
             gc_iterLinkValue(link_base);
-        link_base = link_base->next;
-    }
 
-    HashTable *hash_base = inter->hash_base;
-    while (hash_base != NULL){
+    for (HashTable *hash_base = inter->hash_base; hash_base != NULL; hash_base = hash_base->next)
         if (!needFree(&hash_base->gc_status) && !hash_base->gc_status.continue_)
             gc_iterHashTable(hash_base);
-        hash_base = hash_base->next;
-    }
 }
 
 void gc_freeBase(Inter *inter){
 #if START_GC
-    Value *value_base = inter->base;
-    while (value_base != NULL){
+    for (Value *value_base = inter->base; value_base != NULL;)
         if (needFree(&value_base->gc_status))
             value_base = freeValue(value_base, inter);
         else
             value_base = value_base->next;
-    }
 
-    LinkValue *link_base = inter->link_base;
-    while (link_base != NULL){
+    for (LinkValue *link_base = inter->link_base; link_base != NULL;)
         if (needFree(&link_base->gc_status))
             link_base = freeLinkValue(link_base, inter);
         else
             link_base = link_base->next;
-    }
 
-    HashTable *hash_base = inter->hash_base;
-    while (hash_base != NULL){
+    for (HashTable *hash_base = inter->hash_base; hash_base != NULL;)
         if (needFree(&hash_base->gc_status))
             hash_base = freeHashTable(hash_base, inter);
         else
             hash_base = hash_base->next;
-    }
 #endif
 }
 
@@ -136,7 +112,7 @@ void runGC(Inter *inter, int var_list, int link_value, int value, ...){
     va_start(arg, value);
     for (int i =0;i < var_list;i ++){
         VarList *tmp = va_arg(arg, VarList *);
-        gc_var_list(tmp);
+        gc_varList(tmp);
     }
     for (int i =0;i < link_value;i ++){
         LinkValue *tmp = va_arg(arg, LinkValue *);

gc/set.c

@@ -13,7 +13,6 @@ void setGC(GCStatus *gcs){
 
 void gcAddTmp(GCStatus *gcs){
     gcs->tmp_link ++;
-    gcs->continue_ = false;
 }
 
 void gcAddLink(GCStatus *gcs){

include/__macro.h

@@ -10,12 +10,12 @@
 #define HASH_INDEX unsigned int
 
 #define INTER_FUNCTIONSIG_CORE struct Inter *inter, struct VarList *var_list
-#define INTER_FUNCTIONSIG struct Result *result, struct Statement *st, INTER_FUNCTIONSIG_CORE
-#define INTER_FUNCTIONSIG_NOT_ST struct Result *result, INTER_FUNCTIONSIG_CORE
+#define INTER_FUNCTIONSIG_NOT_ST struct LinkValue *father, struct Result *result, INTER_FUNCTIONSIG_CORE
+#define INTER_FUNCTIONSIG struct Statement *st, INTER_FUNCTIONSIG_NOT_ST
 
 #define CALL_INTER_FUNCTIONSIG_CORE(var_list) inter, var_list
-#define CALL_INTER_FUNCTIONSIG(st, var_list, result) result, st, CALL_INTER_FUNCTIONSIG_CORE(var_list)
-#define CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result) result, CALL_INTER_FUNCTIONSIG_CORE(var_list)
+#define CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father) father, result, CALL_INTER_FUNCTIONSIG_CORE(var_list)
+#define CALL_INTER_FUNCTIONSIG(st, var_list, result, father) st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father)
 
 #define run_continue_type(result) (type == not_return || type == operation_return)
 #define run_continue(result) (result->type == not_return || result->type == operation_return)

include/gc.h

@@ -37,7 +37,7 @@ void gc_iterValue(struct Value *value);
 void gc_iterLinkValue(struct LinkValue *value);
 void gc_iterHashTable(struct HashTable *ht);
 void gc_iterVar(struct Var *var);
-void gc_var_list(struct VarList *vl);
+void gc_varList(struct VarList *vl);
 
 void iterFreezeVarList(struct VarList *freeze, struct VarList *base, bool is_lock);
 void runFREEZE(struct Inter *inter, struct VarList *freeze, struct VarList *base, bool is_lock);

include/parameter.h

@@ -66,7 +66,7 @@ Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE);
 ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *function_var, struct Statement *base, INTER_FUNCTIONSIG_NOT_ST);
 ResultType setParameter(Parameter *call_base, Parameter *function_base, VarList *function_var, struct Statement *base, INTER_FUNCTIONSIG_NOT_ST);
 ResultType iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_NOT_ST);
-Argument *getArgument(Parameter *call, Result *result, INTER_FUNCTIONSIG_CORE);
+Argument *getArgument(Parameter *call, 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);

include/run.h

@@ -20,6 +20,7 @@ bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG);
 bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG);
 
 ResultType operationStatement(INTER_FUNCTIONSIG);
+ResultType setClass(INTER_FUNCTIONSIG);
 ResultType setFunction(INTER_FUNCTIONSIG);
 ResultType callFunction(INTER_FUNCTIONSIG);
 ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info);
@@ -38,6 +39,7 @@ ResultType raiseCode(INTER_FUNCTIONSIG);
 
 ResultType includeFile(INTER_FUNCTIONSIG);
 
+ResultType pointAss(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST);
 ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST);
 
 char *setStrVarName(char *old, bool free_old, INTER_FUNCTIONSIG_CORE);

include/statement.h

@@ -12,6 +12,7 @@ struct Statement{
         base_svar,
         operation,
         set_function,
+        set_class,
         call_function,
         if_branch,
         while_branch,
@@ -54,10 +55,11 @@ struct Statement{
         struct operation{
             enum OperationType{
                 OPT_ADD = 1,
-                OPT_SUB,
-                OPT_MUL,
-                OPT_DIV,
-                OPT_ASS,
+                OPT_SUB = 2,
+                OPT_MUL = 3,
+                OPT_DIV = 4,
+                OPT_ASS = 5,
+                OPT_POINT = 6,
             } OperationType;
             struct Statement *left;
             struct Statement *right;
@@ -67,6 +69,10 @@ struct Statement{
             struct Statement *function;
             struct Parameter *parameter;
         } set_function;
+        struct {
+            struct Statement *name;
+            struct Statement *st;
+        } set_class;
         struct {
             struct Statement *function;
             struct Parameter *parameter;
@@ -161,6 +167,7 @@ Statement *makeBaseVarStatement(char *name, Statement *times, long int line, cha
 Statement *makeBaseSVarStatement(Statement *name, Statement *times);
 Statement *makeBaseDictStatement(Parameter *pt, long int line, char *file);
 Statement *makeTupleStatement(Parameter *pt, enum ListType type, long int line, char *file);
+Statement *makeClassStatement(Statement *name, Statement *function);
 Statement *makeFunctionStatement(Statement *name, Statement *function, struct Parameter *pt);
 Statement *makeCallStatement(Statement *function, struct Parameter *pt);
 Statement *makeIfStatement(long int line, char *file);
@@ -173,7 +180,7 @@ Statement *makeRestartStatement(Statement *times, long int line, char *file);
 Statement *makeReturnStatement(Statement *value, long int line, char *file);
 Statement *makeRaiseStatement(Statement *value, long int line, char *file);
 Statement *makeIncludeStatement(Statement *file, long int line, char *file_dir);
-struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right);
+struct Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct 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

@@ -108,6 +108,7 @@
 #define RAISE -23
 #define TUPLE -24
 #define INCLUDE -25
+#define POINT -26
 
 #define printTokenEnter(tk, debug, type, message) do{ \
 writeLog(debug, type, message, NULL); \

include/value.h

@@ -2,12 +2,14 @@
 #define VIRTUALMATH_VALUE_H
 
 #include "__macro.h"
+#include "gc.h"
+#include "run.h"
 
 struct VarList;
 struct Argument;
 
 struct Value{
-    GCStatus gc_status;
+    struct GCStatus gc_status;
     enum ValueType{
         none=0,
         number=1,
@@ -15,7 +17,12 @@ struct Value{
         function=3,
         list=4,
         dict=5,
+        class=6,
+        object_=7,
     } type;
+    struct {
+        struct VarList *var;
+    } object;
     union data{
         struct Number{
             NUMBER_TYPE num;
@@ -25,7 +32,7 @@ struct Value{
         } str;
         struct Function{
             struct Statement *function;
-            struct VarList *var;
+            struct VarList *out_var;
             struct Parameter *pt;
         } function;
         struct List{
@@ -40,13 +47,16 @@ struct Value{
             struct HashTable *dict;
             NUMBER_TYPE size;
         } dict;
+        struct Class{
+            struct VarList *out_var;  // class 执行的外部环境
+        } class;
     }data;
     struct Value *next;
     struct Value *last;
 };
 
 struct LinkValue{
-    GCStatus gc_status;
+    struct GCStatus gc_status;
     struct Value *value;
     struct LinkValue *father;
     struct LinkValue *next;
@@ -77,27 +87,31 @@ struct Error{
     struct Error *next;
 };
 
+typedef struct Inter Inter;
 typedef struct Value Value;
 typedef struct LinkValue LinkValue;
 typedef struct Result Result;
 typedef struct Error Error;
 typedef enum ResultType ResultType;
 
-Value *makeValue(Inter *inter);
+Value *makeObject(Inter *inter, struct VarList *object);
 Value * freeValue(Value *value, Inter *inter);
 LinkValue *makeLinkValue(Value *value, LinkValue *linkValue,Inter *inter);
 LinkValue * freeLinkValue(LinkValue *value, Inter *inter);
+Value *makeNoneValue(Inter *inter);
 Value *makeNumberValue(long num, Inter *inter);
 Value *makeStringValue(char *str, Inter *inter);
 Value *makeFunctionValue(struct Statement *st, struct Parameter *pt, struct VarList *var_list, Inter *inter);
+Value *makeClassValue(struct VarList *var_list, Inter *inter);
 Value *makeListValue(struct Argument **arg_ad, Inter *inter, enum ListType type);
-Value *makeDictValue(struct Argument **arg_ad, bool new_hash, Result *result, Inter *inter, struct VarList *var_list);
+Value *makeDictValue(struct Argument **arg_ad, bool new_hash, INTER_FUNCTIONSIG_NOT_ST);
 
 void setResultCore(Result *ru);
-void setResult(Result *ru, Inter *inter);
-void setResultBase(Result *ru, Inter *inter);
-void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, struct Statement *st, bool new);
-void setResultOperationNone(Result *ru, Inter *inter);
+void setResult(Result *ru, Inter *inter, LinkValue *father);
+void setResultBase(Result *ru, Inter *inter, LinkValue *father);
+void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, Statement *st, LinkValue *father,
+                    bool new);
+void setResultOperationNone(Result *ru, Inter *inter, LinkValue *father);
 void setResultOperation(Result *ru, LinkValue *value, Inter *inter);
 void setResultOperationBase(Result *ru, LinkValue *value, Inter *inter);
 void freeResult(Result *ru);

main.c

@@ -5,12 +5,12 @@ int main(int argc, char *argv[]) {
     int status = 1;
 
     if (getArgs(argc, argv))
-        goto args_error_;
+        goto args_error;
 
     global_inter = runBaseInter(args.file, args.log_file, &status);
 
     freeInter(global_inter, true);
-    args_error_: freeArgs();
+    args_error: freeArgs();
     return status;
 }
 
@@ -21,5 +21,4 @@ int main(int argc, char *argv[]) {
  * TODO-szh 生成语法树
  * TODO-szh 取反符号 -
  * TODO-szh 字面量后缀
- * TODO-szh 空参数使用 void
  */

parser/grammar.c

@@ -124,6 +124,7 @@ void parserCommand(PASERSSIGNATURE){
     Statement *st = NULL;
     token_type = readBackToken(pm);
     switch (token_type) {
+        case MATHER_CLASS :
         case MATHER_DEF :
             status = commandCallBack_(CALLPASERSSIGNATURE, parserDef, FUNCTION, &st,
                                       "Command: call def\n");
@@ -542,22 +543,23 @@ void parserDef(PASERSSIGNATURE){
     Statement *name_tmp = NULL;
     Statement *code_tmp = NULL;
     Parameter *pt = NULL;
+    int type = readBackToken(pm);
     long int line = delToken(pm);
 
     if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &name_tmp,
-                            "Don't get a function name"))
+                            "Don't get a function/class name"))
         goto error_;
 
     if (!checkToken_(pm, MATHER_LP)) {
-        syntaxError(pm, syntax_error, line, 1, "Don't get a function ( before parameter");
+        syntaxError(pm, syntax_error, line, 1, "Don't get a function/class ( before parameter");
         goto error_;
     }
     if (!parserParameter(CALLPASERSSIGNATURE, &pt, true, false, false, MATHER_COMMA, MATHER_ASSIGNMENT)) {
-        syntaxError(pm, syntax_error, line, 1, "Don't get a function parameter");
+        syntaxError(pm, syntax_error, line, 1, "Don't get a function/class parameter");
         goto error_;
     }
     if (!checkToken_(pm, MATHER_RP)) {
-        syntaxError(pm, syntax_error, line, 1, "Don't get a function ) after parameter");
+        syntaxError(pm, syntax_error, line, 1, "Don't get a function/class ) after parameter");
         goto error_;
     }
     writeLog_(pm->grammar_debug, GRAMMAR_DEBUG, "parserDef: get function title success\n", NULL);
@@ -568,7 +570,10 @@ void parserDef(PASERSSIGNATURE){
         goto error_;
     }
 
-    st = makeFunctionStatement(name_tmp, code_tmp, pt);
+    if (type == MATHER_DEF)
+        st = makeFunctionStatement(name_tmp, code_tmp, pt);
+    else
+        st = makeClassStatement(name_tmp, code_tmp);  // TODO-szh 处理pt
     addLexToken(pm, MATHER_ENTER);
     addStatementToken(FUNCTION, st, pm);
     return;
@@ -783,10 +788,32 @@ int tailCall(PASERSSIGNATURE, Token *left_token, Statement **st){
     return 1;
 }
 void parserCallBack(PASERSSIGNATURE){
-    return tailOperation(CALLPASERSSIGNATURE, parserBaseValue, tailCall, BASEVALUE, CALLBACK,
-            "Base Value", "Call Back");
+    return tailOperation(CALLPASERSSIGNATURE, parserPoint, tailCall, POINT, CALLBACK,
+            "point", "call back");
 }
 
+/**
+ * 成员运算符匹配
+ * parserPoint:
+ * | parserBaseValue
+ * | parserBaseValue POINT parserPoint
+ */
+bool switchPoint(PASERSSIGNATURE, int symbol, Statement **st){
+    switch (symbol) {
+        case MATHER_POINT:
+            *st = makeOperationStatement(OPT_POINT, 0, pm->file);
+            break;
+        default:
+            return false;
+    }
+    return true;
+}
+void parserPoint(PASERSSIGNATURE){
+    return twoOperation(CALLPASERSSIGNATURE, parserBaseValue, switchPoint, BASEVALUE, POINT,
+                        "base value", "point", false);
+}
+
+
 /**
  * 字面量匹配
  * parserBaseValue：
@@ -809,8 +836,7 @@ int getOperation(PASERSSIGNATURE, int right_type, Statement **st, char *name){
     return_:
     return 1;
 }
-//st = makeBaseStrValueStatement(value_token->data.str, string_str, value_token->line, pm->file);
-//st = makeBaseStrValueStatement(value_token->data.str, number_str, value_token->line, pm->file);
+
 void parserBaseValue(PASERSSIGNATURE){
     Token *value_token = popAheadToken(pm);
     Statement *st = NULL;

parser/include/__grammar.h

@@ -44,6 +44,7 @@ void parserOperation(PASERSSIGNATURE);
 void parserPolynomial(PASERSSIGNATURE);
 void parserBaseValue(PASERSSIGNATURE);
 void parserCallBack(PASERSSIGNATURE);
+void parserPoint(PASERSSIGNATURE);
 void parserFactor(PASERSSIGNATURE);
 void parserAssignment(PASERSSIGNATURE);
 void parserTuple(PASERSSIGNATURE);

src/__run.c

@@ -9,17 +9,17 @@ ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
         *times = 0;
         goto not_times;
     }
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_var.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_var.times, var_list, result, father)))
         return result->type;
     if (!isType(result->value->value, number)){
-        setResultError(result, inter, "TypeException", "Don't get a number value", st, true);
+        setResultError(result, inter, "TypeException", "Don't get a number value", st, father, true);
         return result->type;
     }
     *times = (int)result->value->value->data.num.num;
     freeResult(result);
 
     not_times:
-    value = makeLinkValue(makeStringValue(st->u.base_var.name, inter), NULL, inter);
+    value = makeLinkValue(makeStringValue(st->u.base_var.name, inter), father, inter);
     setResultOperation(result, value, inter);
 
     return result->type;
@@ -32,17 +32,17 @@ ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
         *times = 0;
         goto not_times;
     }
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.times, var_list, result, father)))
         return result->type;
     if (!isType(result->value->value, number)){
-        setResultError(result, inter, "TypeException", "Don't get a number value", st, true);
+        setResultError(result, inter, "TypeException", "Don't get a number value", st, father, true);
         return result->type;
     }
     *times = (int)result->value->value->data.num.num;
 
     freeResult(result);
     not_times:
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list, result, father)))
         return result->type;
 
     *name = getNameFromValue(result->value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
@@ -53,11 +53,11 @@ ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
 
 ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     if (st->type == base_var)
-        getBaseVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
+        getBaseVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     else if (st->type == base_svar)
-        getBaseSVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
+        getBaseSVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     else{
-        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
             return result->type;
         *name = getNameFromValue(result->value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
         *times = 0;

src/inter.c

@@ -59,7 +59,7 @@ Inter *makeInter(char *code_file, char *debug) {
         tmp->data.error = stderr;
     }
 
-    Value *none_value = makeValue(tmp);  // 注册None值
+    Value *none_value = makeNoneValue(tmp);  // 注册None值
     gcAddStatementLink(&none_value->gc_status);
     return tmp;
 }

src/parameter.c

@@ -218,16 +218,16 @@ ResultType defaultParameter(Parameter **function_ad, NUMBER_TYPE *num, INTER_FUN
 
     for (*num = 0; function != NULL && function->type == name_par; (*num)++, function = function->next){
         LinkValue *value = NULL;
-        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result)))
+        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result, father)))
             goto return_;
 
         value = result->value;
         freeResult(result);
-        assCore(function->data.name, value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        assCore(function->data.name, value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
         if (!run_continue(result))
             goto return_;
     }
-    setResult(result, inter);
+    setResult(result, inter, father);
 
     return_:
     *function_ad = function;
@@ -252,11 +252,11 @@ ResultType argumentToVar(Argument **call_ad, NUMBER_TYPE *num, INTER_FUNCTIONSIG
             continue;
         }
         freeResult(result);
-        assCore(call->data.name, call->data.value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        assCore(call->data.name, call->data.value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
         if (!run_continue(result))
             goto return_;
     }
-    setResult(result, inter);
+    setResult(result, inter, father);
 
     return_:
     *call_ad = call;
@@ -286,7 +286,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
         get = true;
 
         if (function->type == kwargs_par){
-            value = makeLinkValue(makeDictValue(NULL, false, NULL, inter, var_list), NULL, inter);
+            value = makeLinkValue(makeDictValue(NULL, false, father, NULL, inter, var_list), father, inter);
             value->value->data.dict.dict = var_list->hashtable;
             value->value->data.dict.size = max - *num;
             *status = true;
@@ -294,7 +294,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
         }
 
         freeResult(result);
-        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result));
+        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, father));
         if (!run_continue(result)) {
             memFree(str_name);
             *function_ad = function;
@@ -307,18 +307,18 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
 
         if(value == NULL) {
             get = false;
-            if (function->type == name_par && !operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result))) {
+            if (function->type == name_par && !operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(function->data.value, var_list, result, father))) {
                 value = result->value;
                 goto not_return;
             }
-            setResultError(result, inter, "ArgumentException", "Too less Argument", name, true);
+            setResultError(result, inter, "ArgumentException", "Too less Argument", name, father, true);
             *function_ad = function;
             return result->type;
         }
 
         not_return:
         freeResult(result);
-        assCore(name, value, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+        assCore(name, value, CALL_INTER_FUNCTIONSIG_NOT_ST (function_var, result, father));
 
         if (!run_continue(result)) {
             *function_ad = function;
@@ -331,7 +331,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, NUMB
             (*num)++;
     }
 
-    setResult(result, inter);
+    setResult(result, inter, father);
     *function_ad = function;
     return result->type;
 }
@@ -352,13 +352,13 @@ 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, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+        assCore(name, call->data.value, CALL_INTER_FUNCTIONSIG_NOT_ST (function_var, result, father));
         if (!run_continue(result))
             goto return_;
         freeResult(result);
     }
 
-    setResult(result, inter);
+    setResult(result, inter, father);
     return_:
     *call_ad = call;
     *function_ad = function;
@@ -377,7 +377,7 @@ ResultType iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_
     setResultCore(result);
 
     for (PASS; call != NULL; call = call->next){
-        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(call->data.value, var_list, result)))
+        if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(call->data.value, var_list, result, father)))
             goto return_;
 
         if (call->type == value_par)
@@ -394,18 +394,18 @@ ResultType iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_
         }
         freeResult(result);
     }
-    setResult(result, inter);
+    setResult(result, inter, father);
 
     return_:
     *base_ad = base;
     return result->type;
 }
 
-Argument *getArgument(Parameter *call, Result *result, INTER_FUNCTIONSIG_CORE){
+Argument *getArgument(Parameter *call, INTER_FUNCTIONSIG_NOT_ST){
     Argument *new_arg = NULL;
     freeResult(result);
 
-    iterParameter(call, &new_arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    iterParameter(call, &new_arg, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     return new_arg;
 }
 
@@ -429,14 +429,14 @@ ResultType setParameter(Parameter *call_base, Parameter *function_base, VarList
                     INTER_FUNCTIONSIG_NOT_ST) {
     Argument *call = NULL;
     setResultCore(result);
-    call = getArgument(call_base, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    call = getArgument(call_base, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     if (!run_continue(result)) {
         freeArgument(call, false);
         return result->type;
     }
 
     freeResult(result);
-    setParameterCore(call, function_base, function_var, base, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    setParameterCore(call, function_base, function_var, base, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     freeArgument(call, false);
     return result->type;
 }
@@ -478,13 +478,13 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
         freeResult(result);
         switch (status) {
             case match_status: {
-                argumentToParameter(&call, &function, function_var, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+                argumentToParameter(&call, &function, function_var, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
                 returnResult(result);
                 break;
             }
             case default_status: {
                 NUMBER_TYPE num = 0;
-                defaultParameter(&function, &num, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+                defaultParameter(&function, &num, CALL_INTER_FUNCTIONSIG_NOT_ST (function_var, result, father));
                 returnResult(result);
                 break;
             }
@@ -494,7 +494,7 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
                 bool dict_status = false;
                 VarList *tmp = pushVarList(var_list, inter);
 
-                argumentToVar(&call, &set_num, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result));
+                argumentToVar(&call, &set_num, CALL_INTER_FUNCTIONSIG_NOT_ST (tmp, result, father));
                 returnResult(result);
                 if (!run_continue(result)) {
                     popVarList(tmp);
@@ -502,7 +502,7 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
                 }
 
                 freeResult(result);
-                parameterFromVar(&function, function_var, &get_num, set_num, &dict_status, CALL_INTER_FUNCTIONSIG_NOT_ST(tmp, result));
+                parameterFromVar(&function, function_var, &get_num, set_num, &dict_status, CALL_INTER_FUNCTIONSIG_NOT_ST (tmp, result, father));
                 if (!run_continue(result)) {
                     popVarList(tmp);
                     goto return_;
@@ -516,20 +516,20 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
                 break;
             }
             case mul_par: {
-                LinkValue *tmp = makeLinkValue(makeListValue(&call, inter, value_tuple), NULL, inter);
+                LinkValue *tmp = makeLinkValue(makeListValue(&call, inter, value_tuple), father, inter);
                 if (!run_continue(result))
                     goto return_;
                 else
                     freeResult(result);
 
-                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST (function_var, result, father));
                 returnResult(result);
                 function = function->next;
                 break;
             }
             case space_kwargs:{
-                LinkValue *tmp = makeLinkValue(makeDictValue(NULL, true, result, inter, var_list), NULL, inter);
-                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(function_var, result));
+                LinkValue *tmp = makeLinkValue(makeDictValue(NULL, true, father, result, inter, var_list), father, inter);
+                assCore(function->data.value, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST (function_var, result, father));
                 returnResult(result);
                 function = function->next;
                 break;
@@ -537,14 +537,14 @@ ResultType setParameterCore(Argument *call, Parameter *function_base, VarList *f
             case error:
             error_:  // Statement 处理
                 writeLog(inter->data.debug, ERROR, "setParameter error\n", NULL);
-                setResultError(result, inter, "ArgumentException", "Set Argument error", 0, true);
+                setResultError(result, inter, "ArgumentException", "Set Argument error", 0, father, true);
                 goto return_;
             default:
                 goto break_;
         }
     }
     break_:
-    setResult(result, inter);
+    setResult(result, inter, father);
 
     return_:
     freeParameter(tmp_function, true);

src/run.c

@@ -12,63 +12,66 @@ ResultType runStatement(INTER_FUNCTIONSIG) {
     ResultType type = not_return;
     switch (st->type) {
         case base_value:
-            type = getBaseValue(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = getBaseValue(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case base_var:
-            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result), getBaseVarInfo);
+            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), getBaseVarInfo);
             break;
         case base_svar:
-            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result), getBaseSVarInfo);
+            type = getVar(CALL_INTER_FUNCTIONSIG(st, var_list, result, father), getBaseSVarInfo);
             break;
         case base_list:
-            type = getList(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = getList(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case base_dict:
-            type = getDict(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = getDict(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case operation:
-            type = operationStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = operationStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             if (run_continue_type(type))
                 printLinkValue(result->value, "operation result = ", "\n", inter->data.debug);
             break;
+        case set_class:
+            type = setClass(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            break;
         case set_function:
-            type = setFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = setFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case call_function:
-            type = callFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = callFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case if_branch:
-            type = ifBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = ifBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case while_branch:
-            type = whileBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = whileBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case try_branch:
-            type = tryBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = tryBranch(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case break_cycle:
-            type = breakCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = breakCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case continue_cycle:
-            type = continueCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = continueCycle(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case rego_if:
-            type = regoIf(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = regoIf(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case restart:
-            type = restartCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = restartCode(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case return_code:
-            type = returnCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = returnCode(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case raise_code:
-            type = raiseCode(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = raiseCode(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case include_file:
-            type = includeFile(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            type = includeFile(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         default:
-            setResult(result, inter);
+            setResult(result, inter, father);
             break;
     }
 
@@ -89,21 +92,21 @@ ResultType iterStatement(INTER_FUNCTIONSIG) {
     setResultCore(result);
 
     if (st == NULL){
-        setResult(result, inter);
+        setResult(result, inter, father);
         return result->type;
     }
 
     do {
         for (base_st = st; base_st != NULL; base_st = base_st->next) {
             freeResult(result);
-            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result));
+            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result, father));
             if (!run_continue_type(type))
                 break;
         }
     } while (type == restart_return && result->times == 0);
 
     if (type == not_return || type == restart_return)
-        setResultOperationNone(result, inter);
+        setResultOperationNone(result, inter, father);
 
     runGC(inter, 1, 0, 0, var_list);
     return result->type;
@@ -115,6 +118,7 @@ ResultType iterStatement(INTER_FUNCTIONSIG) {
  * @return
  */
 ResultType globalIterStatement(Inter *inter, Result *result) {
+    LinkValue *father = makeLinkValue(makeObject(inter, inter->var_list), NULL, inter);
     Statement *base_st = NULL;
     VarList *var_list = NULL;
     enum ResultType type;
@@ -122,14 +126,14 @@ ResultType globalIterStatement(Inter *inter, Result *result) {
     do {
         for (base_st = inter->statement, var_list = inter->var_list; base_st != NULL; base_st = base_st->next) {
             freeResult(result);
-            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result));
+            type = runStatement(CALL_INTER_FUNCTIONSIG(base_st, var_list, result, father));
             if (!run_continue_type(type))
                 break;
         }
     } while (type == restart_return && result->times == 0);
 
     if (type != error_return && type != function_return)
-        setResultOperationNone(result, inter);
+        setResultOperationNone(result, inter, father);
 
     runGC(inter, 1, 0, 0, var_list);
     return result->type;
@@ -138,7 +142,7 @@ ResultType globalIterStatement(Inter *inter, Result *result) {
 // 若需要中断执行, 则返回true
 bool operationSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
-    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (run_continue_type(type))
         return false;
     return true;
@@ -146,7 +150,7 @@ bool operationSafeInterStatement(INTER_FUNCTIONSIG){
 
 bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
-    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (run_continue_type(type)){
         return false;
     }
@@ -155,16 +159,14 @@ bool ifBranchSafeInterStatement(INTER_FUNCTIONSIG){
         if (result->times < 0)
             return false;
     }
-    if (type == restart_return) {
-        printf("TAG A\n");
+    if (type == restart_return)
         result->times--;
-    }
     return true;
 }
 
 bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
-    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (run_continue_type(type)){
         return false;
     }
@@ -180,7 +182,7 @@ bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG){
 
 bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
-    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (run_continue_type(type)){
         return false;
     }
@@ -191,7 +193,7 @@ bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG){
 
 bool functionSafeInterStatement(INTER_FUNCTIONSIG){
     ResultType type;
-    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    type = iterStatement(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (type == error_return)
         return true;
     else if (type == function_return){

src/runbranch.c

@@ -3,7 +3,7 @@
 // TODO-szh 重新命名
 #define checkNumber(new_result) do{ \
 if (!isType(new_result->value->value, number)){ \
-setResultError(result, inter, "TypeException", "Don't get a number value", st, true); \
+setResultError(result, inter, "TypeException", "Don't get a number value", st, father, true); \
 return result->type; \
 }}while(0) /*该Macro只适用于控制分支*/
 
@@ -36,7 +36,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
         freeResult(result);
         if (if_list->type == if_b){
             LinkValue *condition_value = NULL;
-            if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->condition, var_list, result))){
+            if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->condition, var_list, result, father))){
                 set_result = false;
                 goto not_else;
             }
@@ -44,7 +44,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
             condition_value = result->value;
             freeResult(result);
             if (if_list->var != NULL) {
-                assCore(if_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+                assCore(if_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
                 if (!run_continue(result)){
                     set_result = false;
                     goto not_else;
@@ -55,7 +55,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
             bool condition = is_rego ? true : checkBool(condition_value->value);  // 若是rego则不执行checkbool的判断了
             if (condition){
                 is_rego = false;
-                if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result))){
+                if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result, father))){
                     set_result = false;
                     goto not_else;
                 }
@@ -69,7 +69,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
             }
         }
         else{
-            if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result))){
+            if (ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(if_list->code, var_list, result, father))){
                 set_result = false;
                 goto not_else;
             }
@@ -78,13 +78,13 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
             freeResult(result);
         }
     }
-    if (else_st != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
+    if (else_st != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result, father)))
         set_result = false;
     else
         freeResult(result);
 
     not_else:
-    if (finally != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
+    if (finally != NULL && ifBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp, father))){
         if (!set_result)
             freeResult(result);
         set_result = false;
@@ -95,7 +95,7 @@ ResultType ifBranch(INTER_FUNCTIONSIG) {
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(result, inter);
+        setResult(result, inter, father);
     return result->type;
 }
 
@@ -116,7 +116,7 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
         LinkValue *condition_value = NULL;
 
         freeResult(result);
-        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->condition, var_list, result))){
+        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->condition, var_list, result, father))){
             set_result = false;
             goto not_else;
         }
@@ -124,7 +124,7 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
         condition_value = result->value;
         freeResult(result);
         if (while_list->var != NULL){
-            assCore(while_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+            assCore(while_list->var, condition_value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
             if (!run_continue(result)){
                 set_result = false;
                 goto not_else;
@@ -134,14 +134,12 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
 
         bool condition = checkBool(condition_value->value);
         if (condition){
-            if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->code, var_list, result))){
+            if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(while_list->code, var_list, result, father))){
                 set_result = false;
                 goto not_else;
             }
             else if (result->type == break_return)
                 is_break = true;
-            else if (result->type == continue_return)
-                PASS;
             freeResult(result);
         }
         else
@@ -150,7 +148,7 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
         if (after == NULL)
             continue;
 
-        if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(after, var_list, result))){
+        if (cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(after, var_list, result, father))){
             set_result = false;
             goto not_else;
         }
@@ -158,18 +156,16 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
             freeResult(result);
             goto not_else;
         }
-        else if (result->type == continue_return)
-            PASS;
 
         freeResult(result);
     }
-    if (!is_break && else_st != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
+    if (!is_break && else_st != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result, father)))
         set_result = false;
     else
         freeResult(result);
 
     not_else:
-    if (finally != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
+    if (finally != NULL && cycleBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp, father))){
         if (!set_result)
             freeResult(result);
         set_result = false;
@@ -178,7 +174,7 @@ ResultType whileBranch(INTER_FUNCTIONSIG) {
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(result, inter);
+        setResult(result, inter, father);
     return result->type;
 }
 
@@ -195,7 +191,7 @@ ResultType tryBranch(INTER_FUNCTIONSIG) {
     setResultCore(&finally_tmp);
 
     var_list = pushVarList(var_list, inter);
-    if (!tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(try, var_list, result))){
+    if (!tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(try, var_list, result, father))){
         freeResult(result);
         goto not_except;
     }
@@ -208,27 +204,27 @@ ResultType tryBranch(INTER_FUNCTIONSIG) {
     error_value = result->value;
     freeResult(result);
     if (except_list->var != NULL){
-        assCore(except_list->var, error_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        assCore(except_list->var, error_value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
         if (!run_continue(result)){
             set_result = false;
             goto not_else;
         }
         freeResult(result);
     }
-    if (tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(except_list->code, var_list, result)))
+    if (tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(except_list->code, var_list, result, father)))
         set_result = false;
     else
         freeResult(result);
     goto not_else;
 
     not_except:
-    if (else_st != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result)))
+    if (else_st != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(else_st, var_list, result, father)))
         set_result = false;
     else
         freeResult(result);
 
     not_else:
-    if (finally != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp))){
+    if (finally != NULL && tryBranchSafeInterStatement(CALL_INTER_FUNCTIONSIG(finally, var_list, &finally_tmp, father))){
         if (!set_result)
             freeResult(result);
         set_result = false;
@@ -237,7 +233,7 @@ ResultType tryBranch(INTER_FUNCTIONSIG) {
 
     var_list = popVarList(var_list);
     if (set_result)
-        setResult(result, inter);
+        setResult(result, inter, father);
     return result->type;
 }
 
@@ -247,7 +243,7 @@ ResultType breakCycle(INTER_FUNCTIONSIG){
     if (st->u.break_cycle.times == NULL)
         goto not_times;
 
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.break_cycle.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.break_cycle.times, var_list, result, father)))
         return result->type;
 
     checkNumber(result);
@@ -255,7 +251,7 @@ ResultType breakCycle(INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    setResult(result, inter);
+    setResult(result, inter, father);
     if (times_int >= 0) {
         result->type = break_return;
         result->times = times_int;
@@ -268,7 +264,7 @@ ResultType continueCycle(INTER_FUNCTIONSIG){
     setResultCore(result);
     if (st->u.continue_cycle.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.continue_cycle.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.continue_cycle.times, var_list, result, father)))
         return result->type;
 
     checkNumber(result);
@@ -276,7 +272,7 @@ ResultType continueCycle(INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    setResult(result, inter);
+    setResult(result, inter, father);
     if (times_int >= 0) {
         result->type = continue_return;
         result->times = times_int;
@@ -289,7 +285,7 @@ ResultType regoIf(INTER_FUNCTIONSIG){
     setResultCore(result);
     if (st->u.rego_if.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.rego_if.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.rego_if.times, var_list, result, father)))
         return result->type;
 
     checkNumber(result);
@@ -297,7 +293,7 @@ ResultType regoIf(INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    setResult(result, inter);
+    setResult(result, inter, father);
     if (times_int >= 0) {
         result->type = rego_return;
         result->times = times_int;
@@ -310,7 +306,7 @@ ResultType restartCode(INTER_FUNCTIONSIG){
     setResultCore(result);
     if (st->u.restart.times == NULL)
         goto not_times;
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.restart.times, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.restart.times, var_list, result, father)))
         return result->type;
 
     checkNumber(result);
@@ -318,7 +314,7 @@ ResultType restartCode(INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    setResult(result, inter);
+    setResult(result, inter, father);
     if (times_int >= 0) {
         result->type = restart_return;
         result->times = times_int;
@@ -329,11 +325,11 @@ ResultType restartCode(INTER_FUNCTIONSIG){
 ResultType returnCode(INTER_FUNCTIONSIG){
     setResultCore(result);
     if (st->u.return_code.value == NULL) {
-        setResult(result, inter);
+        setResult(result, inter, father);
         goto set_result;
     }
 
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.return_code.value, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.return_code.value, var_list, result, father)))
         return result->type;
 
     set_result:
@@ -344,11 +340,11 @@ ResultType returnCode(INTER_FUNCTIONSIG){
 ResultType raiseCode(INTER_FUNCTIONSIG){
     setResultCore(result);
     if (st->u.raise_code.value == NULL) {
-        setResult(result, inter);
+        setResult(result, inter, father);
         goto set_result;
     }
 
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.raise_code.value, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.raise_code.value, var_list, result, father)))
         return result->type;
 
     set_result:

src/runcall.c

@@ -1,37 +1,62 @@
 #include "__run.h"
 
-enum ResultType  setFunction(INTER_FUNCTIONSIG) {
-    LinkValue *tmp = makeLinkValue(NULL, NULL, inter);
+ResultType setClass(INTER_FUNCTIONSIG) {
+    LinkValue *tmp = NULL;
     setResultCore(result);
+    tmp = makeLinkValue(makeClassValue(var_list, inter), father, inter);
+    gcAddTmp(&tmp->gc_status);
 
-    tmp->value = makeFunctionValue(st->u.set_function.function, st->u.set_function.parameter, var_list, inter);
-    assCore(st->u.set_function.name, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    tmp->value->object.var->next = var_list;
+    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.set_class.st, tmp->value->object.var, result, tmp));
+    tmp->value->object.var->next = NULL;
+
+    if (!run_continue(result)) {
+        setResultError(result, inter, NULL, NULL, st, father, false);
+        goto return_;
+    }
+    else
+        freeResult(result);
+
+    assCore(st->u.set_class.name, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
+    if (run_continue(result))
+        setResult(result, inter, father);
+    return_:
+    gcFreeTmpLink(&tmp->gc_status);
+    return result->type;
+}
+
+ResultType setFunction(INTER_FUNCTIONSIG) {
+    LinkValue *tmp = NULL;
+    setResultCore(result);
+
+    tmp = makeLinkValue(makeFunctionValue(st->u.set_function.function, st->u.set_function.parameter, var_list, inter), father, inter);
+    assCore(st->u.set_function.name, tmp, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
     if (run_continue(result))
-        setResult(result, inter);
+        setResult(result, inter, father);
 
     return result->type;
 }
 
-enum ResultType callFunction(INTER_FUNCTIONSIG) {
+ResultType callFunction(INTER_FUNCTIONSIG) {
     LinkValue *function_value = NULL;
     VarList *function_var = NULL;
     setResultCore(result);
 
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list, result, father)))
         goto return_;
     if (result->value->value->type != function){
-        setResultError(result, inter, "TypeException", "Object is not callable", st, true);
+        setResultError(result, inter, "TypeException", "Object is not callable", st, father, true);
         goto return_;
     }
 
     function_value = result->value;
-    function_var = pushVarList(function_value->value->data.function.var, inter);
+    function_var = pushVarList(function_value->value->data.function.out_var, inter);
     gcAddTmp(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, true);
 
     freeResult(result);
     setParameter(st->u.call_function.parameter, function_value->value->data.function.pt, function_var,
-                 st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+                 st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
     if (!run_continue(result)) {
         gcAddTmp(&function_var->hashtable->gc_status);
         runFREEZE(inter, var_list, function_var, false);
@@ -41,13 +66,13 @@ enum ResultType callFunction(INTER_FUNCTIONSIG) {
     else
         freeResult(result);
 
-    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(function_value->value->data.function.function, function_var, result));
+    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(function_value->value->data.function.function, function_var, result, father));
 
     gcFreeTmpLink(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, false);
     popVarList(function_var);
 
-    setResultError(result, inter, NULL, NULL, st, false);  // 自带检查
+    setResultError(result, inter, NULL, NULL, st, father, false);
 
     return_:
     return result->type;

src/runfile.c

@@ -6,11 +6,11 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
     char *file_dir = NULL;
     setResultCore(result);
 
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.include_file.file, var_list, result)))
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.include_file.file, var_list, result, father)))
         return result->type;
 
     if (!isType(result->value->value, string)){
-        setResultError(result, inter, "TypeException", "Don't get a string value", st, true);
+        setResultError(result, inter, "TypeException", "Don't get a string value", st, father, true);
         goto return_;
     }
 
@@ -18,7 +18,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
     freeResult(result);
 
     if (checkFile(file_dir) != 1){
-        setResultError(result, inter, "IncludeFileException", "File is not readable", st, true);
+        setResultError(result, inter, "IncludeFileException", "File is not readable", st, father, true);
         goto return_;
     }
 
@@ -26,13 +26,13 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
     pm = makeParserMessage(file_dir, NULL);
     parserCommandList(pm, inter, true, new_st);
     if (pm->status != success){
-        setResultError(result, inter, "IncludeSyntaxException", pm->status_message, st, true);
+        setResultError(result, inter, "IncludeSyntaxException", pm->status_message, st, father, true);
         goto return_;
     }
 
-    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(new_st, var_list, result));
+    functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(new_st, var_list, result, father));
     if (!run_continue(result))
-        setResultError(result, inter, NULL, NULL, st, false);
+        setResultError(result, inter, NULL, NULL, st, father, false);
 
     return_:
     freeStatement(new_st);

src/runoperation.c

@@ -1,10 +1,11 @@
 #include "__run.h"
 
-enum ResultType addOperation(INTER_FUNCTIONSIG);
-enum ResultType subOperation(INTER_FUNCTIONSIG);
-enum ResultType mulOperation(INTER_FUNCTIONSIG);
-enum ResultType divOperation(INTER_FUNCTIONSIG);
-enum ResultType assOperation(INTER_FUNCTIONSIG);
+ResultType addOperation(INTER_FUNCTIONSIG);
+ResultType subOperation(INTER_FUNCTIONSIG);
+ResultType mulOperation(INTER_FUNCTIONSIG);
+ResultType divOperation(INTER_FUNCTIONSIG);
+ResultType assOperation(INTER_FUNCTIONSIG);
+ResultType pointOperation(INTER_FUNCTIONSIG);
 
 /**
  * operation的整体操作
@@ -17,34 +18,37 @@ ResultType operationStatement(INTER_FUNCTIONSIG) {
     setResultCore(result);
     switch (st->u.operation.OperationType) {
         case OPT_ADD:
-            addOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            addOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case OPT_SUB:
-            subOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            subOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case OPT_MUL:
-            mulOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            mulOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case OPT_DIV:
-            divOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            divOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         case OPT_ASS:
-            assOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result));
+            assOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
+            break;
+        case OPT_POINT:
+            pointOperation(CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
             break;
         default:
-            setResult(result, inter);
+            setResult(result, inter, father);
             break;
     }
     return result->type;
 }
 
 bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG){
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.left, var_list, result)) || result->value->value->type == none)
+    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)) || result->value->value->type == none)
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result, father)) || result->value->value->type == none)
         return true;
     *right = *result;
     return false;
@@ -56,10 +60,10 @@ ResultType addOperation(INTER_FUNCTIONSIG) {
     setResultCore(&left);
     setResultCore(&right);
 
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
         return result->type;
 
-    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter), 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){
@@ -68,7 +72,7 @@ ResultType addOperation(INTER_FUNCTIONSIG) {
         memFree(new_string);
     }
     else
-        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, father, true);
 
     freeResult(&left);
     freeResult(&right);
@@ -81,14 +85,14 @@ ResultType subOperation(INTER_FUNCTIONSIG) {
     setResultCore(&left);
     setResultCore(&right);
 
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
         return result->type;
 
-    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter), 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
-        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, father, true);
 
     freeResult(&left);
     freeResult(&right);
@@ -101,13 +105,13 @@ ResultType mulOperation(INTER_FUNCTIONSIG) {
     setResultCore(&left);
     setResultCore(&right);
 
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
         return result->type;
 
-    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter), 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){
+    else if(left.value->value->type == number && right.value->value->type == string) {
         Result tmp = left;
         left = right;
         right = tmp;
@@ -119,7 +123,7 @@ ResultType mulOperation(INTER_FUNCTIONSIG) {
         memFree(new_string);
     }
     else
-        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, father, true);
 
     freeResult(&left);
     freeResult(&right);
@@ -132,25 +136,48 @@ ResultType divOperation(INTER_FUNCTIONSIG) {
     setResultCore(&left);
     setResultCore(&right);
 
-    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result)))
+    if (getLeftRightValue(&left, &right, CALL_INTER_FUNCTIONSIG(st, var_list, result, father)))
         return result->type;
 
-    setResultOperationBase(result, makeLinkValue(NULL, NULL, inter), inter);
+    setResultOperationBase(result, makeLinkValue(NULL, father, inter), 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
-        setResultError(result, inter, "TypeException", "Get Not Support Value", st, true);
+        setResultError(result, inter, "TypeException", "Get Not Support Value", st, father, true);
 
     freeResult(&left);
     freeResult(&right);
     return result->type;
 }
 
+ResultType pointOperation(INTER_FUNCTIONSIG) {
+    LinkValue *left;
+
+    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;
+
+    runFREEZE(inter, var_list, object, true);
+    operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, object, result, left));
+    if (run_continue(result))
+        result->value->father = left;
+    runFREEZE(inter, var_list, object, false);
+
+    gcFreeTmpLink(&left->gc_status);
+    return result->type;
+}
+
 ResultType assOperation(INTER_FUNCTIONSIG) {
-    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result)))
+    LinkValue *value = NULL;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.operation.right, var_list, result, father)))
         return result->type;
-    assCore(st->u.operation.left, result->value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+    value = result->value;
 
+    freeResult(result);
+    assCore(st->u.operation.left, value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     return result->type;
 }
 
@@ -165,7 +192,7 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
         Statement *tmp_st = makeBaseLinkValueStatement(value, name->line, name->code_file);
 
         pt = makeArgsParameter(tmp_st);
-        call = getArgument(pt, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+        call = getArgument(pt, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
         if (!run_continue(result)) {
             freeArgument(call, false);
             freeParameter(pt, true);
@@ -173,20 +200,22 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
         }
 
         freeResult(result);
-         setParameterCore(call, name->u.base_list.list, var_list, name, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result));
+        setParameterCore(call, name->u.base_list.list, var_list, name, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
         if (run_continue(result)){
             Argument *tmp = call;
-            LinkValue *new_value = makeLinkValue(makeListValue(&tmp, inter, value_tuple), NULL, inter);
+            LinkValue *new_value = makeLinkValue(makeListValue(&tmp, inter, value_tuple), father, inter);
             freeResult(result);
             setResultOperation(result, new_value, inter);
         }
         freeArgument(call, false);
         freeParameter(pt, true);
     }
+    else if (name->type == operation && name->u.operation.OperationType == OPT_POINT)
+        pointAss(name, value, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     else{
         char *str_name = NULL;
 
-        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result));
+        getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, father));
         if (!run_continue(result)) {
             memFree(str_name);
             return result->type;
@@ -205,12 +234,31 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
     return result->type;
 }
 
+ResultType pointAss(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST) {
+    Result left;
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(name->u.operation.left, var_list, result, father)))
+        return result->type;
+    left = *result;
+    setResultCore(result);
+
+    VarList *object = left.value->value->object.var;
+    runFREEZE(inter, var_list, object, true);
+    if (name->u.operation.right->type == OPERATION && name->u.operation.right->u.operation.OperationType == OPT_POINT)
+        pointAss(name->u.operation.right, value, CALL_INTER_FUNCTIONSIG_NOT_ST (object, result, father));
+    else
+        assCore(name->u.operation.right, value, CALL_INTER_FUNCTIONSIG_NOT_ST (object, result, father));
+    runFREEZE(inter, var_list, object, true);
+
+    freeResult(&left);
+    return result->type;
+}
+
 ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
     int int_times = 0;
     char *name = NULL;
 
     freeResult(result);
-    var_info(&name, &int_times, CALL_INTER_FUNCTIONSIG(st, var_list, result));
+    var_info(&name, &int_times, CALL_INTER_FUNCTIONSIG(st, var_list, result, father));
     if (!run_continue(result)) {
         memFree(name);
         return result->type;
@@ -222,7 +270,7 @@ ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
 
     if (result->value == NULL){
         char *info = memStrcat("Name Not Found: ", name, false);
-        setResultError(result, inter, "NameException", info, st, true);
+        setResultError(result, inter, "NameException", info, st, father, true);
         memFree(info);
     }
     else
@@ -234,15 +282,14 @@ ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
 
 ResultType getBaseValue(INTER_FUNCTIONSIG) {
     freeResult(result);
-    if (st->u.base_value.type == link_value) {
+    if (st->u.base_value.type == link_value)
         result->value = st->u.base_value.value;
-    }
     else if (st->u.base_value.type == number_str){
         char *stop = NULL;
-        result->value = makeLinkValue(makeNumberValue(strtol(st->u.base_value.str, &stop, 10), inter), NULL, inter);
+        result->value = makeLinkValue(makeNumberValue(strtol(st->u.base_value.str, &stop, 10), inter), father, inter);
     }
     else
-        result->value = makeLinkValue(makeStringValue(st->u.base_value.str, inter), NULL, inter);
+        result->value = makeLinkValue(makeStringValue(st->u.base_value.str, inter), father, inter);
 
     result->type = operation_return;
     gcAddTmp(&result->value->gc_status);
@@ -254,14 +301,14 @@ ResultType getList(INTER_FUNCTIONSIG) {
     Argument *at_tmp = NULL;
 
     freeResult(result);
-    at = getArgument(st->u.base_list.list, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    at = getArgument(st->u.base_list.list, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     at_tmp = at;
     if (!run_continue(result)){
         freeArgument(at_tmp, true);
         return result->type;
     }
 
-    LinkValue *value = makeLinkValue(makeListValue(&at, inter, st->u.base_list.type), NULL, inter);
+    LinkValue *value = makeLinkValue(makeListValue(&at, inter, st->u.base_list.type), father, inter);
     setResultOperation(result, value, inter);
     freeArgument(at_tmp, false);
 
@@ -274,7 +321,7 @@ ResultType getDict(INTER_FUNCTIONSIG) {
     Argument *at_tmp = NULL;
 
     freeResult(result);
-    at = getArgument(st->u.base_dict.dict, result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    at = getArgument(st->u.base_dict.dict, CALL_INTER_FUNCTIONSIG_NOT_ST (var_list, result, father));
     at_tmp = at;
     if (!run_continue(result)){
         freeArgument(at_tmp, false);
@@ -282,14 +329,14 @@ ResultType getDict(INTER_FUNCTIONSIG) {
     }
 
     freeResult(result);
-    Value *tmp_value = makeDictValue(&at, true, result, inter, var_list);
+    Value *tmp_value = makeDictValue(&at, true, father, result, inter, var_list);
     if (!run_continue(result)) {
         freeArgument(at_tmp, false);
         return result->type;
     }
 
     freeResult(result);
-    LinkValue *value = makeLinkValue(tmp_value, NULL, inter);
+    LinkValue *value = makeLinkValue(tmp_value, father, inter);
     setResultOperation(result, value, inter);
     freeArgument(at_tmp, false);
 

src/statement.c

@@ -9,7 +9,7 @@ Statement *makeStatement(long int line, char *file) {
     return tmp;
 }
 
-Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, int type, bool is_right) {
+Token *setOperationFromToken(Statement **st_ad, struct Token *left, struct Token *right, enum OperationType type, bool is_right) {
     Token *new_token = NULL;
     Statement *st = *st_ad, *left_st = left->data.st;
     if (is_right && left->data.st->type == operation &&
@@ -94,6 +94,14 @@ Statement *makeTupleStatement(Parameter *pt, enum ListType type, long int line,
     return tmp;
 }
 
+Statement *makeClassStatement(Statement *name, Statement *function) {
+    Statement *tmp = makeStatement(name->line, name->code_file);
+    tmp->type = set_class;
+    tmp->u.set_class.name = name;
+    tmp->u.set_class.st = function;
+    return tmp;
+}
+
 Statement *makeFunctionStatement(Statement *name, Statement *function, Parameter *pt) {
     Statement *tmp = makeStatement(name->line, name->code_file);
     tmp->type = set_function;
@@ -227,6 +235,10 @@ void freeStatement(Statement *st){
                 freeStatement(st->u.set_function.function);
                 freeParameter(st->u.set_function.parameter, true);
                 break;
+            case set_class:
+                freeStatement(st->u.set_class.name);
+                freeStatement(st->u.set_class.st);
+                break;
             case call_function:
                 freeStatement(st->u.call_function.function);
                 freeParameter(st->u.call_function.parameter, true);
@@ -342,6 +354,10 @@ Statement *copyStatementCore(Statement *st){
             new->u.set_function.function = copyStatement(st->u.set_function.function);
             new->u.set_function.parameter = copyParameter(st->u.set_function.parameter);
             break;
+        case set_class:
+            new->u.set_class.name = copyStatement(st->u.set_class.name);
+            new->u.set_class.st = copyStatement(st->u.set_class.st);
+            break;
         case call_function:
             new->u.call_function.function = copyStatement(st->u.call_function.function);
             new->u.call_function.parameter = copyParameter(st->u.call_function.parameter);

src/value.c

@@ -1,12 +1,14 @@
 #include "__virtualmath.h"
 
 
-Value *makeValue(Inter *inter) {
+Value *makeObject(Inter *inter, VarList *object) {
     Value *tmp, *list_tmp = inter->base;
     tmp = memCalloc(1, sizeof(Value));
-    tmp->type = none;
     setGC(&tmp->gc_status);
+    tmp->type = object_;
     tmp->next = NULL;
+    tmp->object.var = object == NULL ? makeVarList(inter) : copyVarList(object, false, inter);
+
     if (list_tmp == NULL){
         inter->base = tmp;
         tmp->last = NULL;
@@ -23,9 +25,16 @@ Value *makeValue(Inter *inter) {
     return tmp;
 }
 
+Value *makeNoneValue(Inter *inter) {
+    Value *tmp;
+    tmp = makeObject(inter, NULL);
+    tmp->type = none;
+    return tmp;
+}
+
 Value *makeNumberValue(NUMBER_TYPE num, Inter *inter) {
     Value *tmp;
-    tmp = makeValue(inter);
+    tmp = makeObject(inter, NULL);
     tmp->type = number;
     tmp->data.num.num = num;
     return tmp;
@@ -33,7 +42,7 @@ Value *makeNumberValue(NUMBER_TYPE num, Inter *inter) {
 
 Value *makeStringValue(char *str, Inter *inter) {
     Value *tmp;
-    tmp = makeValue(inter);
+    tmp = makeObject(inter, NULL);
     tmp->type = string;
     tmp->data.str.str = memStrcpy(str);
     return tmp;
@@ -41,18 +50,26 @@ Value *makeStringValue(char *str, Inter *inter) {
 
 Value *makeFunctionValue(Statement *st, Parameter *pt, VarList *var_list, Inter *inter) {
     Value *tmp;
-    tmp = makeValue(inter);
+    tmp = makeObject(inter, NULL);
     tmp->type = function;
     tmp->data.function.function = copyStatement(st);
     tmp->data.function.pt = copyParameter(pt);
-    tmp->data.function.var = copyVarList(var_list, false, inter);
+    tmp->data.function.out_var = copyVarList(var_list, false, inter);
+    return tmp;
+}
+
+Value *makeClassValue(VarList *var_list, Inter *inter) {
+    Value *tmp;
+    tmp = makeObject(inter, NULL);
+    tmp->type = class;
+    tmp->data.class.out_var = copyVarList(var_list, false, inter);
     return tmp;
 }
 
 Value *makeListValue(Argument **arg_ad, Inter *inter, enum ListType type) {
     Value *tmp;
     Argument *at = *arg_ad;
-    tmp = makeValue(inter);
+    tmp = makeObject(inter, NULL);
     tmp->type = list;
     tmp->data.list.type = type;
     tmp->data.list.list = NULL;
@@ -66,9 +83,9 @@ Value *makeListValue(Argument **arg_ad, Inter *inter, enum ListType type) {
     return tmp;
 }
 
-Value *makeDictValue(Argument **arg_ad, bool new_hash, Result *result, Inter *inter, VarList *var_list) {
+Value *makeDictValue(Argument **arg_ad, bool new_hash, INTER_FUNCTIONSIG_NOT_ST) {
     Value *tmp;
-    tmp = makeValue(inter);
+    tmp = makeObject(inter, NULL);
     tmp->data.dict.size = 0;
     tmp->type = dict;
     if (new_hash) {
@@ -76,7 +93,7 @@ Value *makeDictValue(Argument **arg_ad, bool new_hash, Result *result, Inter *in
         gcAddTmp(&tmp->gc_status);
         tmp->data.dict.dict = hash->hashtable;
         freeResult(result);
-        argumentToVar(arg_ad, &tmp->data.dict.size, CALL_INTER_FUNCTIONSIG_NOT_ST(hash, result));
+        argumentToVar(arg_ad, &tmp->data.dict.size, CALL_INTER_FUNCTIONSIG_NOT_ST(hash, result, father));
         popVarList(hash);
         gcFreeTmpLink(&tmp->gc_status);
     }
@@ -97,18 +114,25 @@ Value *freeValue(Value *value, Inter *inter){
     if (value->next != NULL)
         value->next->last = value->last;
 
+    freeVarList(value->object.var, true);
     switch (value->type) {
         case string:
             memFree(value->data.str.str);
             break;
         case function: {
-            VarList *tmp = value->data.function.var;
+            VarList *tmp = value->data.function.out_var;
             freeParameter(value->data.function.pt, true);
             freeStatement(value->data.function.function);
             while (tmp != NULL)
                 tmp = freeVarList(tmp, true);
             break;
         }
+        case class: {
+            VarList *tmp = value->data.class.out_var;
+            while (tmp != NULL)
+                tmp = freeVarList(tmp, true);
+            break;
+        }
         case list:
             memFree(value->data.list.list);
             break;
@@ -167,22 +191,23 @@ void setResultCore(Result *ru) {
     ru->value = NULL;
 }
 
-void setResult(Result *ru, Inter *inter) {
+void setResult(Result *ru, Inter *inter, LinkValue *father) {
     freeResult(ru);
-    setResultBase(ru, inter);
+    setResultBase(ru, inter, father);
 }
 
-void setResultBase(Result *ru, Inter *inter) {
+void setResultBase(Result *ru, Inter *inter, LinkValue *father) {
     setResultCore(ru);
-    ru->value = makeLinkValue(inter->base, NULL, inter);
+    ru->value = makeLinkValue(inter->base, father, inter);
     gcAddTmp(&ru->value->gc_status);
 }
 
-void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, Statement *st, bool new) {
+void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, Statement *st, LinkValue *father,
+                    bool new) {
     if (!new && ru->type != error_return)
         return;
     if (new) {
-        setResult(ru, inter);
+        setResult(ru, inter, father);
         ru->type = error_return;
     }
     else{
@@ -192,8 +217,8 @@ void setResultError(Result *ru, Inter *inter, char *error_type, char *error_mess
     ru->error = connectError(makeError(error_type, error_message, st->line, st->code_file), ru->error);
 }
 
-void setResultOperationNone(Result *ru, Inter *inter) {
-    setResult(ru, inter);
+void setResultOperationNone(Result *ru, Inter *inter, LinkValue *father) {
+    setResult(ru, inter, father);
     ru->type = operation_return;
 }
 
@@ -265,6 +290,12 @@ void printValue(Value *value, FILE *debug){
         case none:
             writeLog(debug, INFO, "<None>", NULL);
             break;
+        case class:
+            writeLog(debug, INFO, "class on <%p>", value);
+            break;
+        case object_:
+            writeLog(debug, INFO, "object on <%p>", value);
+            break;
         default:
             writeLog(debug, INFO, "default on <%p>", value);
             break;