dict函数解包完成

inter/cfunc.c

@@ -97,6 +97,22 @@ GWARF_value to_object(GWARF_value value, var_list *the_var){  // 把GWARF_value
 }
 
 
+GWARF_result get_object(parameter *tmp_s, char *name, var_list *the_var){  // 生成一个object
+    GWARF_result func_result;
+    func_result.u = statement_end;
+    func_result.value.type = NULL_value;
+    func_result.value.value.int_value = 0;
+    var *tmp = find_var(the_var, 0, name);
+    if(tmp != NULL){
+        func_result.value = tmp->value;
+    }
+    else{
+        return to_error("Object Name Not Found", "NameException", the_var);
+    }
+    return call_back_core(func_result, the_var, tmp_s);
+}
+
+
 GWARF_result to_error(char *error_info, char *error_type, var_list *the_var){  // 把GWARF_value封装成error
     GWARF_result func_result, return_result;
     GWARF_value tmp_value;

inter/interpreter.c

@@ -313,7 +313,6 @@ GWARF_result read_statement(statement *the_statement, var_list *the_var, var_lis
         case down:{
             GWARF_result tmp_result = traverse((the_statement->code).down.base_var, the_var, false), get;
             if(is_error(&tmp_result)){  // Name Error错误
-                // puts("STOP:: Name No Found!");
                 return_value = tmp_result;
                 goto the_break_down;
             }
@@ -1809,7 +1808,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
     return_result.value.type = NULL_value;
     return_result.value.value.int_value = 0;
 
-    int assignment_type = 0;  // 0-根据tmp_x进行赋值，1-根据tmp_s赋值
+    int assignment_type = 0;  // 0-根据tmp_x进行赋值，1-根据tmp_s赋值，2-赋值到kwargs
     var_list *tmp_var = make_var_base(make_hash_var());  // 为1-模式准备
 
     while(1){
@@ -1860,20 +1859,65 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                     if(tmp_x == NULL){
                         break;  // 形参录入完毕
                     }
-                    GWARF_result tmp_x_var = traverse(tmp_x->u.var, tmp_var, false);
-                    if((!is_error(&tmp_x_var)) && (!is_space(&tmp_x_var))){
-                        assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp_x_var);
-                    }
-                    else if(tmp_x->type == name_value){
-                        GWARF_result tmp = traverse(tmp_x->u.value, the_var, false);  // 执行形参
-                        if(is_error(&tmp) || is_space(&tmp)){
-                            return tmp;
+                    if(tmp_x->type == put_kwargs){  // 如果遇到了**kwargs，直接把tmp_var中的哈希表合并
+                        GWARF_value dict_tmp = get_object(NULL, "dict", old_var_list).value;// 生成一个空的dict
+                        hash_var *var_dict = tmp_var->hash_var_base;
+                        for(int i = 0;i < MAX_SIZE;i += 1){  // 迭代哈希表
+                            var *dict_var_tmp = var_dict->hash[i];
+                            if(dict_var_tmp != NULL){
+                                dict_var_tmp = dict_var_tmp->next;
+                            }
+                            else{
+                                continue;
+                            }
+                            while (1)
+                            {
+                                if(dict_var_tmp == NULL){  // 不是空的，迭代var
+                                    break;
+                                }
+                                // 设置值
+                                GWARF_value parameter_key;
+                                parameter_key.type = STRING_value;
+                                parameter_key.value.string = dict_var_tmp->name;
+                                parameter *tmp = pack_value_parameter(parameter_key);  // 索引
+                                tmp->next = pack_value_parameter(dict_var_tmp->value);  // 赋值内容
+                                
+                                GWARF_result get;
+                                var_list *call_var = dict_tmp.value.object_value->the_var;
+
+                                var *__down__tmp = find_var(call_var, 0, "__set__");
+                                if(__down__tmp != NULL){
+                                    get.value = __down__tmp->value;
+                                    get.father = &(dict_tmp);  // 设置father
+                                    call_back_core(get, old_var_list, tmp);  // 赋值
+                                }
+                                dict_var_tmp = dict_var_tmp->next;  // 迭代到下一个
+                            }
+                            
                         }
-                        assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp);
+                        GWARF_result dict_result;
+                        dict_result.value = dict_tmp;
+                        assignment_statement(tmp_x->u.var, old_var_list, the_var, dict_result);
+                        tmp_x->next = NULL;  // 理论上没有下一个
                     }
                     else{
-                        printf("Warning!!!\n");
-                        break;
+                        GWARF_result tmp_x_var = traverse(tmp_x->u.var, tmp_var, false);  // 使用tmp_x->u.var在tmp_var中获取变量的值
+                        if((!is_error(&tmp_x_var)) && (!is_space(&tmp_x_var))){  // 如果找到了，就赋值
+                            assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp_x_var);
+                            if(tmp_x->u.var->type = base_var){
+                                del_var_var_list(tmp_var, 0, tmp_x->u.var->code.base_var.var_name);  // 从中删除变量
+                            }
+                        }
+                        else if(tmp_x->type == name_value){  // 没找到就检查是否为name_value类型，给默认值
+                            GWARF_result tmp = traverse(tmp_x->u.value, the_var, false);  // 执行形参
+                            if(is_error(&tmp) || is_space(&tmp)){
+                                return tmp;
+                            }
+                            assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp);
+                        }
+                        else{
+                            break;
+                        }
                     }
                     tmp_x = tmp_x->next;
                 }
@@ -1896,18 +1940,17 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                 if(is_error(&tmp_next)){  // TODO:: 检查是否为IterException
                     break;  // goto return_value;
                 }
-                if(is_space(&tmp_next)){  // TODO:: 检查是否为IterException
+                if(is_space(&tmp_next)){
                     return tmp_next;
                 }
 
                 GWARF_result get;
-                GWARF_value base_the_var = tmp.value;  // 只有一个参数
-                var_list *call_var = base_the_var.value.object_value->the_var;
+                var_list *call_var = tmp.value.value.object_value->the_var;
 
                 var *__down__tmp = find_var(call_var, 0, "__down__");
                 if(__down__tmp != NULL){
                     get.value = __down__tmp->value;
-                    get.father = &base_the_var;  // 设置father
+                    get.father = &(tmp.value);  // 设置father
                     tmp_next_down = call_back_core(get, the_var, pack_value_parameter(tmp_next.value));
                 }
 
@@ -1924,16 +1967,25 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
 
             assignment_type = 1;
         }
-        else if(assignment_type == 1 || tmp_s->type == name_value){
+        else if(assignment_type == 0 && tmp_x->type == put_kwargs){  // tmp_s还没到根据name_value的阶段, 遇到了**kwargs，则把后面的所有直接变成dict
+            // 放入list中
+            GWARF_result dict_tmp;
+            dict_tmp.value = to_object(parameter_to_dict(tmp_s, old_var_list), old_var_list);  // 把所有name_value变成dict
+            assignment_statement(tmp_x->u.var, old_var_list, the_var, dict_tmp);
+            assignment_type = 1;  // 进入根据实参赋值模式
+            tmp_x = NULL;  // 已经到最后一个了
+            tmp_s = NULL;
+        }
+        else if(assignment_type == 1 || tmp_s->type == name_value){  // 根据tmp_s赋值，同时也是进入assignment_type == 1模式的入口，进入前提是：tmp_x不是put_kwargs[否则直接全部赋值到put_kwargs上即可]
             if(tmp_s->type != name_value){
-                printf("Warning!!!");  // 进入了模式1, 但不是name_value
+                printf("Warning!!!");  // 进入了模式1, 但不是name_value 
                 break;
             }
             assignment_type = 1;
             assignment_statement(tmp_s->u.var, old_var_list, tmp_var, tmp);  // 先赋值到tmp_var上
             tmp_s = tmp_s->next;
         }
-        else if(tmp_s->type == put_args){  // assignment_type不在1模式
+        else if(tmp_s->type == put_args){  // assignment_type不在1模式 -> 把tmp_s列表解释为参数
             parameter *before = tmp_s, *after = tmp_s->next;
             GWARF_value iter_value = get__iter__(&(tmp.value), old_var_list).value;  // 获取迭代object，一般是返回self
             while (1){
@@ -1950,10 +2002,10 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
             before->next = after;
             tmp_s = tmp_s->next;  // 实参去下一位, 形参不变
         }
-        else if(assignment_type == 0 && tmp_x->type == put_args){  // 形参出现了*args，收归所有无默认值的实参
+        else if(assignment_type == 0 && tmp_x->type == put_args){  // 形参出现了*args，收归所有无默认值的实参[如果以及开始了根据tmp_s赋值模式，则*args无效]
             // 放入list中
             GWARF_result list_tmp;
-            list_tmp.value = to_object(parameter_to_list(tmp_s, old_var_list), old_var_list);
+            list_tmp.value = to_object(parameter_to_list(tmp_s, old_var_list), old_var_list);  // 把所有only_value变成list
             assignment_statement(tmp_x->u.var, old_var_list, the_var, list_tmp);
             assignment_type = 1;  // 进入根据实参赋值模式
             tmp_x = tmp_x->next;
@@ -1964,7 +2016,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                 if(tmp_s->type != only_value){
                     break;
                 }
-                tmp_s = tmp_s->next;
+                tmp_s = tmp_s->next;  // tmp_s迭代到only_value的最后一个
             }
         }
         else if(assignment_type == 0){

inter/interpreter.h

@@ -560,6 +560,7 @@ int len_double(double num);
 int len_int(int num);
 int len_intx(unsigned int num);
 GWARF_value to_object(GWARF_value, var_list *);
+GWARF_result get_object(parameter *, char *, var_list *);
 class_object *make_object(var_list *the_var, var_list *father_var_list);
 
 void login_official_func(int type, int is_class, var_list *the_var, char *name, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *));
@@ -645,12 +646,14 @@ var_list *free_var_list(var_list *);
 int get_var_list_len(var_list *);
 var *find_var(var_list *,int , char *);
 void add_var(var_list *,int , char *, GWARF_value);
+void del_var_var_list(var_list *,int, char *);
 var_list *copy_var_list(var_list *);
 
 hash_var *make_hash_var();
 unsigned int time33(char *);
 int login_node(char *, GWARF_value, hash_var *);
 var *find_node(char *, hash_var *);
+void del_var_node(char *, hash_var *);
 
 parameter *make_parameter_name(statement *);
 parameter *append_parameter_name(statement *, parameter *);

inter/var.c

@@ -70,7 +70,7 @@ var *get_var(char *name, var *base_var){  // get the address
 void del_var(char *name, var *base_var){  // free an address
     var *tmp = base_var, *last_tmp=NULL;  // iter var
     while(1){
-        if (tmp->name == name){
+        if (!strcmp(tmp->name, name)){
             if(last_tmp != NULL){
                 last_tmp->next = tmp->next;  // if tmp->next is NULL last_tmp->next is NULL too
             }
@@ -80,8 +80,8 @@ void del_var(char *name, var *base_var){  // free an address
         if (tmp->next == NULL){  // not var name *name
             return;
         }
-        tmp = tmp->next;  // get the next to iter
         last_tmp = tmp;
+        tmp = tmp->next;  // get the next to iter
     }
 }
 
@@ -132,8 +132,22 @@ var *find_node(char *name, hash_var *the_hash_var){
     return get_var(name, base_node);
 }
 
-// --------------default_var[存储在var_list节点上]
+void del_var_node(char *name, hash_var *the_hash_var){  // 删除某个var
+    if(the_hash_var == NULL){
+        return;
+    }
+
+    unsigned int index = time33(name);
+    var *base_node = the_hash_var->hash[index];  // 根据下标拿base节点
+
+    if(base_node == NULL){  // 没有节点
+        return;
+    }
+    del_var(name, base_node);
+}
 
+// --------------default_var[存储在var_list节点上]
+// TODO:: default_var也应该删除对应的var
 default_var *make_default_var(){  // make_default_var
     default_var *tmp;
     tmp = malloc(sizeof(default_var));  // get an address for default_var
@@ -199,7 +213,6 @@ var_list *make_var_base(hash_var *global_hash_var){  // make the base for global
     return tmp;
 }
 
-
 var_list *append_var_list(hash_var *global_hash_var, var_list *var_list_base){  // make var_list[FILO]
     var_list *tmp = make_var_list();
     tmp->hash_var_base = global_hash_var;
@@ -280,6 +293,19 @@ void add_var(var_list *var_base,int from, char *name, GWARF_value value){  // ad
     login_node(name, value, start->hash_var_base);
 }
 
+void del_var_var_list(var_list *var_base,int from, char *name){
+    var_list *start = var_base;
+    var *return_var;
+    from += get_default(name, var_base->default_list);
+    for(int i = 0;i < from;i+= 1){
+        if(start->next == NULL){
+            break;
+        }
+        start = start->next;
+    }
+    del_var_node(name, start->hash_var_base);
+}
+
 var_list *copy_var_list(var_list *var_list_base){  // 复制一条var链到另一个内存地址上[base不复制]
     var_list *start = malloc(sizeof(var_list_base)), *tmp;
     memcpy(start, var_list_base, sizeof(var_list_base));  // 复制base节点

mem/mem.c

@@ -18,6 +18,7 @@ void *safe_malloc(size_t size){
 
 void *safe_free(void *p){  // 安全的释放
     if(p == NULL){
+        puts("free Wrong!");
         return p;  // p已经释放了
     }
     free(p);

paser/gwarf_yacc.y

@@ -326,6 +326,7 @@ formal_parameter
     {
         parameter *tmp = append_parameter_name($4, $1);
         tmp->type = put_kwargs;
+        puts("WSSDD");
         $$ = $1;
     }
     | formal_parameter COMMA top_exp EQ top_exp
@@ -354,7 +355,6 @@ arguments
         $$ = make_parameter_name($1);
         $$->u.value = $3;
         $$->type = name_value;
-        puts("SSSS");
     }
     | arguments COMMA base_var_ EQ top_exp
     {

paser/y.tab.c

@@ -703,7 +703,7 @@ static const yytype_int16 yyrline[] =
      133,   137,   141,   145,   149,   153,   157,   161,   165,   173,
      180,   181,   190,   199,   208,   217,   226,   235,   244,   253,
      262,   271,   280,   292,   297,   302,   307,   313,   319,   325,
-     331,   341,   346,   352,   359,   366,   371,   377,   382,   391,
+     332,   342,   347,   353,   359,   366,   371,   377,   382,   391,
      395,   400,   408,   416,   417,   425,   436,   437,   447,   460,
      461,   475,   476,   488,   489,   501,   502,   515,   516,   525,
      534,   543,   552,   561,   573,   574,   587,   588,   600,   601,
@@ -2373,48 +2373,48 @@ yyreduce:
     {
         parameter *tmp = append_parameter_name((yyvsp[0].statement_value), (yyvsp[-3].parameter_list));
         tmp->type = put_kwargs;
+        puts("WSSDD");
         (yyval.parameter_list) = (yyvsp[-3].parameter_list);
     }
-#line 2379 "y.tab.c"
+#line 2380 "y.tab.c"
     break;
 
   case 50:
-#line 332 "gwarf_yacc.y"
+#line 333 "gwarf_yacc.y"
     {
         parameter *tmp = append_parameter_name((yyvsp[-2].statement_value), (yyvsp[-4].parameter_list));
         tmp->u.value = (yyvsp[0].statement_value);
         tmp->type = name_value;
         (yyval.parameter_list) = (yyvsp[-4].parameter_list);
     }
-#line 2390 "y.tab.c"
+#line 2391 "y.tab.c"
     break;
 
   case 51:
-#line 342 "gwarf_yacc.y"
+#line 343 "gwarf_yacc.y"
     {
         (yyval.parameter_list) = make_parameter_value((yyvsp[0].statement_value));
         (yyval.parameter_list)->type = only_value;
     }
-#line 2399 "y.tab.c"
+#line 2400 "y.tab.c"
     break;
 
   case 52:
-#line 347 "gwarf_yacc.y"
+#line 348 "gwarf_yacc.y"
     {
         parameter *tmp = append_parameter_value((yyvsp[0].statement_value), (yyvsp[-2].parameter_list));
         tmp->type = only_value;
         (yyval.parameter_list) = (yyvsp[-2].parameter_list);
     }
-#line 2409 "y.tab.c"
+#line 2410 "y.tab.c"
     break;
 
   case 53:
-#line 353 "gwarf_yacc.y"
+#line 354 "gwarf_yacc.y"
     {
         (yyval.parameter_list) = make_parameter_name((yyvsp[-2].statement_value));
         (yyval.parameter_list)->u.value = (yyvsp[0].statement_value);
         (yyval.parameter_list)->type = name_value;
-        puts("SSSS");
     }
 #line 2420 "y.tab.c"
     break;