fix: 调整gc机制

添加gc机制对FatherValue的支持
调整了gc函数的名字

gc/freeze.c

@@ -5,11 +5,11 @@ void gc_freezeHashTable(HashTable *ht, bool is_lock){
         return;
 
     if (is_lock)
-        gcAddTmp(&ht->gc_status);
+        gc_addTmpLink(&ht->gc_status);
     else
-        gcFreeTmpLink(&ht->gc_status);
+        gc_freeTmpLink(&ht->gc_status);
 
-    setIterAlready(&ht->gc_status);
+    gc_IterAlready(&ht->gc_status);
 }
 
 void iterFreezeVarList(VarList *freeze, VarList *base, bool is_lock){

gc/gc.c

@@ -3,22 +3,27 @@
 void gc_iterLinkValue(LinkValue *value){
     if (value == NULL)
         return;
-    gcAddLink(&value->gc_status);
-    if (!setIterAlready(&value->gc_status)){
+    gc_addLink(&value->gc_status);
+    if (!gc_IterAlready(&value->gc_status)){
         gc_iterLinkValue(value->father);
         gc_iterValue(value->value);
     }
 }
 
+void gc_fatherValue(FatherValue *value){
+    for (PASS; value != NULL; value = value->next)
+        gc_iterLinkValue(value->value);
+}
+
 void gc_iterValue(Value *value){
     if (value == NULL)
         return;
-    gcAddLink(&value->gc_status);
-    if (setIterAlready(&value->gc_status))
+    gc_addLink(&value->gc_status);
+    if (gc_IterAlready(&value->gc_status))
         return;
     gc_varList(value->object.var);
     gc_varList(value->object.out_var);
-    // TODO-szh 处理father_value
+    gc_fatherValue(value->object.father);
     switch (value->type) {
         case list:
             for (int i=0;i < value->data.list.size;i++)
@@ -40,8 +45,8 @@ void gc_varList(VarList *vl){
 void gc_iterHashTable(HashTable *ht){
     if (ht == NULL)
         return;
-    gcAddLink(&ht->gc_status);
-    if (setIterAlready(&ht->gc_status))
+    gc_addLink(&ht->gc_status);
+    if (gc_IterAlready(&ht->gc_status))
         return;
     for (int i=0;i < MAX_SIZE;i++)
         gc_iterVar(ht->hashtable[i]);
@@ -50,8 +55,8 @@ void gc_iterHashTable(HashTable *ht){
 void gc_iterVar(Var *var){
     if (var == NULL)
         return;
-    gcAddLink(&var->gc_status);
-    if (setIterAlready(&var->gc_status))
+    gc_addLink(&var->gc_status);
+    if (gc_IterAlready(&var->gc_status))
         return;
     for (PASS; var != NULL; var = var->next){
         gc_iterLinkValue(var->name_);
@@ -75,40 +80,40 @@ void gc_resetBase(Inter *inter){
 
 void gc_checkBase(Inter *inter){
     for (Value *value_base = inter->base; value_base != NULL; value_base = value_base->gc_next)
-        if (!needFree(&value_base->gc_status) && !value_base->gc_status.continue_)
+        if (!gc_needFree(&value_base->gc_status) && !value_base->gc_status.continue_)
             gc_iterValue(value_base);
 
     for (LinkValue *link_base = inter->link_base; link_base != NULL; link_base = link_base->gc_next)
-        if (!needFree(&link_base->gc_status) && !link_base->gc_status.continue_)
+        if (!gc_needFree(&link_base->gc_status) && !link_base->gc_status.continue_)
             gc_iterLinkValue(link_base);
 
     for (HashTable *hash_base = inter->hash_base; hash_base != NULL; hash_base = hash_base->gc_next)
-        if (!needFree(&hash_base->gc_status) && !hash_base->gc_status.continue_)
+        if (!gc_needFree(&hash_base->gc_status) && !hash_base->gc_status.continue_)
             gc_iterHashTable(hash_base);
 }
 
 void gc_freeBase(Inter *inter){
 #if START_GC
     for (Value *value_base = inter->base; value_base != NULL;)
-        if (needFree(&value_base->gc_status))
+        if (gc_needFree(&value_base->gc_status))
             value_base = freeValue(value_base, inter);
         else
             value_base = value_base->gc_next;
 
     for (LinkValue *link_base = inter->link_base; link_base != NULL;)
-        if (needFree(&link_base->gc_status))
+        if (gc_needFree(&link_base->gc_status))
             link_base = freeLinkValue(link_base, inter);
         else
             link_base = link_base->gc_next;
 
     for (HashTable *hash_base = inter->hash_base; hash_base != NULL;)
-        if (needFree(&hash_base->gc_status))
+        if (gc_needFree(&hash_base->gc_status))
             hash_base = freeHashTable(hash_base, inter);
         else
             hash_base = hash_base->gc_next;
 
     for (Var *var_base = inter->base_var; var_base != NULL;)
-        if (needFree(&var_base->gc_status))
+        if (gc_needFree(&var_base->gc_status))
             var_base = freeVar(var_base, inter);
         else
             var_base = var_base->gc_next;

gc/set.c

@@ -11,33 +11,33 @@ void setGC(GCStatus *gcs){
     gcs->statement_link = 0;
 }
 
-void gcAddTmp(GCStatus *gcs){
+void gc_addTmpLink(GCStatus *gcs){
     gcs->tmp_link ++;
 }
 
-void gcAddLink(GCStatus *gcs){
+void gc_addLink(GCStatus *gcs){
     gcs->link ++;
 }
 
-void gcAddStatementLink(GCStatus *gcs){
+void gc_addStatementLink(GCStatus *gcs){
     gcs->statement_link ++;
 }
 
-void gcFreeStatementLink(GCStatus *gcs){
+void gc_freeStatementLink(GCStatus *gcs){
     gcs->statement_link --;
 }
 
-void gcFreeTmpLink(GCStatus *gcs){
+void gc_freeTmpLink(GCStatus *gcs){
     gcs->tmp_link --;
 }
 
-bool setIterAlready(GCStatus *gcs){
+bool gc_IterAlready(GCStatus *gcs){
     bool return_ = gcs->continue_;
     gcs->continue_ = true;
     return return_;
 }
 
-bool needFree(GCStatus *gcs){
+bool gc_needFree(GCStatus *gcs){
     if (gcs->statement_link == 0 && gcs->tmp_link == 0 && gcs->link == 0)
         return true;
     return false;

include/gc.h

@@ -21,13 +21,13 @@ struct VarList;
 
 void resetGC(GCStatus *gcs);
 void setGC(GCStatus *gcs);
-void gcAddTmp(GCStatus *gcs);
-void gcAddLink(GCStatus *gcs);
-void gcAddStatementLink(GCStatus *gcs);
-void gcFreeStatementLink(GCStatus *gcs);
-void gcFreeTmpLink(GCStatus *gcs);
-bool setIterAlready(GCStatus *gcs);
-bool needFree(GCStatus *gcs);
+void gc_addTmpLink(GCStatus *gcs);
+void gc_addLink(GCStatus *gcs);
+void gc_addStatementLink(GCStatus *gcs);
+void gc_freeStatementLink(GCStatus *gcs);
+void gc_freeTmpLink(GCStatus *gcs);
+bool gc_IterAlready(GCStatus *gcs);
+bool gc_needFree(GCStatus *gcs);
 
 void gc_freeBase(struct Inter *inter);
 void gc_checkBase(struct Inter *inter);

src/inter.c

@@ -60,7 +60,7 @@ Inter *makeInter(char *code_file, char *debug) {
     }
 
     Value *none_value = makeNoneValue(tmp);  // 注册None值
-    gcAddStatementLink(&none_value->gc_status);
+    gc_addStatementLink(&none_value->gc_status);
     return tmp;
 }
 

src/parameter.c

@@ -20,7 +20,7 @@ Argument *makeArgument(void){
 Argument *makeValueArgument(LinkValue *value){
     Argument *tmp = makeArgument();
     tmp->data.value = value;
-    gcAddTmp(&value->gc_status);
+    gc_addTmpLink(&value->gc_status);
     return tmp;
 }
 
@@ -29,7 +29,7 @@ Argument *makeStatementNameArgument(LinkValue *value, Statement *name){
     tmp->type = name_arg;
     tmp->data.value = value;
     tmp->data.name = name;
-    gcAddTmp(&value->gc_status);
+    gc_addTmpLink(&value->gc_status);
     return tmp;
 }
 
@@ -40,8 +40,8 @@ Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *na
     tmp->data.value = value;
     tmp->data.name_ = memStrcpy(name);
     tmp->data.name_value = name_value;
-    gcAddTmp(&value->gc_status);
-    gcAddTmp(&name_value->gc_status);
+    gc_addTmpLink(&value->gc_status);
+    gc_addTmpLink(&name_value->gc_status);
     return tmp;
 }
 
@@ -78,9 +78,9 @@ void freeArgument(Argument *at, bool free_st) {
         memFree(at->data.name_);
 
         if (at->data.name_value != NULL)
-            gcFreeTmpLink(&at->data.name_value->gc_status);
+            gc_freeTmpLink(&at->data.name_value->gc_status);
         if (at->data.value != NULL)
-            gcFreeTmpLink(&at->data.value->gc_status);
+            gc_freeTmpLink(&at->data.value->gc_status);
 
         memFree(at);
     }
@@ -393,13 +393,13 @@ ResultType iterParameter(Parameter *call, Argument **base_ad, bool is_dict, INTE
                 LinkValue *value = result->value;
                 setResultCore(result);
                 if(operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(call->data.name, var_list, result, father))) {
-                    gcFreeTmpLink(&value->gc_status);
+                    gc_freeTmpLink(&value->gc_status);
                     goto return_;
                 }
                 char *name_str = getNameFromValue(result->value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
                 base = connectCharNameArgument(value, result->value, name_str, base);
                 memFree(name_str);
-                gcFreeTmpLink(&value->gc_status);
+                gc_freeTmpLink(&value->gc_status);
             }
             else
                 base = connectStatementNameArgument(result->value, call->data.name, base);

src/runcall.c

@@ -18,7 +18,7 @@ ResultType setClass(INTER_FUNCTIONSIG) {
         goto error_;
 
     tmp = makeLinkValue(makeClassValue(copyVarList(var_list, false, inter), inter, class_father), father, inter);
-    gcAddTmp(&tmp->gc_status);
+    gc_addTmpLink(&tmp->gc_status);
 
     father_var = tmp->value->object.var->next;
     tmp->value->object.var->next = var_list;
@@ -33,11 +33,11 @@ ResultType setClass(INTER_FUNCTIONSIG) {
     if (run_continue(result))
         setResult(result, inter, father);
 
-    gcFreeTmpLink(&tmp->gc_status);
+    gc_freeTmpLink(&tmp->gc_status);
     return result->type;
 
     error_:
-    gcFreeTmpLink(&tmp->gc_status);
+    gc_freeTmpLink(&tmp->gc_status);
     setResultError(result, inter, NULL, NULL, st, father, false);
     return result->type;
 }
@@ -97,9 +97,9 @@ ResultType callClass(LinkValue *class_value, Parameter *parameter, INTER_FUNCTIO
         setResultCore(&__init__result);
         __init__ = makeLinkValue(__init__->value, value, inter);
 
-        gcAddTmp(&__init__->gc_status);
+        gc_addTmpLink(&__init__->gc_status);
         callFunction(__init__, parameter, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &__init__result, value));
-        gcFreeTmpLink(&__init__->gc_status);
+        gc_freeTmpLink(&__init__->gc_status);
 
         if (!run_continue_type(__init__result.type)){
             freeResult(result);
@@ -116,15 +116,15 @@ ResultType callClass(LinkValue *class_value, Parameter *parameter, INTER_FUNCTIO
 ResultType callFunction(LinkValue *function_value, Parameter *parameter, INTER_FUNCTIONSIG_NOT_ST) {
     VarList *function_var = NULL;
     setResultCore(result);
-    gcAddTmp(&function_value->gc_status);
+    gc_addTmpLink(&function_value->gc_status);
 
     function_var = pushVarList(function_value->value->object.out_var, inter);
-    gcAddTmp(&function_var->hashtable->gc_status);
+    gc_addTmpLink(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, true);
 
     setParameter(parameter, function_value->value->data.function.pt, function_var, function_value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, father));
     if (!run_continue(result)) {
-        gcAddTmp(&function_var->hashtable->gc_status);
+        gc_addTmpLink(&function_var->hashtable->gc_status);
         runFREEZE(inter, var_list, function_var, false);
         popVarList(function_var);
         goto return_;
@@ -133,11 +133,11 @@ ResultType callFunction(LinkValue *function_value, Parameter *parameter, INTER_F
     freeResult(result);
     functionSafeInterStatement(CALL_INTER_FUNCTIONSIG(function_value->value->data.function.function, function_var, result, function_value));
 
-    gcFreeTmpLink(&function_var->hashtable->gc_status);
+    gc_freeTmpLink(&function_var->hashtable->gc_status);
     runFREEZE(inter, var_list, function_var, false);
     popVarList(function_var);
 
     return_:
-    gcFreeTmpLink(&function_value->gc_status);
+    gc_freeTmpLink(&function_value->gc_status);
     return result->type;
 }

src/runoperation.c

@@ -178,7 +178,7 @@ ResultType pointOperation(INTER_FUNCTIONSIG) {
     runFREEZE(inter, var_list, object, false);
     if (out_var != NULL)
         out_var->next = NULL;
-    gcFreeTmpLink(&left->gc_status);
+    gc_freeTmpLink(&left->gc_status);
     return result->type;
 }
 
@@ -196,7 +196,7 @@ ResultType assOperation(INTER_FUNCTIONSIG) {
 ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
     int int_times;
     setResultCore(result);
-    gcAddTmp(&value->gc_status);
+    gc_addTmpLink(&value->gc_status);
 
     if (name->type == base_list && name->u.base_list.type == value_tuple){
         Parameter *pt = NULL;
@@ -241,11 +241,11 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
 
         result->type = operation_return;
         result->value = value;
-        gcAddTmp(&result->value->gc_status);
+        gc_addTmpLink(&result->value->gc_status);
     }
 
     return_:
-    gcFreeTmpLink(&value->gc_status);
+    gc_freeTmpLink(&value->gc_status);
     return result->type;
 }
 
@@ -318,7 +318,7 @@ ResultType getBaseValue(INTER_FUNCTIONSIG) {
         result->value = makeLinkValue(makeStringValue(st->u.base_value.str, inter), father, inter);
 
     result->type = operation_return;
-    gcAddTmp(&result->value->gc_status);
+    gc_addTmpLink(&result->value->gc_status);
     return result->type;
 }
 

src/statement.c

@@ -42,7 +42,7 @@ Statement *makeBaseLinkValueStatement(LinkValue *value, long int line, char *fil
     tmp->u.base_value.type = link_value;
     tmp->u.base_value.value = value;
     tmp->u.base_value.str = NULL;
-    gcAddStatementLink(&value->gc_status);
+    gc_addStatementLink(&value->gc_status);
     return tmp;
 }
 
@@ -220,7 +220,7 @@ void freeStatement(Statement *st){
                 break;
             case base_value:
                 if (st->u.base_value.type == link_value)
-                    gcFreeStatementLink(&st->u.base_value.value->gc_status);
+                    gc_freeStatementLink(&st->u.base_value.value->gc_status);
                 else
                     memFree(st->u.base_value.str);
                 break;
@@ -331,7 +331,7 @@ Statement *copyStatementCore(Statement *st){
             new->u.base_value.type = st->u.base_value.type;
             if (new->u.base_value.type == link_value) {
                 new->u.base_value.value = st->u.base_value.value;
-                gcAddStatementLink(&new->u.base_value.value->gc_status);
+                gc_addStatementLink(&new->u.base_value.value->gc_status);
             }
             else
                 new->u.base_value.str = memStrcpy(st->u.base_value.str);

src/value.c

@@ -89,12 +89,12 @@ Value *makeDictValue(Argument **arg_ad, bool new_hash, INTER_FUNCTIONSIG_NOT_ST)
     tmp->type = dict;
     if (new_hash) {
         VarList *hash = pushVarList(var_list, inter);
-        gcAddTmp(&tmp->gc_status);
+        gc_addTmpLink(&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, father));
         popVarList(hash);
-        gcFreeTmpLink(&tmp->gc_status);
+        gc_freeTmpLink(&tmp->gc_status);
     }
     else
         tmp->data.dict.dict = NULL;
@@ -201,7 +201,7 @@ void setResult(Result *ru, Inter *inter, LinkValue *father) {
 void setResultBase(Result *ru, Inter *inter, LinkValue *father) {
     setResultCore(ru);
     ru->value = makeLinkValue(inter->base, father, inter);
-    gcAddTmp(&ru->value->gc_status);
+    gc_addTmpLink(&ru->value->gc_status);
 }
 
 void setResultError(Result *ru, Inter *inter, char *error_type, char *error_message, Statement *st, LinkValue *father,
@@ -233,14 +233,14 @@ void setResultOperationBase(Result *ru, LinkValue *value, Inter *inter) {
     setResultCore(ru);
     ru->value = value;
     if (value != NULL)
-        gcAddTmp(&ru->value->gc_status);
+        gc_addTmpLink(&ru->value->gc_status);
     ru->type = operation_return;
 }
 
 void freeResult(Result *ru){
     freeResultSave(ru);
     if (ru->value != NULL) {
-        gcFreeTmpLink(&ru->value->gc_status);
+        gc_freeTmpLink(&ru->value->gc_status);
         ru->value = NULL;
     }
 }