实现in表达式

README.md

@@ -79,6 +79,8 @@ return x n  函数返回值x，返回n层
 * try...except增加了else和finally语句，并且允许``except``，``except as``，``else``，``finally``为可选语句
 * 实现了slice赋None值(本质是依靠了虚解包)
 * 修改了无法return的bug
+* in 语句
+* 疑似bug：``a.__iter__.__next__``会出现内存错误，``a.__iter__().__next__()``会出现解析错误
 ## GWARF计划
 * 类型转换(list, str, int之间的转换)
 * 魔法方法：``__eq__(用于特殊赋值)，__int__，__str__，__double__，__repo__，__list__，__tuple__，__dict__，__key__，__in__``
@@ -86,7 +88,6 @@ return x n  函数返回值x，返回n层
 * 数据类型：``set()，link()``
 * 内置类：``range,exp(列表推导试)``
 * 内置函数：``print, input, exit``
-* xx in yy语法
 * @装饰器语法
 * 内存控制：控制``var``链表，控制``哈希表``，控制``var_list``
 * 多重继承优化：super().__init__()

inter/cfunc.c

@@ -1747,8 +1747,8 @@ class_object *tuple_login_official(var_list *the_var, GWARF_result (*paser)(func
     puts("----stop set class----");
 
     // 注册函数
-    int a[][2] = {{__init__func,1},{__len__func,1},{__down__func,1},{__slice__func,1},{__iter__func,1},{__next__func,1}};
-    char *name[] = {"__init__", "__len__", "__down__", "__slice__", "__iter__", "__next__"};  //  __len__是获取长度，__down__是获取下值，__slice__是切片
+    int a[][2] = {{__init__func,1},{__len__func,1},{__down__func,1},{__slice__func,1},{__iter__func,1},{__next__func,1},{__in__func, 1}};
+    char *name[] = {"__init__", "__len__", "__down__", "__slice__", "__iter__", "__next__","__in__"};  //  __len__是获取长度，__down__是获取下值，__slice__是切片
 
     int lenth = sizeof(a)/sizeof(a[0]);
     for(int i = 0;i < lenth;i+=1){
@@ -1874,6 +1874,36 @@ GWARF_result tuple_official_func(func *the_func, parameter *tmp_s, var_list *the
             }
             break;
         }
+        case __in__func:{  // return index
+            var *tmp = find_var(login_var, 0, "value", NULL);
+            int len = tmp->value.value.list_value->index;
+            if(tmp != NULL){
+                GWARF_result get_value, tmp_result = traverse(tmp_s->u.value, out_var, false, global_inter);
+                error_space(tmp_result, return_result, return_value);
+                get_value = get__value__(&(tmp_result.value), the_var, global_inter);
+                error_space(get_value, return_result, return_value);
+
+                GWARF_result self = GWARF_result_reset, tmp_eq = GWARF_result_reset;
+                for(int i = 0;i < len;i++){
+                    self.value = tmp->value.value.list_value->list_value[i];
+                    tmp_eq = equal_func(get_value, self, out_var, 0, global_inter);
+                    error_space(tmp_eq, return_result, return_value);
+                    if(tmp_eq.value.value.bool_value){  // 相等
+                        return_value.value.type = BOOL_value;
+                        return_value.value.value.bool_value = true;
+                        goto return_result;  // return true
+                    }
+                }
+
+                return_value.value.type = BOOL_value;
+                return_value.value.value.bool_value = false;
+            }
+            else{
+                return_value = to_error("Don't get List Value", "ValueException", global_inter);
+                goto return_result;
+            }
+            break;
+        }
         case __slice__func:{  // return index
             var *tmp = find_var(login_var, 0, "value", NULL);
             int len = tmp->value.value.list_value->index;
@@ -2254,8 +2284,8 @@ class_object *dict_login_official(var_list *the_var, GWARF_result (*paser)(func
     puts("----stop set class----");
 
     // 注册函数
-    int a[][2] = {{__init__func,1},{__down__func,1},{__set__func,1},{__next__func,1}};
-    char *name[] = {"__init__", "__down__", "__set__", "__next__"};  //  继承tuple
+    int a[][2] = {{__init__func,1},{__down__func,1},{__set__func,1},{__next__func,1},{__in__func,1}};
+    char *name[] = {"__init__", "__down__", "__set__", "__next__", "__in__"};  //  继承tuple
 
     int lenth = sizeof(a)/sizeof(a[0]);
     for(int i = 0;i < lenth;i+=1){
@@ -2353,6 +2383,28 @@ GWARF_result dict_official_func(func *the_func, parameter *tmp_s, var_list *the_
 
              break;
         }
+        case __in__func:{  // return index
+            var *tmp = find_var(login_var, 0, "value", NULL);
+            if(tmp != NULL){
+                GWARF_result get_value, tmp_result = traverse(tmp_s->u.value, out_var, false, global_inter);
+                error_space(tmp_result, return_result, return_value);
+                get_value = to_str_dict(tmp_result.value, out_var, global_inter);
+                error_space(get_value, return_result, return_value);
+                var *find_var = find_node(get_value.value.value.string, tmp->value.value.dict_value->dict_value);
+                return_value.value.type = BOOL_value;
+                if(find_var != NULL){  // not found
+                    return_value.value.value.bool_value = true;
+                }
+                else{
+                    return_value.value.value.bool_value = false;
+                }
+            }
+            else{
+                return_value = to_error("Don't get List Value", "ValueException", global_inter);
+                goto return_result;
+            }
+            break;
+        }
         case __down__func:{  // return index
             var *tmp = find_var(login_var, 0, "value", NULL);
             if(tmp != NULL){

inter/interpreter.c

@@ -1817,6 +1817,11 @@ GWARF_result operation_func(statement *the_statement, var_list *the_var, var_lis
             get_right_result;
             value = is_func(left_result, right_result, the_var, global_inter);
             break;
+        case IN_func:
+            get_left_result;
+            get_right_result;
+            value = in_func(left_result, right_result, the_var, global_inter);
+            break;
         case EQUAL_func:
             get_left_result;
             get_right_result;
@@ -3998,6 +4003,26 @@ GWARF_result sqrt_func(GWARF_result left_result, GWARF_result right_result, var_
     return_back: return return_value;
 }
 
+// ---------  IN
+GWARF_result in_func(GWARF_result left_result, GWARF_result right_result, var_list *the_var, inter *global_inter){  // the func for div and call from read_statement_list
+    GWARF_result return_value;  // the result by call read_statement_list with left and right = GWARF_result_reset; value is the result for div
+    if(right_result.value.type == OBJECT_value){  // 调用右sqrt方法
+        GWARF_result get = GWARF_result_reset;
+        GWARF_value base_the_var = right_result.value;  // 只有一个参数
+        var_list *call_var = base_the_var.value.object_value->the_var;
+
+        var *tmp = find_var(call_var, 0, "__in__", NULL);
+        if(tmp != NULL){
+            get.value = tmp->value;
+            get.father = &base_the_var;  // 设置father
+            return_value = call_back_core(get, the_var, pack_value_parameter(left_result.value), global_inter);
+        }
+        NotSupportCul();
+    }
+    NotSupportCul();
+    return_back: return return_value;
+}
+
 // ---------  ASSIGnMENT
 GWARF_result assignment_func(char *left, GWARF_result right_result, var_list *the_var, int from, int lock){  // lock代表变量的权限
     add_var(the_var, from, left, right_result.value, lock);

inter/interpreter.h

@@ -206,6 +206,7 @@ typedef struct statement{
                 BOOLSAND_func,  // and
                 BOOLSOR_func,  // or
                 IS_func,  // a is b
+                IN_func,
             } type;
             struct statement *right_exp;  // the right exp
             struct statement *left_exp;  // the left exp
@@ -618,6 +619,7 @@ GWARF_result bit_left_func(GWARF_result, GWARF_result, var_list *, inter *);
 GWARF_result bit_notor_func(GWARF_result, GWARF_result, var_list *, inter *);
 GWARF_result bit_or_func(GWARF_result, GWARF_result, var_list *, inter *);
 GWARF_result bit_and_func(GWARF_result, GWARF_result, var_list *, inter *);
+GWARF_result in_func(GWARF_result, GWARF_result, var_list *, inter *);
 
 double sqrt_(double, double);
 double log_(double, double);

paser/syntax.c

@@ -759,6 +759,8 @@ void formal_parameter(p_status *status, token_node *list){  // 因试分解
             }
             p_status new_status;
             new_status = *status;
+            reset_status(new_status);
+            new_status.is_left = false;
             new_status.not_match_tuple = true;
             if(!status->match_dict) new_status.not_match_eq = true;
             get_right_token(&new_status, list, top_exp, value_token);
@@ -772,7 +774,7 @@ void formal_parameter(p_status *status, token_node *list){  // 因试分解
         }
         else{
             if(status->match_dict){
-                paser_error("dict should get ':'[2]");
+                paser_error("dict should get ':'[3]");
             }
             back_again(list,eq);  // 回退[如果使用back_one_token则会导致add_node在EQ的后面]
             new_token.data.parameter_list = make_parameter_value(next.data.statement_value);
@@ -1848,7 +1850,7 @@ void compare(p_status *status, token_node *list){  // 多项式
            symbol.type == MORE_PASER || symbol.type == LESS_PASER || symbol.type == NOTEQ_PASER ||
            symbol.type == ISLEFT_PASER || symbol.type == ISRIGHT_PASER || symbol.type == BOOLIS_PASER ||
            symbol.type == ILEFT_PASER || symbol.type == IRIGHT_PASER || symbol.type == BOOLNOTOR_PASER ||
-           symbol.type == IS_PASER){
+           symbol.type == IS_PASER || (symbol.type == IN_PASER && !status->is_for)){
             get_right_token(status, list, bit_notor, right);  // 回调右边
             if(right.type != NON_bit_notor){
                 paser_error("Don't get a bit_notor");
@@ -1898,6 +1900,9 @@ void compare(p_status *status, token_node *list){  // 多项式
             case IS_PASER:
                 code_tmp->code.operation.type = IS_func;
                 break;
+            case IN_PASER:
+                code_tmp->code.operation.type = IN_func;
+                break;
             }
             code_tmp->code.operation.left_exp = left.data.statement_value;
             code_tmp->code.operation.right_exp = right.data.statement_value;