新增内置函数 type

README.md

@@ -85,13 +85,14 @@ return x n  函数返回值x，返回n层
 * ``a.__iter__().__next__()``会出现解析错误, 已经修复，调整了``.``运算符和``call_back``为同级优先级
 * 解决了object的``__value__``无法调用的问题：原因是注册函数的时候使用了数字而不是枚举体[现在，使用``{__value__func, 1}``取代了数字``{3, 1}``]
 * 可以生成语法树，输出文件到./log下
+* ``isinherited``检查继承关系，``isinstance``检查是否为类的实例(忽略继承)，``isbelong``检查是否为类的实例, ``type``检查数据类型。
 ## GWARF计划
 * 类型转换(list, str, int之间的转换)
 * 魔法方法：``__eq__(用于特殊赋值)，__int__，__str__，__double__，__repo__，__list__，__tuple__，__dict__，__key__，__in__``
 * 魔法属性：``__name__，__id__``
 * 数据类型：``set()，link()，file()``
 * 内置类：``range,exp(列表推导试)``
-* 内置函数：``exit()[报出错误ExitException(Systemctl)], type(), isinherited()[A类是否继承B类], isinstance()[A object是否为B的实例(不检查继承关系)]``
+* 内置函数：``exit()[报出错误ExitException(Systemctl)], type()]``
 * @装饰器语法
 * 内存控制：控制``var``链表，控制``哈希表``，控制``var_list``
 * 多重继承优化：``super().__init__()``

demo/9.gwf

@@ -5,4 +5,12 @@ b = 10
 class c(a){
 d = 20
 }
+q = c()
 print(isinherited(c,a))
+print(isinstance(q,c))
+print(isinstance(q,a))
+print(isbelong(q,a))
+print(type(c))
+print(type(q))
+print(type(a) == type(c))
+print(type(q) == type(c))

inter/cfunc.c

