fix & feat: 修复了gc机制问题, 加入list赋值等方法

修复了gc机制iter_var只对链表头部的var标记的问题
增加了list的赋值、下标和切片方法

gc/gc.c

@@ -56,10 +56,10 @@ void gc_iterHashTable(HashTable *ht){
 void gc_iterVar(Var *var){
     if (var == NULL)
         return;
-    gc_addLink(&var->gc_status);
     if (gc_IterAlready(&var->gc_status))
         return;
     for (PASS; var != NULL; var = var->next){
+        gc_addLink(&var->gc_status);
         gc_iterLinkValue(var->name_);
         gc_iterLinkValue(var->value);
     }

include/inter.h

@@ -37,6 +37,9 @@ struct Inter{
         char *object_sub;
         char *object_mul;
         char *object_div;
+        char *object_del;
+        char *object_down;
+        char *object_slice;
         int default_pt_type;
     } data;
 };

include/run.h

@@ -31,6 +31,7 @@ ResultType setClass(INTER_FUNCTIONSIG);
 ResultType setFunction(INTER_FUNCTIONSIG);
 ResultType setLambda(INTER_FUNCTIONSIG);
 ResultType callBack(INTER_FUNCTIONSIG);
+ResultType elementSlice(INTER_FUNCTIONSIG);
 
 ResultType callBackCore(LinkValue *function_value, Argument *arg, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType callBackCorePt(LinkValue *function_value, Parameter *pt, long line, char *file, INTER_FUNCTIONSIG_NOT_ST);

include/statement.h

@@ -18,6 +18,7 @@ struct Statement{
         set_function,
         set_class,
         call_function,
+        slice_,
         if_branch,
         while_branch,
         for_branch,
@@ -100,6 +101,14 @@ struct Statement{
             struct Statement *function;
             struct Parameter *parameter;
         } call_function;
+        struct {
+            struct Statement *element;
+            struct Parameter *index;
+            enum SliceType{
+                SliceType_down_,
+                SliceType_slice_,
+            } type;
+        } slice_;
         struct {
             struct StatementList *if_list;  // if elif
             struct Statement *else_list;  // else分支(无condition)
@@ -258,6 +267,7 @@ Statement *makeClassStatement(Statement *name, Statement *function, Parameter *p
 Statement *makeFunctionStatement(Statement *name, Statement *function, struct Parameter *pt);
 Statement *makeLambdaStatement(Statement *function, Parameter *pt);
 Statement *makeCallStatement(Statement *function, struct Parameter *pt);
+Statement *makeSliceStatement(Statement *element, Parameter *index, enum SliceType type);
 Statement *makeIfStatement(long int line, char *file);
 Statement *makeWhileStatement(long int line, char *file);
 Statement *makeTryStatement(long int line, char *file);

include/token.h

@@ -128,6 +128,7 @@
 #define GOTO -32
 #define LABEL -33
 #define DECORATION -34
+#define SLICE -35
 
 #define printTokenEnter(tk, debug, type, message) do{ \
 writeLog(debug, type, message, NULL); \

include/value.h

@@ -178,6 +178,7 @@ Inherit *connectInherit(Inherit *base, Inherit *back);
 Inherit *connectSafeInherit(Inherit *base, Inherit *back);
 bool checkAttribution(Value *self, Value *father);
 
+Inherit *getInheritFromValueCore(LinkValue *num_father);
 Inherit *getInheritFromValue(Value *value, Inter *inter);
 bool callDel(Value *object_value, Result *result, Inter *inter, VarList *var_list);
 bool needDel(Value *object_value, Inter *inter);

main.c

@@ -22,9 +22,7 @@ int main(int argc, char *argv[]) {
 
 /** TODO-szh List
  * argument 设定 tmp_link
- * __call__ 设定
  * __var__ 设定
- * __del__ 设定
  * 下标和切片
  * 官方函数
  * 官方类

ofunc/src/io.c

@@ -5,17 +5,10 @@ ResultType vm_print(OfficialFunctionSig){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=true},
                            {.type=name_value, .name="end", .must=0, .value=NULL},
                            {.must=-1}};
-    {
-        int status;
-        status = parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
-            return result->type;
-        if (status != 1) {
-            setResultError(result, inter, "ArgumentException", "Too less Argument", 0, "sys", belong, true);
-            return error_return;
-        }
-        freeResult(result);
-    }
+    parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (!run_continue(result))
+        return result->type;
+    freeResult(result);
 
     arg = ap[0].arg;
     for (int i=0; i < ap[0].c_count; arg = arg->next,i++)

ofunc/src/list.c

@@ -1,17 +1,166 @@
 #include "__ofunc.h"
 
+ResultType list_slice(OfficialFunctionSig){
+    ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
+                           {.type=only_value, .must=1, .long_arg=false},
+                           {.type=only_value, .must=0, .long_arg=false},
+                           {.type=only_value, .must=0, .long_arg=false},
+                           {.must=-1}};
+    long size;
+    long first;
+    long second;
+    long stride;
+    setResultCore(result);
+    parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (!run_continue(result))
+        return result->type;
+    freeResult(result);
+
+    if (ap[0].value->value->type != list)
+        goto type_error;
+    size = ap[0].value->value->data.list.size;
+    if (ap[1].value == NULL || ap[1].value->value->type == none)
+        first = 0;
+    else if (ap[1].value->value->type == number)
+        first = ap[1].value->value->data.num.num;
+    else
+        goto type_error;
+
+    if (ap[2].value == NULL || ap[2].value->value->type == none)
+        second = size;
+    else if (ap[2].value->value->type == number)
+        second = ap[2].value->value->data.num.num;
+    else
+        goto type_error;
+
+    if (ap[3].value == NULL || ap[3].value->value->type == none)
+        stride = 1;
+    else if (ap[3].value->value->type == number)
+        stride = ap[3].value->value->data.num.num;
+    else
+        goto type_error;
+
+    first = first < 0 ? first + size : first;
+    second = second < 0 ? second + size : second;
+    if (second > size || first >= size){
+        setResultError(result, inter, "IndexException", "Index too max", 0, "sys", belong, true);
+        return error_return;
+    } else if (first < 0 || second <= 0){
+        setResultError(result, inter, "IndexException", "Index too small", 0, "sys", belong, true);
+        return error_return;
+    }
+
+    if (stride < 0){
+        long tmp = first;
+        stride = -stride;
+        first = second;
+        second = tmp;
+    }
+    if (stride == 0 || first > second){
+        setResultError(result, inter, "StrideException", "Stride Error", 0, "sys", belong, true);
+        return error_return;
+    }
+
+    {
+        Argument *new_list = NULL;
+        Argument *back_up = NULL;
+        LinkValue *new = NULL;
+        for (long i = first; i < second; i += stride) {
+            LinkValue *element = ap[0].value->value->data.list.list[i];
+            new_list = connectValueArgument(element, new_list);
+        }
+        back_up = new_list;
+        new = makeLinkValue(makeListValue(&new_list, inter, ap[0].value->value->data.list.type), belong, inter);
+        setResultOperationBase(result, new);
+        freeArgument(back_up, true);
+    }
+    return result->type;
+
+    type_error:
+    setResultError(result, inter, "TypeException", "Get Not Support Type", 0, "sys", belong, true);
+    return error_return;
+}
+
+ResultType list_down_assignment(OfficialFunctionSig){
+    ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
+                           {.type=only_value, .must=1, .long_arg=false},
+                           {.type=only_value, .must=1, .long_arg=false},
+                           {.must=-1}};
+    long size;
+    long index;
+    setResultCore(result);
+    parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (!run_continue(result))
+        return result->type;
+    freeResult(result);
+
+    if (ap[0].value->value->type != list || ap[2].value->value->type != number){
+        setResultError(result, inter, "TypeException", "Get Not Support Type", 0, "sys", belong, true);
+        return error_return;
+    }
+    size = ap[0].value->value->data.list.size;
+    index = ap[2].value->value->data.num.num;
+    if (index < 0)
+        index = size + index;
+    if (index >= size){
+        setResultError(result, inter, "IndexException", "Index too max", 0, "sys", belong, true);
+        return error_return;
+    } else if (index < 0){
+        setResultError(result, inter, "IndexException", "Index too small", 0, "sys", belong, true);
+        return error_return;
+    }
+    ap[0].value->value->data.list.list[index] = ap[1].value;
+    setResultOperationBase(result, ap[1].value);
+    return result->type;
+}
+
+ResultType list_down(OfficialFunctionSig){
+    ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
+                           {.type=only_value, .must=1, .long_arg=false},
+                           {.must=-1}};
+    long size;
+    long index;
+    LinkValue *element = NULL;
+    setResultCore(result);
+    parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (!run_continue(result))
+        return result->type;
+    freeResult(result);
+
+    if (ap[0].value->value->type != list || ap[1].value->value->type != number){
+        setResultError(result, inter, "TypeException", "Get Not Support Type", 0, "sys", belong, true);
+        return error_return;
+    }
+    size = ap[0].value->value->data.list.size;
+    index = ap[1].value->value->data.num.num;
+    if (index < 0)
+        index = size + index;
+    if (index >= size){
+        setResultError(result, inter, "IndexException", "Index too max", 0, "sys", belong, true);
+        return error_return;
+    } else if (index < 0){
+        setResultError(result, inter, "IndexException", "Index too small", 0, "sys", belong, true);
+        return error_return;
+    }
+    element = ap[0].value->value->data.list.list[index];
+    setResultOperationBase(result, copyLinkValue(element, inter));
+    return result->type;
+}
+
 void registeredList(RegisteredFunctionSig){
     LinkValue *object = makeLinkValue(inter->data.list, inter->base_father, inter);
-//    VarList *object_var = object->value->object.var;
-//    VarList *object_backup = NULL;
-//    NameFunc tmp[] = {{NULL, NULL}};
+    VarList *object_var = object->value->object.var;
+    VarList *object_backup = NULL;
+    NameFunc tmp[] = {{"__down__", list_down, object_free_},
+                      {"__slice__", list_slice, object_free_},
+                      {"__down_assignment__", list_down_assignment, object_free_},
+                      {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
     addStrVar("list", false, object, belong, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
-
-//    object_backup = object_var->next;
-//    object_var->next = inter->var_list;
-//    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
-//    object_var->next = object_backup;
+    object_backup = object_var->next;
+    object_var->next = inter->var_list;
+    iterNameFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(object_var));
+    object_var->next = object_backup;
 
     gc_freeTmpLink(&object->gc_status);
 }

ofunc/src/object.c

@@ -15,13 +15,9 @@ ResultType object_new_(OfficialFunctionSig){
     }
 
     {
-        VarList *new_var = NULL;
-        Value *new_object = NULL;
-        Argument *father_arg = makeValueArgument(ap[1].value);
-        Inherit *object_father = setFather(father_arg);
-        freeArgument(father_arg, true);
-        new_var = copyVarList(ap[1].value->value->object.out_var, false, inter);
-        new_object = makeObject(inter, NULL, new_var, object_father);
+        Inherit *object_father = getInheritFromValueCore(ap[1].value);
+        VarList *new_var = copyVarList(ap[1].value->value->object.out_var, false, inter);
+        Value *new_object = makeObject(inter, NULL, new_var, object_father);
         value = makeLinkValue(new_object, belong, inter);
         setResultOperation(result, value);
     }

ofunc/src/sys.c

@@ -8,12 +8,10 @@ ResultType vm_super(OfficialFunctionSig){
                            {.type=name_value, .name="obj_", .must=1, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
-    {
-        parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-        if (!run_continue(result))
-            return result->type;
-        freeResult(result);
-    }
+    parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (!run_continue(result))
+        return result->type;
+    freeResult(result);
 
     arg_father = ap[0].value->value;
     arg_child = ap[1].value->value;

parser/grammar.c

@@ -1142,8 +1142,43 @@ int tailCall(PASERSSIGNATURE, Token *left_token, Statement **st){
     return 1;
 }
 void parserCallBack(PASERSSIGNATURE){
-    return tailOperation(CALLPASERSSIGNATURE, parserPoint, tailCall, POINT, CALLBACK,
-            "point", "call back");
+    return tailOperation(CALLPASERSSIGNATURE, parserSlice, tailCall, SLICE, CALLBACK,
+            "slice", "call back");
+}
+
+int tailSlice(PASERSSIGNATURE, Token *left_token, Statement **st){
+    Parameter *pt = NULL;
+    Token *tmp = NULL;
+    enum SliceType type;  // 0-slice  1-down
+    if (readBackToken(pm) != MATHER_LB)
+        return -1;
+    long int line = delToken(pm);
+
+    if (!callChildToken(CALLPASERSSIGNATURE, parserPolynomial, POLYNOMIAL, &tmp, "Don't get slice/down element", syntax_error))
+        PASS;
+    if (readBackToken(pm) == MATHER_COLON)
+        type = SliceType_slice_;
+    else
+        type = SliceType_down_;
+    line = tmp->line;
+    addToken_(pm ,tmp);
+
+    if (!parserParameter(CALLPASERSSIGNATURE, &pt, true, true, true, true, (type == SliceType_down_ ? MATHER_COMMA : MATHER_COLON), MATHER_ASSIGNMENT)) {
+        syntaxError(pm, syntax_error, line, 1, "Don't get slice element");
+        return 0;
+    }
+    if (!checkToken(pm, MATHER_RB)){
+        freeParameter(pt, true);
+        syntaxError(pm, syntax_error, line, 1, "Don't get ] from slice");
+        return 0;
+    }
+
+    *st = makeSliceStatement(left_token->data.st, pt, type);
+    return 1;
+}
+void parserSlice(PASERSSIGNATURE){
+    return tailOperation(CALLPASERSSIGNATURE, parserPoint, tailSlice, POINT, SLICE,
+                         "point", "slice");
 }
 
 /**

parser/include/__grammar.h

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

src/inter.c

@@ -62,6 +62,9 @@ void setBaseInterData(struct Inter *inter){
     inter->data.object_mul = memStrcpy("__mul__");
     inter->data.object_div = memStrcpy("__div__");
     inter->data.object_call = memStrcpy("__call__");
+    inter->data.object_del = memStrcpy("__del__");
+    inter->data.object_down = memStrcpy("__down__");
+    inter->data.object_slice = memStrcpy("__slice__");
     inter->data.default_pt_type = free_;
 
 }
@@ -89,6 +92,9 @@ void freeBaseInterData(struct Inter *inter){
     memFree(inter->data.object_mul);
     memFree(inter->data.object_div);
     memFree(inter->data.object_call);
+    memFree(inter->data.object_del);
+    memFree(inter->data.object_down);
+    memFree(inter->data.object_slice);
 
     memFree(inter->data.log_dir);
     if (inter->data.log_dir != NULL) {

src/run.c

@@ -38,6 +38,9 @@ ResultType runStatement(INTER_FUNCTIONSIG) {
         case set_function:
             type = setFunction(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
             break;
+        case slice_:
+            type = elementSlice(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
+            break;
         case call_function:
             type = callBack(CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
             break;

src/runcall.c

@@ -95,19 +95,41 @@ ResultType setLambda(INTER_FUNCTIONSIG) {
     return result->type;
 }
 
+ResultType elementSlice(INTER_FUNCTIONSIG) {
+    LinkValue *element = NULL;
+    LinkValue *_func_ = NULL;
+    char *func_name = NULL;
+    setResultCore(result);
+    if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.slice_.element, var_list, result, belong)))
+        return result->type;
+    element = result->value;
+    result->value = NULL;
+    freeResult(result);
+
+    func_name = st->u.slice_.type == SliceType_down_ ? inter->data.object_down : inter->data.object_slice;
+    _func_ = findAttributes(func_name, false, element, inter);
+    if (_func_ != NULL){
+        gc_addTmpLink(&_func_->gc_status);
+        callBackCorePt(_func_, st->u.slice_.index, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+        gc_freeTmpLink(&_func_->gc_status);
+    }
+    else
+        setResultErrorSt(result, inter, "TypeException", "Don't find __down__/__slice__", st, belong, true);
+
+    gc_freeTmpLink(&element->gc_status);
+    return result->type;
+}
+
 ResultType callBack(INTER_FUNCTIONSIG) {
     LinkValue *function_value = NULL;
     setResultCore(result);
     if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.call_function.function, var_list, result, belong)))
-        goto return_;
+        return result->type;
     function_value = result->value;
     result->value = NULL;
     freeResult(result);
-
     callBackCorePt(function_value, st->u.call_function.parameter, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-
     gc_freeTmpLink(&function_value->gc_status);
-    return_:
     return result->type;
 }
 

src/runoperation.c

@@ -160,6 +160,34 @@ ResultType assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST){
         freeArgument(call, false);
         freeParameter(pt, true);
     }
+    else if (name->type == slice_ && name->u.slice_.type == SliceType_down_){
+        LinkValue *iter = NULL;
+        LinkValue *_down_assignment_ = NULL;
+        Parameter *pt = name->u.slice_.index;
+        if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(name->u.slice_.element, var_list, result, belong)))
+            goto return_;
+        iter = result->value;
+        result->value = NULL;
+        freeResult(result);
+        _down_assignment_ = findAttributes("__down_assignment__", false, iter, inter);
+        if (_down_assignment_ != NULL){
+            Argument *arg = makeValueArgument(value);
+            gc_addTmpLink(&_down_assignment_->gc_status);
+            arg->next = getArgument(pt, false, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+            if (!run_continue(result))
+                goto daerror_;
+
+            freeResult(result);
+            callBackCore(_down_assignment_, arg, name->line, name->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+
+            daerror_:
+            freeArgument(arg, true);
+            gc_freeTmpLink(&_down_assignment_->gc_status);
+        }
+        else
+            setResultErrorSt(result, inter, "TypeException", "Don't find __down_assignment__", name, belong, true);
+        gc_freeTmpLink(&iter->gc_status);
+    }
     else if (name->type == operation && name->u.operation.OperationType == OPT_POINT)
         pointAss(name, value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     else{

src/statement.c

@@ -172,6 +172,15 @@ Statement *makeCallStatement(Statement *function, Parameter *pt) {
     return tmp;
 }
 
+Statement *makeSliceStatement(Statement *element, Parameter *index, enum SliceType type) {
+    Statement *tmp = makeStatement(element->line, element->code_file);
+    tmp->type = slice_;
+    tmp->u.slice_.element = element;
+    tmp->u.slice_.index = index;
+    tmp->u.slice_.type = type;
+    return tmp;
+}
+
 Statement *makeIfStatement(long int line, char *file) {
     Statement *tmp = makeStatement(line, file);
     tmp->type = if_branch;
@@ -368,6 +377,10 @@ void freeStatement(Statement *st){
                 freeStatement(st->u.call_function.function);
                 freeParameter(st->u.call_function.parameter, true);
                 break;
+            case slice_:
+                freeStatement(st->u.slice_.element);
+                freeParameter(st->u.slice_.index, true);
+                break;
             case base_list:
                 freeParameter(st->u.base_list.list, true);
                 break;
@@ -521,6 +534,10 @@ Statement *copyStatementCore(Statement *st){
             new->u.call_function.function = copyStatement(st->u.call_function.function);
             new->u.call_function.parameter = copyParameter(st->u.call_function.parameter);
             break;
+        case slice_:
+            new->u.slice_.element = copyStatement(st->u.slice_.element);
+            new->u.slice_.index = copyParameter(st->u.slice_.index);
+            break;
         case base_list:
             new->u.base_list.type = st->u.base_list.type;
             new->u.base_list.list = copyParameter(st->u.base_list.list);

src/value.c

@@ -486,9 +486,13 @@ Inherit *connectSafeInherit(Inherit *base, Inherit *back){
     reutrn_: return base;
 }
 
-Inherit *getInheritFromValue(Value *value, Inter *inter){  // TODO-szh set clas 和 __new__ 应用此函数
-    Inherit *object_father = NULL;
+Inherit *getInheritFromValue(Value *value, Inter *inter){
     LinkValue *num_father = makeLinkValue(value, inter->base_father, inter);
+    return getInheritFromValueCore(num_father);
+}
+
+Inherit *getInheritFromValueCore(LinkValue *num_father) {
+    Inherit *object_father;
     Argument *father_arg = makeValueArgument(num_father);
     gc_addTmpLink(&num_father->gc_status);
     object_father = setFather(father_arg);
@@ -498,7 +502,7 @@ Inherit *getInheritFromValue(Value *value, Inter *inter){  // TODO-szh set clas
 }
 
 bool needDel(Value *object_value, Inter *inter) {
-    LinkValue *_del_ = checkStrVar("__del__", false, CALL_INTER_FUNCTIONSIG_CORE(object_value->object.var));
+    LinkValue *_del_ = checkStrVar(inter->data.object_del, false, CALL_INTER_FUNCTIONSIG_CORE(object_value->object.var));
     enum FunctionPtType type;
     if (_del_ == NULL)
         return false;
@@ -511,7 +515,7 @@ bool needDel(Value *object_value, Inter *inter) {
 }
 
 bool callDel(Value *object_value, Result *result, Inter *inter, VarList *var_list) {
-    LinkValue *_del_ = findStrVar("__del__", false, CALL_INTER_FUNCTIONSIG_CORE(object_value->object.var));
+    LinkValue *_del_ = findStrVar(inter->data.object_del, false, CALL_INTER_FUNCTIONSIG_CORE(object_value->object.var));
     setResultCore(result);
 
     if (_del_ != NULL){