修复了一些bug

gwarf_interpreter/branch.c

@@ -0,0 +1,34 @@
+#include<stdio.h>
+// #include "interpreter.h"
+
+if_list *make_base_if();
+if_list *make_if(statement *, statement *);
+if_list *append_elif(if_list *, if_list *);
+
+if_list *make_base_if(){  // make base if
+    if_list *tmp;
+    tmp = malloc(sizeof(if_list));  // get an address for base var
+    tmp->next = NULL;
+    tmp->done = NULL;
+    tmp->condition = NULL;
+    return tmp;
+}
+
+if_list *make_if(statement *condition, statement *done_base){  // if
+    if_list *tmp = make_base_if();
+    tmp->done = done_base;
+    tmp->condition = condition;
+    return tmp;
+}
+
+if_list *append_elif(if_list *tmp ,if_list *base_if_list){  // elif
+    if_list *start = base_if_list;
+    while(1){
+        if(start->next  == NULL){
+            break;
+        }
+        start = start->next;
+    }
+    start->next = tmp;
+    return tmp;
+}

gwarf_interpreter/cfunc.c

@@ -0,0 +1,809 @@
+#include<stdio.h>
+// #include "interpreter.h"
+
+int len_only_double(double num);
+int len_double(double num);
+int len_int(int num);
+int len_intx(unsigned int num);
+GWARF_value to_object(GWARF_value, 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 *));
+void login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *));
+
+// 内置函数
+GWARF_result official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *);
+
+// object内置类
+class_object *object_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *));
+GWARF_result object_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+
+// gobject内置类
+class_object *gobject_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
+GWARF_result gobject_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+
+// int内置类
+class_object *int_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
+GWARF_result int_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *);
+
+// double内置类
+class_object *double_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
+GWARF_result double_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *);
+
+// str内置类
+class_object *str_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
+GWARF_result str_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+
+// bool内置类
+class_object *bool_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
+GWARF_result bool_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+
+int len_int(int num){
+    int count = 1;  // 默认得有1位
+    while(1){
+        num = num / 10;
+        if(num <= 0){
+            break;
+        }
+        count += 1;
+    }
+    return count;
+}
+
+int len_only_double(double num){
+    int count = 1;  // 默认得有1位
+    while(1){
+        num = num * 10;
+        if(num - (int)num <= 0){
+            break;
+        }
+        count += 1;
+    }
+    return count;
+}
+
+int len_double(double num){
+    int count = 1, i = (int)num;
+    count += len_int(i);
+    count += len_only_double(num);
+    return count;
+}
+
+int len_intx(unsigned int num){  // 16进制
+    int count = 1;  // 默认得有1位
+    while(1){
+        num = num / 16;
+        if(num <= 0){
+            break;
+        }
+        count += 1;
+    }
+    return count;
+}
+
+GWARF_value to_object(GWARF_value value, var_list *the_var){  // 把GWARF_value封装成objct
+    GWARF_result return_value;
+    if((value.type == CLASS_value) || (value.type == OBJECT_value) || (value.type == FUNC_value) || (value.type == NULL_value)){  // 可以直接返回
+        return value;
+    }
+    GWARF_result func_result;
+    if(value.type == NUMBER_value){
+        func_result.value = find_var(the_var, 0, "double")->value;
+    }
+    else if(value.type == INT_value){
+        func_result.value = find_var(the_var, 0, "int")->value;
+    }
+    else if(value.type == BOOL_value){
+        func_result.value = find_var(the_var, 0, "bool")->value;
+    }
+    else if(value.type == STRING_value){
+        func_result.value = find_var(the_var, 0, "str")->value;
+    }
+    else{
+        return value;
+    }
+    return call_back_core(func_result, the_var, pack_value_parameter(value)).value;
+}
+
+
+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 *)){  // 注册单个official func
+    GWARF_result func_value;
+    func *func_tmp = malloc(sizeof(func));
+
+    func_tmp->done = NULL;
+    func_tmp->parameter_list = NULL;
+    func_tmp->the_var = copy_var_list(the_var);
+    func_tmp->type = official;
+    func_tmp->official_func = type;
+    func_tmp->is_class = is_class;
+    func_tmp->paser = paser;
+
+    func_value.value.type = FUNC_value;
+    func_value.value.value.func_value = func_tmp;
+    assigment_func(name, func_value, the_var, 0);  // 注册函数到指定的位置
+}
+
+void login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *)){
+    // {{official_func_type, is_class}}
+    int a[][2] = {{1,0}};
+    // {login_name}
+    char *name[] = {"print"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], the_var, name[i], paser);
+    }
+}
+
+
+// global 全局内置函数解析器
+GWARF_result official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){
+    GWARF_result return_value;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    switch (the_func->official_func)
+    {
+    case printf_func:{  // printf something
+        if(tmp_s == NULL){  // 没有东西要打印
+            goto return_result;
+        }
+        while(1){
+            GWARF_result tmp = traverse(tmp_s->u.value, out_var, false);
+            if((tmp.value.type == INT_value)){
+                printf("%d", tmp.value.value.int_value);
+            }
+            else if(tmp.value.type == BOOL_value){
+                if(tmp.value.value.bool_value){
+                    printf("true");
+                }
+                else{
+                    printf("false");
+                } 
+            }
+            else if(tmp.value.type == NUMBER_value){
+                printf("%f", tmp.value.value.double_value);
+            }
+            else if(tmp.value.type == NULL_value){
+                printf("<-None->");
+            }
+            else if(tmp.value.type == STRING_value){
+                printf("'%s'", tmp.value.value.string);
+            }
+            else if(tmp.value.type == FUNC_value){
+                printf("<-function on %u->", tmp.value.value.func_value);
+            }
+            else if(tmp.value.type == CLASS_value){
+                printf("<-class on %u->", tmp.value.value.class_value);
+            }
+            else if(tmp.value.type == OBJECT_value){
+                printf("<-object on %u->", tmp.value.value.object_value);
+            }
+            else{
+                printf("var value = other\n");
+            }
+            if (tmp_s->next == NULL){  // the last
+                break;
+            }
+            tmp_s = tmp_s->next;
+        }
+        printf("\n");  // 换行
+        return_value.u = statement_end;
+        break;
+    }
+    default:
+        break;
+    }
+    return_result: return return_value;
+}
+
+class_object *object_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *)){  // 内置对象继承的类
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("object", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+
+    // 注册函数
+    int a[][2] = {{3,1}};
+    char *name[] = {"__value__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result object_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    switch (the_func->official_func)
+    {
+        case __value__func:{  // 若想实现运算必须要有这个方法
+            return_value.value.type = STRING_value;  // 取得用于计算的数值
+            return_value.value = to_str(*(father.father), out_var);
+            break;
+        }
+    }
+    return_result: return return_value;
+}
+
+class_object *gobject_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){  // 内置对象继承的类
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    if(father_var_list != NULL){
+        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
+    }
+
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("gobject", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+    // 注册函数
+    int a[][2] = {{2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}, {13,1}, {14,1}, {15,1}, {16,1}, {17,1}, {3,1}};
+    char *name[] = {"__init__", "__value__", "__add__", "__sub__", "__mul__","__div__","__eq__", "__more__", "__less__", "__eqmore__", "__eqless__","__noteq__", "__pow__", "__log__","__sqrt__","__negative__","__bool__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result gobject_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    else{
+        printf("NO login, father type = %d\n", father.father->type);
+    }
+    switch (the_func->official_func)
+    {
+        case __init__func:{  // printf something
+            GWARF_result tmp;
+            tmp.value.type = INT_value;
+            tmp.value.value.int_value = 0;
+            assigment_func("value", tmp, login_var, 0);  // 注册到self
+            return_value.u = statement_end;  // __init__没有return
+            break;
+        }
+        case __value__func:{  // 若想实现运算必须要有这个方法
+            var *tmp = find_var(login_var, 0, "value");  // gobject类的value存储在self.value中
+            return_value.value = tmp->value;  // 取得用于计算的数值
+            break;
+        }
+        case __add__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = add_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __sub__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = sub_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __mul__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = mul_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __div__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = div_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __eq__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 0);
+            break;
+        }
+        case __more__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 1);
+            break;
+        }
+        case __less__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 2);
+            break;
+        }
+        case __eqmore__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 3);
+            break;
+        }
+        case __eqless__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 4);
+            break;
+        }
+        case __noteq__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = equal_func(left_tmp, reight_tmp, out_var, 5);
+            break;
+        }
+        case __pow__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = pow_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __log__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = log_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __sqrt__func:{
+            GWARF_result reight_tmp, left_tmp;
+            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
+            reight_tmp = get__value__(&base_the_var, the_var);
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = sqrt_func(left_tmp, reight_tmp, out_var);
+            break;
+        }
+        case __negative__func:{
+            GWARF_result left_tmp;
+            left_tmp.value = find_var(login_var, 0, "value")->value;
+            return_value = negative_func(left_tmp, out_var);
+            break;
+        }
+        default:
+            break;
+    }
+    return_result: return return_value;
+}
+
+class_object *int_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    if(father_var_list != NULL){
+        append_by_var_list(class_tmp->the_var, father_var_list);  // int、double、str等内置类需要继承gobject类
+    }
+
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("int", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+    // 注册函数
+    int a[][2] = {{2,1}};
+    char *name[] = {"__init__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result int_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    else{
+        printf("NO login, father type = %d\n", father.father->type);
+    }
+    switch (the_func->official_func)
+    {
+        case __init__func:{  // printf something
+            GWARF_result tmp;
+            tmp.value = to_int(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
+            assigment_func("value", tmp, login_var, 0);  // 注册到self
+            return_value.u = statement_end;  // __init__没有return
+            break;
+        }
+        default:
+            break;
+    }
+    return_result: return return_value;
+}
+
+// to int[底层实现]
+GWARF_value to_int(GWARF_value value, var_list *the_var){
+    if((value.type == INT_value)){
+        return value;  // 直接返回数据
+    }
+
+    GWARF_value return_number;
+    return_number.type = INT_value;
+
+    if(value.type == OBJECT_value){  // 调用__value__方法
+        return_number = to_int(get__value__(&value, the_var).value, the_var);  // 递归
+    }
+    else{
+        if(value.type == BOOL_value){
+            return_number.value.int_value = value.value.bool_value;
+        }
+        else if(value.type == NUMBER_value){
+            return_number.value.int_value = (int)value.value.double_value;
+        }
+        else if(value.type == STRING_value){
+            return_number.value.int_value = atoi(value.value.string);
+        }
+        else{
+            return_number.value.int_value = 0;
+        }
+    }
+    return return_number;
+}
+
+
+class_object *double_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    if(father_var_list != NULL){
+        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
+    }
+
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("double", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+    // 注册函数
+    int a[][2] = {{2,1}};
+    char *name[] = {"__init__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result double_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    else{
+        printf("NO login, father type = %d\n", father.father->type);
+    }
+    switch (the_func->official_func)
+    {
+        case __init__func:{  // printf something
+            GWARF_result tmp;
+            tmp.value = to_double(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
+            assigment_func("value", tmp, login_var, 0);  // 注册到self
+            return_value.u = statement_end;  // __init__没有return
+            break;
+        }
+        default:
+            break;
+    }
+    return_result: return return_value;
+}
+
+// to double[底层实现]
+GWARF_value to_double(GWARF_value value, var_list *the_var){
+    if((value.type == NUMBER_value)){
+        return value;  // 直接返回数据
+    }
+
+    GWARF_value return_number;
+    return_number.type = NUMBER_value;
+
+    if(value.type == OBJECT_value){  // 调用__value__方法
+        return_number = to_double(get__value__(&value, the_var).value, the_var);  // 递归
+    }
+    else{
+        if(value.type == BOOL_value){
+            return_number.value.double_value = (double)value.value.bool_value;
+        }
+        else if(value.type == INT_value){
+            return_number.value.double_value = (double)value.value.int_value;
+        }
+        else if(value.type == STRING_value){
+            return_number.value.double_value = (double)atof(value.value.string);
+        }
+        else{
+            return_number.value.double_value = 0;
+        }
+    }
+    return return_number;
+}
+
+class_object *str_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    if(father_var_list != NULL){
+        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
+    }
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("str", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+    // 注册函数
+    int a[][2] = {{2,1}};
+    char *name[] = {"__init__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result str_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    else{
+        printf("NO login, father type = %d\n", father.father->type);
+    }
+    switch (the_func->official_func)
+    {
+        case __init__func:{  // printf something
+            GWARF_result tmp;
+            tmp.value = to_str(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
+            assigment_func("value", tmp, login_var, 0);  // 注册到self
+            return_value.u = statement_end;  // __init__没有return
+            break;
+        }
+        default:
+            break;
+    }
+    return_result: return return_value;
+}
+
+// to str[底层实现]
+GWARF_value to_str(GWARF_value value, var_list *the_var){
+    if((value.type == STRING_value)){
+        return value;  // 直接返回数据
+    }
+
+    GWARF_value return_number;
+    return_number.type = STRING_value;
+
+    if(value.type == OBJECT_value){  // 调用__value__方法
+        return_number = to_str(get__value__(&value, the_var).value, the_var);  // 递归
+    }
+    else{
+        if(value.type == BOOL_value){
+            if(value.value.bool_value){
+                return_number.value.string = "true";
+            }
+            else{
+                return_number.value.string = "false";
+            }
+        }
+        else if(value.type == INT_value){
+            size_t size = (size_t)(2 + len_int(value.value.int_value));
+            return_number.value.string = (char *)malloc(size);
+            snprintf(return_number.value.string, size, "%d", value.value.int_value);
+        }
+        else if(value.type == NUMBER_value){
+            size_t size = (size_t)(2 + len_double(value.value.double_value));
+            return_number.value.string = (char *)malloc(size);
+            snprintf(return_number.value.string, size, "%f", value.value.double_value);
+        }
+        else if(value.type == NULL_value){
+            return_number.value.string = "<-None->";
+        }
+        else if(value.type == FUNC_value){
+            size_t size = (size_t)(20 + len_intx((unsigned int)value.value.func_value));  // 转换为无符号整形数字
+            return_number.value.string = (char *)malloc(size);
+            snprintf(return_number.value.string, size, "<-function on %u->", value.value.func_value);
+        }
+        else if(value.type == CLASS_value){
+            size_t size = (size_t)(16 + len_intx((unsigned int)value.value.class_value));
+            return_number.value.string = (char *)malloc(size);
+            snprintf(return_number.value.string, size, "<-class on %u->", value.value.class_value);
+        }
+        else{
+            printf("var value = other\n");
+        }
+    }
+    return return_number;
+}
+
+class_object *bool_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
+    // 创建对象[空对象]
+    puts("----set class----");
+    GWARF_result class_value;
+    class_object *class_tmp = malloc(sizeof(class_object));
+
+    class_tmp->the_var = make_var_base(make_var());  // make class var list
+    if(father_var_list != NULL){
+        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
+    }
+    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
+    class_value.value.type = CLASS_value;
+    class_value.value.value.class_value = class_tmp;
+
+    assigment_func("bool", class_value, the_var, 0);  // 注册class 的 位置
+    puts("----stop set class----");
+
+    // 注册函数
+    int a[][2] = {{2,1}};
+    char *name[] = {"__init__"};
+
+    int lenth = sizeof(a)/sizeof(a[0]);
+    for(int i = 0;i < lenth;i+=1){
+        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
+    }
+    return class_tmp;
+}
+
+GWARF_result bool_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境, the_var是self内部环境
+    GWARF_result return_value;
+    var_list *login_var;
+    return_value.u = return_def;
+    return_value.return_times = 0;
+    if(father.father->type == CLASS_value){  // is class so that can use "."
+        login_var = father.father->value.class_value->the_var;
+    }
+    else if(father.father->type == OBJECT_value){
+        login_var = father.father->value.object_value->the_var;
+    }
+    else{
+        printf("NO login, father type = %d\n", father.father->type);
+    }
+    switch (the_func->official_func)
+    {
+        case __init__func:{  // printf something
+            GWARF_result tmp;
+            tmp.value = to_bool_(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
+            assigment_func("value", tmp, login_var, 0);  // 注册到self
+            return_value.u = statement_end;  // __init__没有return
+            break;
+        }
+        default:
+            break;
+    }
+    return_result: return return_value;
+}
+
+// to bool[底层实现]
+GWARF_value to_bool_(GWARF_value value, var_list *the_var){
+    if((value.type == BOOL_value)){
+        return value;  // 直接返回数据
+    }
+
+    GWARF_value return_number;
+    return_number.type = BOOL_value;
+
+    if(value.type == OBJECT_value){  // 调用__value__方法
+        return_number = to_bool_(get__value__(&value, the_var).value, the_var);  // 递归
+    }
+    else{
+        return_number.value.bool_value = to_bool(value);  // 转换成bool
+    }
+    return return_number;
+}
+
+GWARF_result get__value__(GWARF_value *base_the_var, var_list *the_var){  // 用于计算的get__value__统一核心
+    return run_func(base_the_var, the_var, "__value__");
+}
+
+GWARF_result get__bool__(GWARF_value *base_the_var, var_list *the_var){  // 用于计算的get__value__统一核心
+    return run_func(base_the_var, the_var, "__bool__");
+}
+
+GWARF_result run_func(GWARF_value *base_the_var, var_list *the_var, char *name){  // 无参数func->直到返回GWARF_value[not class]
+    GWARF_result reight_tmp, get;
+    int times = 0;
+    var_list *call_var;
+    while(1){
+        if(base_the_var->type == CLASS_value){  // is class so that can use "."
+            call_var = base_the_var->value.class_value->the_var;
+        }
+        else if(base_the_var->type == OBJECT_value){
+            call_var = base_the_var->value.object_value->the_var;
+        }
+        else{
+            reight_tmp.u = return_def;
+            reight_tmp.value = *base_the_var;
+            reight_tmp.return_times = times;
+            goto return_result;  // 如果类型不是object或者class
+        }
+        get.value = find_var(call_var, 0, name)->value;  // TODO:: 需要检查__value__是否存在
+        get.father = base_the_var;  // 设置father
+        reight_tmp = call_back_core(get, the_var, NULL);
+        times = reight_tmp.return_times;
+        base_the_var = &(reight_tmp.value);  // 重复获取__value__[直到类型不是object或class]
+    }
+    return_result: return reight_tmp;
+}

gwarf_interpreter/interpreter.c

@@ -3,9 +3,22 @@
 #include "../paser/y.tab.c"
 #include <math.h>
 
+// #include "interpreter.h"
+#include "branch.c"
+#include "cfunc.c"
+#include "parameter.c"
+#include "statement.c"
+#include "var.c"
+
 // running code
-GWARF_result while_func(statement *, var_list *);
 GWARF_result operation_func(statement *, var_list *, var_list *);
+GWARF_result while_func(statement *, var_list *);
+GWARF_result if_func(if_list *, var_list *);
+GWARF_result for_func(statement *, var_list *);
+GWARF_result call_back(statement *, var_list *);
+GWARF_result call_back_core(GWARF_result, var_list *, parameter *);
+GWARF_result block_func(statement *, var_list *);
+
 GWARF_result add_func(GWARF_result, GWARF_result, var_list *);
 GWARF_result sub_func(GWARF_result, GWARF_result, var_list *);
 GWARF_result mul_func(GWARF_result, GWARF_result, var_list *);
@@ -15,43 +28,31 @@ GWARF_result log_func(GWARF_result, GWARF_result, var_list *);
 GWARF_result sqrt_func(GWARF_result, GWARF_result, var_list *);
 GWARF_result assigment_func(char *, GWARF_result, var_list *, int);
 GWARF_result equal_func(GWARF_result, GWARF_result, var_list *, int);
-GWARF_result if_func(if_list *, var_list *);
-GWARF_result for_func(statement *, var_list *);
 GWARF_result negative_func(GWARF_result, var_list *);
-GWARF_result call_back(statement *, var_list *);
-GWARF_result call_back_core(GWARF_result, var_list *, parameter *);
-int len_only_double(double num);
-int len_double(double num);
-int len_int(int num);
-int len_intx(unsigned int num);
+
+double sqrt_(double, double);
+double log_(double, double);
 
 GWARF_value to_int(GWARF_value, var_list *the_var);
 GWARF_value to_double(GWARF_value value, var_list *the_var);
-GWARF_value to_bool_(GWARF_value value, var_list *the_var);
 GWARF_value to_str(GWARF_value value, var_list *the_var);
+GWARF_value to_bool_(GWARF_value value, var_list *the_var);
 bool to_bool(GWARF_value);
+
 GWARF_result get__value__(GWARF_value *, var_list *);
 GWARF_result get__bool__(GWARF_value *, var_list *);
 GWARF_result run_func(GWARF_value *, var_list *, char *);
 
-int get_var_list_len(var_list *);
-var_list *copy_var_list(var_list *);
-var_list * append_by_var_list(var_list *, var_list *);
-
-GWARF_result block_func(statement *, var_list *);
 
-// math
-double log_(double, double);
 double log_(double base, double num){  // 自己定义一次log
     return log(num) / log(base);
 }
 
-double sqrt_(double, double);
 double sqrt_(double base, double num){  // 定义根号sqrt
     return pow(base, (1 / num));
 }
 
-// bool[bool逻辑转换]
+
 bool to_bool(GWARF_value value){
     double bool_double = 1;  // if bool_double == 0则返回false其他返回true
     if(value.type == OBJECT_value){  // 调用左add方法
@@ -80,413 +81,6 @@ bool to_bool(GWARF_value value){
     }
 }
 
-// ---- parameter func[形参]
-parameter *make_parameter_name(char *name){
-    parameter *tmp;
-    tmp = malloc(sizeof(parameter));  // get an address for base var
-    tmp->next = NULL;
-    tmp->u.name = malloc(sizeof(name));
-    strcpy(tmp->u.name, name);
-    return tmp;
-}
-
-void append_parameter_name(char *name, parameter *parameter_base){
-    parameter *tmp = parameter_base;  // iter var
-    while(1){
-        if (tmp->next == NULL){  // the last
-            break;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-    parameter *new_tmp = make_parameter_name(name);
-    tmp->next = new_tmp;
-}
-
-// ---- parameter func[实参]
-parameter *make_parameter_value(statement *value){
-    parameter *tmp;
-    tmp = malloc(sizeof(parameter));  // get an address for base var
-    tmp->next = NULL;
-    tmp->u.value = value;
-    return tmp;
-}
-
-void append_parameter_value(statement *value, parameter *parameter_base){
-    parameter *tmp = parameter_base;  // iter var
-    while(1){
-        if (tmp->next == NULL){  // the last
-            break;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-    parameter *new_tmp = make_parameter_value(value);
-    tmp->next = new_tmp;
-}
-
-parameter *add_parameter_value(statement *value, parameter *parameter_base){
-    parameter *new_tmp = make_parameter_value(value);
-    new_tmp->next = parameter_base;
-    return new_tmp;
-}
-
-parameter *pack_value_parameter(GWARF_value value){  // 把value封装成参数
-    parameter *tmp;
-    tmp = malloc(sizeof(parameter));  // get an address for base var
-    tmp->next = NULL;
-    statement *statement_tmp = malloc(sizeof(statement));
-    statement_tmp->type = base_value;
-    statement_tmp->code.base_value.value = value;
-    tmp->u.value = statement_tmp;
-    return tmp;
-}
-
-statement *pack_call_name(char *name, statement *from){  // 快速生成call back函数的the_statment
-    statement *tmp = make_statement();
-    tmp->type = base_var;
-    tmp->code.base_var.var_name = name;
-    tmp->code.base_var.from = from;
-    return tmp;
-}
-
-// ---- var func
-
-var *make_var(){  // make var with base
-    var *tmp;
-    tmp = malloc(sizeof(var));  // get an address for base var
-    tmp->name = "";  // can't get the name for the real var
-    tmp->next = NULL;
-    return tmp;
-}
-
-void append_var(char *name, GWARF_value value, var *base_var){
-    int break_ = 1;  // get var[2] or not[1]
-    var *tmp = base_var;  // iter var
-    while(1){
-        if (!strcmp(tmp->name, name)){
-            break_ = 2;
-            break;
-        }
-        if (tmp->next == NULL){  // not var name *name
-            break_ = 1;
-            break;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-    if(break_ == 2){
-        tmp->value = value;
-        return;
-    }
-    var *new_tmp = make_var();
-    tmp->next = new_tmp;
-    new_tmp->name = malloc(sizeof(name));
-    strcpy(new_tmp->name, name);
-    new_tmp->value = value;
-}
-
-void free_var(var *base_var){  // free the address
-    var *tmp = base_var;  // iter var
-    while(1){
-        if (tmp->next == NULL){  // the last
-            free(tmp);
-            break;
-        }
-        var *tmp_2 = tmp;
-        tmp = tmp->next;
-        free(tmp_2);
-    }
-}
-
-var *get_var(char *name, var *base_var){  // get the address
-    var *tmp = base_var;  // iter var
-    while(1){
-        if (!strcmp(tmp->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
-            return tmp;
-        }
-        if (tmp->next == NULL){  // not var name *name
-            return NULL;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-}
-
-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(last_tmp != NULL){
-                last_tmp->next = tmp->next;  // if tmp->next is NULL last_tmp->next is NULL too
-            }
-            free(tmp);
-            return;
-        }
-        if (tmp->next == NULL){  // not var name *name
-            return;
-        }
-        tmp = tmp->next;  // get the next to iter
-        last_tmp = tmp;
-    }
-}
-
-// --------------default_var
-
-default_var *make_default_var(){  // make_default_var
-    default_var *tmp;
-    tmp = malloc(sizeof(default_var));  // get an address for default_var
-    tmp->next = NULL;
-    return tmp;
-}
-
-default_var *make_default_var_base(){  // if
-    default_var *tmp = make_default_var();
-    tmp->name = "";
-    tmp->from = 0;
-    return tmp;
-}
-
-void append_default_var_base(char *name ,int from, default_var *base_default_var){  // elif
-    default_var *start = base_default_var;
-    while(1){
-        if (!strcmp(start->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
-            return;  // 不可以二次设置
-        }
-        if (start->next == NULL){  // not var name *name
-            break;
-        }
-        start = start->next;  // get the next to iter
-    }
-    default_var *tmp = make_default_var();
-    tmp->name = name;
-    tmp->from = from;
-    start->next = tmp;
-    return;
-}
-
-int get_default(char *name, default_var *base_default_var){  // get the address
-    default_var *tmp = base_default_var;  // iter var
-    if(tmp == NULL){
-        return 0;
-    }
-    while(1){
-        if (!strcmp(tmp->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
-            return tmp->from;
-        }
-        if (tmp->next == NULL){  // not var name *name
-            return 0;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-}
-
-// ---- statement list
-
-statement *make_statement(){  // make statement
-    statement *tmp;
-    tmp = malloc(sizeof(statement));  // get an address for base var
-    tmp->next = NULL;
-    tmp->type = start;
-    return tmp;
-}
-
-statement *append_statement(statement *base_statement, statement *new_tmp){  // make statement next
-    statement *tmp = base_statement;  // iter var
-    while(1){
-        if (tmp->next == NULL){  // not var name *name
-            break;
-        }
-        tmp = tmp->next;  // get the next to iter
-    }
-    tmp->next = new_tmp;
-    return new_tmp;
-}
-
-// ---- var_list
-
-var_list *make_var_list(){  // make a empty var_list node
-    var_list *tmp;
-    tmp = malloc(sizeof(var_list));  // get an address for base var
-    tmp->next = NULL;
-    tmp->var_base = NULL;
-    tmp->default_list = make_default_var_base();
-    return tmp;
-}
-
-var_list *make_var_base(var *gloabl_var){  // make the base for global_var
-    var_list *tmp = make_var_list();
-    tmp->var_base = gloabl_var;
-    return tmp;
-}
-
-
-var_list *append_var_list(var *var_base, var_list *var_list_base){  // make var_list[FILO]
-    var_list *tmp = make_var_list();
-    tmp->var_base = var_base;
-    tmp->next = var_list_base;
-    return tmp;
-}
-
-var_list *append_by_var_list(var_list *back_var_list, var_list *var_list_base){  // 拼凑两个var_list
-    var_list *start = back_var_list;
-    while(1){
-        if(start->next == NULL){  // to the last
-            break;
-        }
-        start = start->next;
-    }
-    start->next = var_list_base;
-    return back_var_list;
-}
-
-var_list *free_var_list(var_list *var_list_base){  // free one var_list[FILO]
-    var_list *tmp = var_list_base->next;
-    if(tmp==NULL){
-        return var_list_base;
-    }
-    free(var_list_base);
-    return tmp;
-}
-
-int get_var_list_len(var_list *var_base){
-    var_list *start = var_base;
-    int tmp = 0;
-    while(1){
-        if(start->next == NULL){
-            break;
-        }
-        start = start->next;
-        tmp += 1;
-    }
-    return tmp;
-}
-
-var *find_var(var_list *var_base,int from, char *name){  // find var by func get_var in var_list[iter to find]
-    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;
-    }
-    // printf("name = %s, from = %d, address = %x\n", name, from, start->var_base);
-    while (1)
-    {
-        return_var = get_var(name, start->var_base);
-        if((return_var == NULL) && (start->next == NULL)){  // don't get the var and not next
-            return NULL;
-        }
-        else if((return_var == NULL) && (start->next != NULL)){  // don't get the var but can next
-            start = start->next;
-            continue;
-        }
-        // printf("find on name = %s, from = %d, address = %x\n", name, from, start->var_base);
-        return return_var;  //get var success can or can't next
-    }
-}
-
-void add_var(var_list *var_base,int from, char *name, GWARF_value value){  // add var by func append_var in var_list[iter to find]
-    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;
-    }
-    // printf("----var add address = %d----\n", start);
-    append_var(name, value, start->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节点
-    tmp = start;  // 记录base节点
-    while(1){  // 复制var_list链
-        if((start == NULL) || (start->next == NULL)){
-            break;
-        }
-        puts("F1");
-        var_list *next_tmp = malloc(sizeof(start->next));
-        memcpy(next_tmp, start->next, sizeof(start->next));  // 复制到新的地方
-        start->next = next_tmp;  // 应用新的地方
-        start = start->next;
-    }
-    return tmp;
-}
-
-// ---- statement_list
-statement_list *make_statement_list(){  // make a empty var_list node
-    statement_list *tmp;
-    tmp = malloc(sizeof(statement_list));  // get an address for base var
-    tmp->next = NULL;
-    tmp->statement_base = NULL;
-    return tmp;
-}
-
-statement_list *make_statement_base(statement *gloabl_code){
-    statement_list *tmp = make_statement_list();
-    tmp->statement_base = gloabl_code;
-    return tmp;
-}
-
-statement_list *append_statement_list(statement *statement_base, statement_list *statment_list_base){  // make var_list[FILO]
-    statement_list *tmp = make_statement_list();
-    tmp->statement_base = statement_base;
-    tmp->next = statment_list_base;
-    return tmp;
-}
-
-statement *find_statement_list(int from, statement_list *statment_list_base){  // find var by func get_var in var_list[iter to find]
-    statement_list *start = statment_list_base;
-    for(int i = 0;i < from;i+= 1){
-        if(start->next == NULL){
-            break;
-        }
-        start = start->next;
-    }
-    return start->statement_base;
-}
-
-statement_list *free_statement_list(statement_list *statment_list_base){  // make var_list[FILO]
-    statement_list *tmp = statment_list_base->next;
-    if(tmp != NULL){
-        free(statment_list_base);
-        return tmp;
-    }
-    return statment_list_base;
-}
-
-// ---- if_list
-if_list *make_base_if(){  // make base if
-    if_list *tmp;
-    tmp = malloc(sizeof(if_list));  // get an address for base var
-    tmp->next = NULL;
-    tmp->done = NULL;
-    tmp->condition = NULL;
-    return tmp;
-}
-
-if_list *make_if(statement *condition, statement *done_base){  // if
-    if_list *tmp = make_base_if();
-    tmp->done = done_base;
-    tmp->condition = condition;
-    return tmp;
-}
-
-if_list *append_elif(if_list *tmp ,if_list *base_if_list){  // elif
-    if_list *start = base_if_list;
-    while(1){
-        if(start->next  == NULL){
-            break;
-        }
-        start = start->next;
-    }
-    start->next = tmp;
-    return tmp;
-}
-
-// ---- run code
 
 GWARF_result read_statement(statement *the_statement, var_list *the_var, var_list *login_var){  // read the statement list with case to run by func
     if(login_var == NULL){
@@ -2242,775 +1836,6 @@ inter *get_inter(){
 }
 
 // ------official func
-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 *)){  // 注册单个official func
-    GWARF_result func_value;
-    func *func_tmp = malloc(sizeof(func));
-
-    func_tmp->done = NULL;
-    func_tmp->parameter_list = NULL;
-    func_tmp->the_var = copy_var_list(the_var);
-    func_tmp->type = official;
-    func_tmp->official_func = type;
-    func_tmp->is_class = is_class;
-    func_tmp->paser = paser;
-
-    func_value.value.type = FUNC_value;
-    func_value.value.value.func_value = func_tmp;
-    assigment_func(name, func_value, the_var, 0);  // 注册函数到指定的位置
-}
-
-void login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *)){
-    // {{official_func_type, is_class}}
-    int a[][2] = {{1,0}};
-    // {login_name}
-    char *name[] = {"print"};
 
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], the_var, name[i], paser);
-    }
-}
-
-
-// global 全局内置函数解析器
-GWARF_result official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){
-    GWARF_result return_value;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    switch (the_func->official_func)
-    {
-    case printf_func:{  // printf something
-        if(tmp_s == NULL){  // 没有东西要打印
-            goto return_result;
-        }
-        while(1){
-            GWARF_result tmp = traverse(tmp_s->u.value, out_var, false);
-            if((tmp.value.type == INT_value)){
-                printf("%d", tmp.value.value.int_value);
-            }
-            else if(tmp.value.type == BOOL_value){
-                if(tmp.value.value.bool_value){
-                    printf("true");
-                }
-                else{
-                    printf("false");
-                } 
-            }
-            else if(tmp.value.type == NUMBER_value){
-                printf("%f", tmp.value.value.double_value);
-            }
-            else if(tmp.value.type == NULL_value){
-                printf("<-None->");
-            }
-            else if(tmp.value.type == STRING_value){
-                printf("'%s'", tmp.value.value.string);
-            }
-            else if(tmp.value.type == FUNC_value){
-                printf("<-function on %u->", tmp.value.value.func_value);
-            }
-            else if(tmp.value.type == CLASS_value){
-                printf("<-class on %u->", tmp.value.value.class_value);
-            }
-            else if(tmp.value.type == OBJECT_value){
-                printf("<-object on %u->", tmp.value.value.object_value);
-            }
-            else{
-                printf("var value = other\n");
-            }
-            if (tmp_s->next == NULL){  // the last
-                break;
-            }
-            tmp_s = tmp_s->next;
-        }
-        printf("\n");  // 换行
-        return_value.u = statement_end;
-        break;
-    }
-    default:
-        break;
-    }
-    return_result: return return_value;
-}
-
-class_object *object_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *)){  // 内置对象继承的类
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("object", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-
-    // 注册函数
-    int a[][2] = {{3,1}};
-    char *name[] = {"__value__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result object_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    switch (the_func->official_func)
-    {
-        case __value__func:{  // 若想实现运算必须要有这个方法
-            return_value.value.type = STRING_value;  // 取得用于计算的数值
-            return_value.value = to_str(*(father.father), out_var);
-            break;
-        }
-    }
-    return_result: return return_value;
-}
-
-class_object *gobject_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){  // 内置对象继承的类
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    if(father_var_list != NULL){
-        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
-    }
-
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("gobject", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-    // 注册函数
-    int a[][2] = {{2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}, {8,1}, {9,1}, {10,1}, {11,1}, {12,1}, {13,1}, {14,1}, {15,1}, {16,1}, {17,1}, {3,1}};
-    char *name[] = {"__init__", "__value__", "__add__", "__sub__", "__mul__","__div__","__eq__", "__more__", "__less__", "__eqmore__", "__eqless__","__noteq__", "__pow__", "__log__","__sqrt__","__negative__","__bool__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result gobject_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    else{
-        printf("NO login, father type = %d\n", father.father->type);
-    }
-    switch (the_func->official_func)
-    {
-        case __init__func:{  // printf something
-            GWARF_result tmp;
-            tmp.value.type = INT_value;
-            tmp.value.value.int_value = 0;
-            assigment_func("value", tmp, login_var, 0);  // 注册到self
-            return_value.u = statement_end;  // __init__没有return
-            break;
-        }
-        case __value__func:{  // 若想实现运算必须要有这个方法
-            var *tmp = find_var(login_var, 0, "value");  // gobject类的value存储在self.value中
-            return_value.value = tmp->value;  // 取得用于计算的数值
-            break;
-        }
-        case __add__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = add_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __sub__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = sub_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __mul__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = mul_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __div__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = div_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __eq__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 0);
-            break;
-        }
-        case __more__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 1);
-            break;
-        }
-        case __less__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 2);
-            break;
-        }
-        case __eqmore__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 3);
-            break;
-        }
-        case __eqless__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 4);
-            break;
-        }
-        case __noteq__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = equal_func(left_tmp, reight_tmp, out_var, 5);
-            break;
-        }
-        case __pow__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = pow_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __log__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = log_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __sqrt__func:{
-            GWARF_result reight_tmp, left_tmp;
-            GWARF_value base_the_var = traverse(tmp_s->u.value, out_var, false).value;  // 只有一个参数
-            reight_tmp = get__value__(&base_the_var, the_var);
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = sqrt_func(left_tmp, reight_tmp, out_var);
-            break;
-        }
-        case __negative__func:{
-            GWARF_result left_tmp;
-            left_tmp.value = find_var(login_var, 0, "value")->value;
-            return_value = negative_func(left_tmp, out_var);
-            break;
-        }
-        default:
-            break;
-    }
-    return_result: return return_value;
-}
-
-class_object *int_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    if(father_var_list != NULL){
-        append_by_var_list(class_tmp->the_var, father_var_list);  // int、double、str等内置类需要继承gobject类
-    }
-
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("int", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-    // 注册函数
-    int a[][2] = {{2,1}};
-    char *name[] = {"__init__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result int_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    else{
-        printf("NO login, father type = %d\n", father.father->type);
-    }
-    switch (the_func->official_func)
-    {
-        case __init__func:{  // printf something
-            GWARF_result tmp;
-            tmp.value = to_int(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
-            assigment_func("value", tmp, login_var, 0);  // 注册到self
-            return_value.u = statement_end;  // __init__没有return
-            break;
-        }
-        default:
-            break;
-    }
-    return_result: return return_value;
-}
-
-// to int[底层实现]
-GWARF_value to_int(GWARF_value value, var_list *the_var){
-    if((value.type == INT_value)){
-        return value;  // 直接返回数据
-    }
-
-    GWARF_value return_number;
-    return_number.type = INT_value;
-
-    if(value.type == OBJECT_value){  // 调用__value__方法
-        return_number = to_int(get__value__(&value, the_var).value, the_var);  // 递归
-    }
-    else{
-        if(value.type == BOOL_value){
-            return_number.value.int_value = value.value.bool_value;
-        }
-        else if(value.type == NUMBER_value){
-            return_number.value.int_value = (int)value.value.double_value;
-        }
-        else if(value.type == STRING_value){
-            return_number.value.int_value = atoi(value.value.string);
-        }
-        else{
-            return_number.value.int_value = 0;
-        }
-    }
-    return return_number;
-}
-
-
-class_object *double_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    if(father_var_list != NULL){
-        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
-    }
-
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("double", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-    // 注册函数
-    int a[][2] = {{2,1}};
-    char *name[] = {"__init__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result double_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    else{
-        printf("NO login, father type = %d\n", father.father->type);
-    }
-    switch (the_func->official_func)
-    {
-        case __init__func:{  // printf something
-            GWARF_result tmp;
-            tmp.value = to_double(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
-            assigment_func("value", tmp, login_var, 0);  // 注册到self
-            return_value.u = statement_end;  // __init__没有return
-            break;
-        }
-        default:
-            break;
-    }
-    return_result: return return_value;
-}
-
-// to double[底层实现]
-GWARF_value to_double(GWARF_value value, var_list *the_var){
-    if((value.type == NUMBER_value)){
-        return value;  // 直接返回数据
-    }
-
-    GWARF_value return_number;
-    return_number.type = NUMBER_value;
-
-    if(value.type == OBJECT_value){  // 调用__value__方法
-        return_number = to_double(get__value__(&value, the_var).value, the_var);  // 递归
-    }
-    else{
-        if(value.type == BOOL_value){
-            return_number.value.double_value = (double)value.value.bool_value;
-        }
-        else if(value.type == INT_value){
-            return_number.value.double_value = (double)value.value.int_value;
-        }
-        else if(value.type == STRING_value){
-            return_number.value.double_value = (double)atof(value.value.string);
-        }
-        else{
-            return_number.value.double_value = 0;
-        }
-    }
-    return return_number;
-}
-
-class_object *str_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    if(father_var_list != NULL){
-        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
-    }
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("str", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-    // 注册函数
-    int a[][2] = {{2,1}};
-    char *name[] = {"__init__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result str_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    else{
-        printf("NO login, father type = %d\n", father.father->type);
-    }
-    switch (the_func->official_func)
-    {
-        case __init__func:{  // printf something
-            GWARF_result tmp;
-            tmp.value = to_str(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
-            assigment_func("value", tmp, login_var, 0);  // 注册到self
-            return_value.u = statement_end;  // __init__没有return
-            break;
-        }
-        default:
-            break;
-    }
-    return_result: return return_value;
-}
-
-// to str[底层实现]
-GWARF_value to_str(GWARF_value value, var_list *the_var){
-    if((value.type == STRING_value)){
-        return value;  // 直接返回数据
-    }
-
-    GWARF_value return_number;
-    return_number.type = STRING_value;
-
-    if(value.type == OBJECT_value){  // 调用__value__方法
-        return_number = to_str(get__value__(&value, the_var).value, the_var);  // 递归
-    }
-    else{
-        if(value.type == BOOL_value){
-            if(value.value.bool_value){
-                return_number.value.string = "true";
-            }
-            else{
-                return_number.value.string = "false";
-            }
-        }
-        else if(value.type == INT_value){
-            size_t size = (size_t)(2 + len_int(value.value.int_value));
-            return_number.value.string = (char *)malloc(size);
-            snprintf(return_number.value.string, size, "%d", value.value.int_value);
-        }
-        else if(value.type == NUMBER_value){
-            size_t size = (size_t)(2 + len_double(value.value.double_value));
-            return_number.value.string = (char *)malloc(size);
-            snprintf(return_number.value.string, size, "%f", value.value.double_value);
-        }
-        else if(value.type == NULL_value){
-            return_number.value.string = "<-None->";
-        }
-        else if(value.type == FUNC_value){
-            size_t size = (size_t)(20 + len_intx((unsigned int)value.value.func_value));  // 转换为无符号整形数字
-            return_number.value.string = (char *)malloc(size);
-            snprintf(return_number.value.string, size, "<-function on %u->", value.value.func_value);
-        }
-        else if(value.type == CLASS_value){
-            size_t size = (size_t)(16 + len_intx((unsigned int)value.value.class_value));
-            return_number.value.string = (char *)malloc(size);
-            snprintf(return_number.value.string, size, "<-class on %u->", value.value.class_value);
-        }
-        else{
-            printf("var value = other\n");
-        }
-    }
-    return return_number;
-}
-
-class_object *bool_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list){
-    // 创建对象[空对象]
-    puts("----set class----");
-    GWARF_result class_value;
-    class_object *class_tmp = malloc(sizeof(class_object));
-
-    class_tmp->the_var = make_var_base(make_var());  // make class var list
-    if(father_var_list != NULL){
-        append_by_var_list(class_tmp->the_var, father_var_list);  // 一切类都需要继承object类[包括set class如果tmp_s == NULL则需要继承object]
-    }
-    class_tmp->out_var = append_by_var_list(class_tmp->the_var, copy_var_list(the_var));  // make class var list with out var
-    class_value.value.type = CLASS_value;
-    class_value.value.value.class_value = class_tmp;
-
-    assigment_func("bool", class_value, the_var, 0);  // 注册class 的 位置
-    puts("----stop set class----");
-
-    // 注册函数
-    int a[][2] = {{2,1}};
-    char *name[] = {"__init__"};
-
-    int lenth = sizeof(a)/sizeof(a[0]);
-    for(int i = 0;i < lenth;i+=1){
-        login_official_func(a[i][0], a[i][1], class_tmp->the_var, name[i], paser);
-    }
-    return class_tmp;
-}
-
-GWARF_result bool_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var){  // out_var是外部环境, the_var是self内部环境
-    GWARF_result return_value;
-    var_list *login_var;
-    return_value.u = return_def;
-    return_value.return_times = 0;
-    if(father.father->type == CLASS_value){  // is class so that can use "."
-        login_var = father.father->value.class_value->the_var;
-    }
-    else if(father.father->type == OBJECT_value){
-        login_var = father.father->value.object_value->the_var;
-    }
-    else{
-        printf("NO login, father type = %d\n", father.father->type);
-    }
-    switch (the_func->official_func)
-    {
-        case __init__func:{  // printf something
-            GWARF_result tmp;
-            tmp.value = to_bool_(traverse(tmp_s->u.value, out_var, false).value, out_var);  // 只有一个参数[要针对不同数据类型对此处作出处理]
-            assigment_func("value", tmp, login_var, 0);  // 注册到self
-            return_value.u = statement_end;  // __init__没有return
-            break;
-        }
-        default:
-            break;
-    }
-    return_result: return return_value;
-}
-
-// to bool[底层实现]
-GWARF_value to_bool_(GWARF_value value, var_list *the_var){
-    if((value.type == BOOL_value)){
-        return value;  // 直接返回数据
-    }
-
-    GWARF_value return_number;
-    return_number.type = BOOL_value;
-
-    if(value.type == OBJECT_value){  // 调用__value__方法
-        return_number = to_bool_(get__value__(&value, the_var).value, the_var);  // 递归
-    }
-    else{
-        return_number.value.bool_value = to_bool(value);  // 转换成bool
-    }
-    return return_number;
-}
-
-GWARF_result get__value__(GWARF_value *base_the_var, var_list *the_var){  // 用于计算的get__value__统一核心
-    return run_func(base_the_var, the_var, "__value__");
-}
-
-GWARF_result get__bool__(GWARF_value *base_the_var, var_list *the_var){  // 用于计算的get__value__统一核心
-    return run_func(base_the_var, the_var, "__bool__");
-}
-
-GWARF_result run_func(GWARF_value *base_the_var, var_list *the_var, char *name){  // 无参数func->直到返回GWARF_value[not class]
-    GWARF_result reight_tmp, get;
-    int times = 0;
-    var_list *call_var;
-    while(1){
-        if(base_the_var->type == CLASS_value){  // is class so that can use "."
-            call_var = base_the_var->value.class_value->the_var;
-        }
-        else if(base_the_var->type == OBJECT_value){
-            call_var = base_the_var->value.object_value->the_var;
-        }
-        else{
-            reight_tmp.u = return_def;
-            reight_tmp.value = *base_the_var;
-            reight_tmp.return_times = times;
-            goto return_result;  // 如果类型不是object或者class
-        }
-        get.value = find_var(call_var, 0, name)->value;  // TODO:: 需要检查__value__是否存在
-        get.father = base_the_var;  // 设置father
-        reight_tmp = call_back_core(get, the_var, NULL);
-        times = reight_tmp.return_times;
-        base_the_var = &(reight_tmp.value);  // 重复获取__value__[直到类型不是object或class]
-    }
-    return_result: return reight_tmp;
-}
-
-GWARF_value to_object(GWARF_value value, var_list *the_var){  // 把GWARF_value封装成objct
-    GWARF_result return_value;
-    if((value.type == CLASS_value) || (value.type == OBJECT_value) || (value.type == FUNC_value) || (value.type == NULL_value)){  // 可以直接返回
-        return value;
-    }
-    GWARF_result func_result;
-    if(value.type == NUMBER_value){
-        func_result.value = find_var(the_var, 0, "double")->value;
-    }
-    else if(value.type == INT_value){
-        func_result.value = find_var(the_var, 0, "int")->value;
-    }
-    else if(value.type == BOOL_value){
-        func_result.value = find_var(the_var, 0, "bool")->value;
-    }
-    else if(value.type == STRING_value){
-        func_result.value = find_var(the_var, 0, "str")->value;
-    }
-    else{
-        return value;
-    }
-    return call_back_core(func_result, the_var, pack_value_parameter(value)).value;
-}
-
-
-int len_int(int num){
-    int count = 1;  // 默认得有1位
-    while(1){
-        num = num / 10;
-        if(num <= 0){
-            break;
-        }
-        count += 1;
-    }
-    return count;
-}
-
-int len_only_double(double num){
-    int count = 1;  // 默认得有1位
-    while(1){
-        num = num * 10;
-        if(num - (int)num <= 0){
-            break;
-        }
-        count += 1;
-    }
-    return count;
-}
-
-int len_double(double num){
-    int count = 1, i = (int)num;
-    count += len_int(i);
-    count += len_only_double(num);
-    return count;
-}
-
-int len_intx(unsigned int num){  // 16进制
-    int count = 1;  // 默认得有1位
-    while(1){
-        num = num / 16;
-        if(num <= 0){
-            break;
-        }
-        count += 1;
-    }
-    return count;
-}
 
-// TODO::设置func和NULL均为object，设置object无__add___等方法时的操作
+// TODO::设置func和NULL均为object，设置object无__add___等方法时的操作:: NULL永远只有一个实例, object回调__call__   [find_var类型检查]

gwarf_interpreter/interprete.h → gwarf_interpreter/interpreter.h

@@ -265,39 +265,6 @@ typedef struct{
     statement *global_code;  // global code链表
 } inter;
 
-//------- var func
-var *make_var();
-void append_var(char *, GWARF_value , var *);
-void free_var(var *);
-var *get_var(char *, var *);
-void del_var(char *, var *);
-
-
-default_var *make_default_var();
-default_var *make_default_var_base();
-void append_default_var_base(char * ,int , default_var *);
-int get_default(char *, default_var *);
-
-
-//------- statement func
-statement *make_statement();
-statement *append_statement(statement *, statement*);
-
-statement_list *make_statement_list();
-statement_list *make_statement_base(statement *);
-statement_list *append_statement_list(statement *, statement_list *);
-statement *find_statement_list(int, statement_list *);
-statement_list *free_statement_list(statement_list *);
-
-//------- if func
-if_list *make_base_if();
-if_list *make_if(statement *, statement *);
-if_list *append_elif(if_list *, if_list *);
-
-//------- run func
-GWARF_result traverse(statement *, var_list *, bool);
-GWARF_result traverse_global(statement *, var_list *);
-
 //------- class/object/func
 typedef enum{
     customize = 1,  // func by user
@@ -344,29 +311,43 @@ typedef struct the_object{
     struct var_list *the_var;  // 记录class_object的实例  -- 相当与self
 } the_object;
 
-//------- inter func
-inter *get_inter();
-
-// //------ paser func
-int yyerror(char const *);
-FILE *yyin;
-char *yytext;
-
-// ---- parameter func[形参]
-parameter *make_parameter_name(char *);
-void append_parameter_name(char *, parameter *);
-
-// ---- parameter func[实参]
-parameter *make_parameter_value(statement *);
-void append_parameter_value(statement *, parameter *);
-parameter *add_parameter_value(statement *, parameter *);
-
-parameter *pack_value_parameter(GWARF_value);
-statement *pack_call_name(char *, statement *);
-
-// main
-inter *global_inter;
-statement_list *statement_base;
+// 函数声明
+GWARF_result operation_func(statement *, var_list *, var_list *);
+GWARF_result while_func(statement *, var_list *);
+GWARF_result if_func(if_list *, var_list *);
+GWARF_result for_func(statement *, var_list *);
+GWARF_result call_back(statement *, var_list *);
+GWARF_result call_back_core(GWARF_result, var_list *, parameter *);
+GWARF_result block_func(statement *, var_list *);
+
+GWARF_result add_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result sub_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result mul_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result div_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result pow_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result log_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result sqrt_func(GWARF_result, GWARF_result, var_list *);
+GWARF_result assigment_func(char *, GWARF_result, var_list *, int);
+GWARF_result equal_func(GWARF_result, GWARF_result, var_list *, int);
+GWARF_result negative_func(GWARF_result, var_list *);
+
+double sqrt_(double, double);
+double log_(double, double);
+
+GWARF_value to_int(GWARF_value, var_list *the_var);
+GWARF_value to_double(GWARF_value value, var_list *the_var);
+GWARF_value to_str(GWARF_value value, var_list *the_var);
+GWARF_value to_bool_(GWARF_value value, var_list *the_var);
+bool to_bool(GWARF_value);
+
+GWARF_result get__value__(GWARF_value *, var_list *);
+GWARF_result get__bool__(GWARF_value *, var_list *);
+GWARF_result run_func(GWARF_value *, var_list *, char *);
+
+int len_only_double(double num);
+int len_double(double num);
+int len_int(int num);
+int len_intx(unsigned int num);
 GWARF_value to_object(GWARF_value, 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 *));
@@ -397,4 +378,58 @@ GWARF_result str_official_func(func *the_func, parameter *tmp_s, var_list *the_v
 
 // bool内置类
 class_object *bool_login_official(var_list *the_var, GWARF_result (*paser)(func *, parameter *, var_list *, GWARF_result, var_list *), var_list *father_var_list);
-GWARF_result bool_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+GWARF_result bool_official_func(func *the_func, parameter *tmp_s, var_list *the_var, GWARF_result father, var_list *out_var);
+
+if_list *make_base_if();
+if_list *make_if(statement *, statement *);
+if_list *append_elif(if_list *, if_list *);
+
+statement *make_statement();
+statement *append_statement(statement *, statement*);
+statement_list *make_statement_list();
+statement_list *make_statement_base(statement *);
+statement_list *append_statement_list(statement *, statement_list *);
+statement *find_statement_list(int, statement_list *);
+statement_list *free_statement_list(statement_list *);
+
+var *make_var();
+void append_var(char *name, GWARF_value, var *);
+void free_var(var *);
+var *get_var(char *, var *);
+void del_var(char *, var *);
+default_var *make_default_var();
+default_var *make_default_var_base();
+void append_default_var_base(char * ,int , default_var *);
+int get_default(char *, default_var *);
+var_list *make_var_list();
+var_list *make_var_base(var *);
+var_list *append_var_list(var *, var_list *);
+var_list *append_by_var_list(var_list *, var_list *);
+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);
+var_list *copy_var_list(var_list *);
+
+parameter *make_parameter_name(char *);
+void append_parameter_name(char *, parameter *);
+
+parameter *make_parameter_value(statement *);
+void append_parameter_value(statement *, parameter *);
+parameter *add_parameter_value(statement *, parameter *);
+
+parameter *pack_value_parameter(GWARF_value);
+statement *pack_call_name(char *, statement *);
+
+
+GWARF_result traverse(statement *, var_list *, bool);
+GWARF_result traverse_global(statement *, var_list *);
+
+inter *get_inter();
+
+inter *global_inter;
+statement_list *statement_base;
+
+int yyerror(char const *);
+FILE *yyin;
+char *yytext;

gwarf_interpreter/parameter.c

@@ -0,0 +1,80 @@
+#include<stdio.h>
+// #include "interpreter.h"
+
+parameter *make_parameter_name(char *);
+void append_parameter_name(char *, parameter *);
+
+parameter *make_parameter_value(statement *);
+void append_parameter_value(statement *, parameter *);
+parameter *add_parameter_value(statement *, parameter *);
+
+parameter *pack_value_parameter(GWARF_value);
+statement *pack_call_name(char *, statement *);
+
+
+parameter *make_parameter_name(char *name){
+    parameter *tmp;
+    tmp = malloc(sizeof(parameter));  // get an address for base var
+    tmp->next = NULL;
+    tmp->u.name = malloc(sizeof(name));
+    strcpy(tmp->u.name, name);
+    return tmp;
+}
+
+void append_parameter_name(char *name, parameter *parameter_base){
+    parameter *tmp = parameter_base;  // iter var
+    while(1){
+        if (tmp->next == NULL){  // the last
+            break;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+    parameter *new_tmp = make_parameter_name(name);
+    tmp->next = new_tmp;
+}
+
+// ---- parameter func[实参]
+parameter *make_parameter_value(statement *value){
+    parameter *tmp;
+    tmp = malloc(sizeof(parameter));  // get an address for base var
+    tmp->next = NULL;
+    tmp->u.value = value;
+    return tmp;
+}
+
+void append_parameter_value(statement *value, parameter *parameter_base){
+    parameter *tmp = parameter_base;  // iter var
+    while(1){
+        if (tmp->next == NULL){  // the last
+            break;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+    parameter *new_tmp = make_parameter_value(value);
+    tmp->next = new_tmp;
+}
+
+parameter *add_parameter_value(statement *value, parameter *parameter_base){
+    parameter *new_tmp = make_parameter_value(value);
+    new_tmp->next = parameter_base;
+    return new_tmp;
+}
+
+parameter *pack_value_parameter(GWARF_value value){  // 把value封装成参数
+    parameter *tmp;
+    tmp = malloc(sizeof(parameter));  // get an address for base var
+    tmp->next = NULL;
+    statement *statement_tmp = malloc(sizeof(statement));
+    statement_tmp->type = base_value;
+    statement_tmp->code.base_value.value = value;
+    tmp->u.value = statement_tmp;
+    return tmp;
+}
+
+statement *pack_call_name(char *name, statement *from){  // 快速生成call back函数的the_statment
+    statement *tmp = make_statement();
+    tmp->type = base_var;
+    tmp->code.base_var.var_name = name;
+    tmp->code.base_var.from = from;
+    return tmp;
+}

gwarf_interpreter/statement.c

@@ -0,0 +1,71 @@
+#include<stdio.h>
+// #include "interpreter.h"
+
+statement *make_statement();
+statement *append_statement(statement *, statement*);
+statement_list *make_statement_list();
+statement_list *make_statement_base(statement *);
+statement_list *append_statement_list(statement *, statement_list *);
+statement *find_statement_list(int, statement_list *);
+statement_list *free_statement_list(statement_list *);
+
+statement *make_statement(){  // make statement
+    statement *tmp;
+    tmp = malloc(sizeof(statement));  // get an address for base var
+    tmp->next = NULL;
+    tmp->type = start;
+    return tmp;
+}
+
+statement *append_statement(statement *base_statement, statement *new_tmp){  // make statement next
+    statement *tmp = base_statement;  // iter var
+    while(1){
+        if (tmp->next == NULL){  // not var name *name
+            break;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+    tmp->next = new_tmp;
+    return new_tmp;
+}
+
+statement_list *make_statement_list(){  // make a empty var_list node
+    statement_list *tmp;
+    tmp = malloc(sizeof(statement_list));  // get an address for base var
+    tmp->next = NULL;
+    tmp->statement_base = NULL;
+    return tmp;
+}
+
+statement_list *make_statement_base(statement *gloabl_code){
+    statement_list *tmp = make_statement_list();
+    tmp->statement_base = gloabl_code;
+    return tmp;
+}
+
+statement_list *append_statement_list(statement *statement_base, statement_list *statment_list_base){  // make var_list[FILO]
+    statement_list *tmp = make_statement_list();
+    tmp->statement_base = statement_base;
+    tmp->next = statment_list_base;
+    return tmp;
+}
+
+statement *find_statement_list(int from, statement_list *statment_list_base){  // find var by func get_var in var_list[iter to find]
+    statement_list *start = statment_list_base;
+    for(int i = 0;i < from;i+= 1){
+        if(start->next == NULL){
+            break;
+        }
+        start = start->next;
+    }
+    return start->statement_base;
+}
+
+statement_list *free_statement_list(statement_list *statment_list_base){  // make var_list[FILO]
+    statement_list *tmp = statment_list_base->next;
+    if(tmp != NULL){
+        free(statment_list_base);
+        return tmp;
+    }
+    return statment_list_base;
+}

gwarf_interpreter/var.c

@@ -0,0 +1,262 @@
+#include<stdio.h>
+// #include "interpreter.h"
+
+var *make_var();
+void append_var(char *name, GWARF_value, var *);
+void free_var(var *);
+var *get_var(char *, var *);
+void del_var(char *, var *);
+default_var *make_default_var();
+default_var *make_default_var_base();
+void append_default_var_base(char * ,int , default_var *);
+int get_default(char *, default_var *);
+var_list *make_var_list();
+var_list *make_var_base(var *);
+var_list *append_var_list(var *, var_list *);
+var_list *append_by_var_list(var_list *, var_list *);
+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);
+var_list *copy_var_list(var_list *);
+
+var *make_var(){  // make var with base
+    var *tmp;
+    tmp = malloc(sizeof(var));  // get an address for base var
+    tmp->name = "";  // can't get the name for the real var
+    tmp->next = NULL;
+    return tmp;
+}
+
+void append_var(char *name, GWARF_value value, var *base_var){
+    int break_ = 1;  // get var[2] or not[1]
+    var *tmp = base_var;  // iter var
+    while(1){
+        if (!strcmp(tmp->name, name)){
+            break_ = 2;
+            break;
+        }
+        if (tmp->next == NULL){  // not var name *name
+            break_ = 1;
+            break;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+    if(break_ == 2){
+        tmp->value = value;
+        return;
+    }
+    var *new_tmp = make_var();
+    tmp->next = new_tmp;
+    new_tmp->name = malloc(sizeof(name));
+    strcpy(new_tmp->name, name);
+    new_tmp->value = value;
+}
+
+void free_var(var *base_var){  // free the address
+    var *tmp = base_var;  // iter var
+    while(1){
+        if (tmp->next == NULL){  // the last
+            free(tmp);
+            break;
+        }
+        var *tmp_2 = tmp;
+        tmp = tmp->next;
+        free(tmp_2);
+    }
+}
+
+var *get_var(char *name, var *base_var){  // get the address
+    var *tmp = base_var;  // iter var
+    while(1){
+        if (!strcmp(tmp->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
+            return tmp;
+        }
+        if (tmp->next == NULL){  // not var name *name
+            return NULL;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+}
+
+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(last_tmp != NULL){
+                last_tmp->next = tmp->next;  // if tmp->next is NULL last_tmp->next is NULL too
+            }
+            free(tmp);
+            return;
+        }
+        if (tmp->next == NULL){  // not var name *name
+            return;
+        }
+        tmp = tmp->next;  // get the next to iter
+        last_tmp = tmp;
+    }
+}
+
+// --------------default_var
+
+default_var *make_default_var(){  // make_default_var
+    default_var *tmp;
+    tmp = malloc(sizeof(default_var));  // get an address for default_var
+    tmp->next = NULL;
+    return tmp;
+}
+
+default_var *make_default_var_base(){  // if
+    default_var *tmp = make_default_var();
+    tmp->name = "";
+    tmp->from = 0;
+    return tmp;
+}
+
+void append_default_var_base(char *name ,int from, default_var *base_default_var){  // elif
+    default_var *start = base_default_var;
+    while(1){
+        if (!strcmp(start->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
+            return;  // 不可以二次设置
+        }
+        if (start->next == NULL){  // not var name *name
+            break;
+        }
+        start = start->next;  // get the next to iter
+    }
+    default_var *tmp = make_default_var();
+    tmp->name = name;
+    tmp->from = from;
+    start->next = tmp;
+    return;
+}
+
+int get_default(char *name, default_var *base_default_var){  // get the address
+    default_var *tmp = base_default_var;  // iter var
+    if(tmp == NULL){
+        return 0;
+    }
+    while(1){
+        if (!strcmp(tmp->name, name)){  // if tmp->name == name , strcmp will return 0, if not strcmp return not 0
+            return tmp->from;
+        }
+        if (tmp->next == NULL){  // not var name *name
+            return 0;
+        }
+        tmp = tmp->next;  // get the next to iter
+    }
+}
+
+var_list *make_var_list(){  // make a empty var_list node
+    var_list *tmp;
+    tmp = malloc(sizeof(var_list));  // get an address for base var
+    tmp->next = NULL;
+    tmp->var_base = NULL;
+    tmp->default_list = make_default_var_base();
+    return tmp;
+}
+
+var_list *make_var_base(var *gloabl_var){  // make the base for global_var
+    var_list *tmp = make_var_list();
+    tmp->var_base = gloabl_var;
+    return tmp;
+}
+
+
+var_list *append_var_list(var *var_base, var_list *var_list_base){  // make var_list[FILO]
+    var_list *tmp = make_var_list();
+    tmp->var_base = var_base;
+    tmp->next = var_list_base;
+    return tmp;
+}
+
+var_list *append_by_var_list(var_list *back_var_list, var_list *var_list_base){  // 拼凑两个var_list
+    var_list *start = back_var_list;
+    while(1){
+        if(start->next == NULL){  // to the last
+            break;
+        }
+        start = start->next;
+    }
+    start->next = var_list_base;
+    return back_var_list;
+}
+
+var_list *free_var_list(var_list *var_list_base){  // free one var_list[FILO]
+    var_list *tmp = var_list_base->next;
+    if(tmp==NULL){
+        return var_list_base;
+    }
+    free(var_list_base);
+    return tmp;
+}
+
+int get_var_list_len(var_list *var_base){
+    var_list *start = var_base;
+    int tmp = 0;
+    while(1){
+        if(start->next == NULL){
+            break;
+        }
+        start = start->next;
+        tmp += 1;
+    }
+    return tmp;
+}
+
+var *find_var(var_list *var_base,int from, char *name){  // find var by func get_var in var_list[iter to find]
+    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;
+    }
+    // printf("name = %s, from = %d, address = %x\n", name, from, start->var_base);
+    while (1)
+    {
+        return_var = get_var(name, start->var_base);
+        if((return_var == NULL) && (start->next == NULL)){  // don't get the var and not next
+            return NULL;
+        }
+        else if((return_var == NULL) && (start->next != NULL)){  // don't get the var but can next
+            start = start->next;
+            continue;
+        }
+        // printf("find on name = %s, from = %d, address = %x\n", name, from, start->var_base);
+        return return_var;  //get var success can or can't next
+    }
+}
+
+void add_var(var_list *var_base,int from, char *name, GWARF_value value){  // add var by func append_var in var_list[iter to find]
+    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;
+    }
+    // printf("----var add address = %d----\n", start);
+    append_var(name, value, start->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节点
+    tmp = start;  // 记录base节点
+    while(1){  // 复制var_list链
+        if((start == NULL) || (start->next == NULL)){
+            break;
+        }
+        puts("F1");
+        var_list *next_tmp = malloc(sizeof(start->next));
+        memcpy(next_tmp, start->next, sizeof(start->next));  // 复制到新的地方
+        start->next = next_tmp;  // 应用新的地方
+        start = start->next;
+    }
+    return tmp;
+}

paser/gwarf_yacc.y

@@ -1,7 +1,7 @@
 %{
     #include<stdio.h>
     #include"lex.yy.c"
-    #include"../gwarf_interpreter/interprete.h"
+    #include"../gwarf_interpreter/interpreter.h"
     #define yylex yylex_self
     extern int yylex (void);
     // 此处声明：定义的token：INDENTA不会在yacc中被使用，但将会在lex中被使用

paser/y.tab.c

@@ -70,7 +70,7 @@
 
     #include<stdio.h>
     #include"lex.yy.c"
-    #include"../gwarf_interpreter/interprete.h"
+    #include"../gwarf_interpreter/interpreter.h"
     #define yylex yylex_self
     extern int yylex (void);
     // 此处声明：定义的token：INDENTA不会在yacc中被使用，但将会在lex中被使用