@@ -182,8 +182,8 @@ void login_official_func(int type, int is_class, var_list *the_var, char *name,
 }
 
 void login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *,inter *), inter *global_inter){
-    int a[][2] = {{printf_func,0}, {input_func,0}, {isinherited_func,0}};
-    char *name[] = {"print", "input", "isinherited"};
+    int a[][2] = {{printf_func,0}, {input_func,0}, {isinherited_func,0}, {isinstance_func,0}, {isbelong_func,0}, {type_func, 0}};
+    char *name[] = {"print", "input", "isinherited", "isinstance", "isbelong", "type"};
 
     int lenth = sizeof(a)/sizeof(a[0]);
     for(int i = 0;i < lenth;i+=1){
@@ -285,6 +285,128 @@ GWARF_result official_func(func *the_func, parameter *tmp_s, var_list *the_var,
         return_value = to_object(return_value, global_inter);
         break;
     }
+    case isbelong_func:{
+        if(tmp_s == NULL || tmp_s->next == NULL){
+            return to_error("Too Little Args", "ArgsException", global_inter);
+        }
+        else if(tmp_s->next->next != NULL){
+            return to_error("Too Many Args", "ArgsException", global_inter);
+        }
+
+        GWARF_result child = traverse(tmp_s->u.value, out_var, false, global_inter), father = GWARF_result_reset;
+        error_space(child, return_result, return_value);
+
+        tmp_s = tmp_s->next;
+        father = traverse(tmp_s->u.value, out_var, false, global_inter);
+        error_space(father, return_result, return_value);
+
+        if(child.value.type != OBJECT_value || father.value.type != CLASS_value){
+            return to_error("First Args Should Be Object, Second Args Should Be Class", "TypeException", global_inter);
+        }
+
+        hash_var *src = father.value.value.class_value->the_var->hash_var_base;
+        var_list *dust = child.value.value.object_value->cls;
+        bool is = false;
+
+        while(true){  // 读取child的没一个the_var的哈希表，与father的对比
+            if(dust == NULL){
+                break;
+            }
+            if(dust->hash_var_base == src){
+                is = true;
+                break;
+            }
+            dust = dust->next;
+        }
+
+        return_value.value.type = BOOL_value;
+        return_value.value.value.bool_value = is;
+        return_value = to_object(return_value, global_inter);
+        break;
+    }
+    case type_func:{
+        if(tmp_s == NULL){
+            return to_error("Too Little Args", "ArgsException", global_inter);
+        }
+        else if(tmp_s->next != NULL){
+            return to_error("Too Many Args", "ArgsException", global_inter);
+        }
+
+        GWARF_result obj = traverse(tmp_s->u.value, out_var, false, global_inter);
+        error_space(obj, return_result, return_value);
+
+        char *str;
+        switch (obj.value.type)
+        {
+        case NULL_value:
+            str = "NULL";
+            break;
+        case NUMBER_value:
+            str = "DOUBLE";
+            break;
+        case INT_value:
+            str = "INT";
+            break;
+        case STRING_value:
+            str = "STR";
+            break;
+        case OBJECT_value:
+            str = "OBJECT";
+            break;
+        case CLASS_value:
+            str = "CLASS";
+            break;
+        case FUNC_value:
+            str = "FUNC";
+            break;
+        case LIST_value:
+            str = "LIST";
+            break;
+        case DICT_value:
+            str = "DICT";
+            break;
+        default:
+            str = "UNKNOW";
+            break;
+        }
+        
+        return_value.value.type = STRING_value;
+        return_value.value.value.string = str;
+        return_value = to_object(return_value, global_inter);
+        break;
+    }
+    case isinstance_func:{
+        if(tmp_s == NULL || tmp_s->next == NULL){
+            return to_error("Too Little Args", "ArgsException", global_inter);
+        }
+        else if(tmp_s->next->next != NULL){
+            return to_error("Too Many Args", "ArgsException", global_inter);
+        }
+
+        GWARF_result child = traverse(tmp_s->u.value, out_var, false, global_inter), father = GWARF_result_reset;
+        error_space(child, return_result, return_value);
+
+        tmp_s = tmp_s->next;
+        father = traverse(tmp_s->u.value, out_var, false, global_inter);
+        error_space(father, return_result, return_value);
+
+        if(child.value.type != OBJECT_value || father.value.type != CLASS_value){
+            return to_error("First Args Should Be Object, Second Args Should Be Class", "TypeException", global_inter);
+        }
+
+        hash_var *src = father.value.value.class_value->the_var->hash_var_base;
+        var_list *dust = child.value.value.class_value->the_var;
+        bool is = false;
+
+        if(father.value.value.class_value->the_var->hash_var_base == child.value.value.object_value->cls->hash_var_base){
+            is = true;
+        }
+
+        return_value.value.type = BOOL_value;
+        return_value.value.value.bool_value = is;
+        return_value = to_object(return_value, global_inter);
+        break;
+    }
     default:
         break;
     }

inter/interpreter.c

@@ -4160,6 +4160,11 @@ GWARF_result equal_func(GWARF_result left_result, GWARF_result right_result, var
                 return_bool = true;  // 返回1 否则(默认)为0
             }
         }
+        else if(left_result.value.type == STRING_value && right_result.value.type == STRING_value){
+            if ((type == 0) && !strcmp(left_result.value.value.string, right_result.value.value.string)){  // 如果相等
+                return_bool = true;  // 返回1 否则(默认)为0
+            }
+        }
         NotSupportCul();
         return_value.value.value.bool_value = return_bool;
         return_value.value.type = BOOL_value;

inter/interpreter.h

@@ -494,9 +494,15 @@ typedef enum{
 } func_type;
 
 typedef enum{
+    // 全局方法
     printf_func,
     input_func,
     isinherited_func,
+    isinstance_func,
+    isbelong_func,
+    type_func,
+
+    // 类方法
     __init__func,
     __value__func,
     __add__func,