可以生成语法树，并修复了if使用break无法跳出rego的问题

README.md

@@ -84,20 +84,22 @@ return x n  函数返回值x，返回n层
 * 疑似bug：``a.__iter__.__next__``会出现内存错误, 已经修复，原因是: 内置函数无self属性
 * ``a.__iter__().__next__()``会出现解析错误, 已经修复，调整了``.``运算符和``call_back``为同级优先级
 * 解决了object的``__value__``无法调用的问题：原因是注册函数的时候使用了数字而不是枚举体[现在，使用``{__value__func, 1}``取代了数字``{3, 1}``]
+* 可以生成语法树，输出文件到./log下
 ## GWARF计划
 * 类型转换(list, str, int之间的转换)
 * 魔法方法：``__eq__(用于特殊赋值)，__int__，__str__，__double__，__repo__，__list__，__tuple__，__dict__，__key__，__in__``
 * 魔法属性：``__name__，__id__``
-* 数据类型：``set()，link()``
+* 数据类型：``set()，link()，file()``
 * 内置类：``range,exp(列表推导试)``
-* 内置函数：``print, input, exit``
+* 内置函数：``print(), input(), exit()[报出错误ExitException(Systemctl)], type(), isinherited()[A类是否继承B类], isinstance()[A object是否为B的实例(不检查继承关系)]``
 * @装饰器语法
 * 内存控制：控制``var``链表，控制``哈希表``，控制``var_list``
 * 多重继承优化：``super().__init__()``
 * 抽象类和接口类(纯抽象类)
 * goto语句
 * 宏定义
-* 生成语法树
 * yield生成器和列表推导试
+* 模块化导入，读取``__init__.gwf``文件
+* 优化错误输出[行号]
 ## 关于GWARF
-最后更新时间 ： 2020年05月08日 广州
+最后更新时间 ： 2020年05月09日 广州

demo/2.gwf

@@ -1,10 +1,3 @@
-if(True){
-print("I am True")
-}
-else{
-print("I am False")
-}
-
 a = 0
 while(a < 3){
 a++

demo/6.gwf

@@ -1,12 +1,2 @@
-class a()
-{
-def run(self,b=3,c=10)
-{
-b * c
-return self;
-}
-}
-q = a()
-z = q.__value__()
-print(z)
-
+20 * 30
+20 * 30

demo/7.gwf

@@ -0,0 +1,43 @@
+if(True)
+{
+print("I am True")
+}
+else
+{
+print("I am Not True")
+}
+
+if(True)
+{
+print("I am True")
+rewent
+print("I will print")
+}
+elif(False)
+{
+print("beacuse rewent, I can print")
+rego
+print("because rego, I can't print")
+}
+elif(False)
+{
+print("beacuse rego I can print")
+break
+}
+else
+{
+print("because break, I can't print")
+}
+
+if(False)
+{
+print("I am True")
+}
+elif(True)
+{
+print("I am True!")
+}
+else
+{
+print("I am Not True")
+}

gwarf.c

@@ -10,17 +10,19 @@
 #include "inter/statement.c"
 #include "inter/var.c"
 
+#include "inter/tree.c"
 #include "inter/interpreter.c"
 
 void do_exit(void);
 void setup();
 
 void setup(){
-    debug = fopen("./debug.log", "w");  // 设置debug的位置
-    status_log = fopen("./status.log", "w");  // 设置debug的位置
-    token_log = fopen("./token.log", "w");  // 设置debug的位置
-    token_info = fopen("./tokenINFO.log", "w");  // 设置debug的位置
-    inter_info = fopen("./interINFO.log", "w");  // 设置debug的位置
+    debug = fopen("./log/debug.log", "w");  // 设置debug的位置
+    status_log = fopen("./log/status.log", "w");  // 设置debug的位置
+    token_log = fopen("./log/token.log", "w");  // 设置debug的位置
+    token_info = fopen("./log/tokenINFO.log", "w");  // 设置debug的位置
+    inter_info = fopen("./log/interINFO.log", "w");  // 设置debug的位置
+    tree_info = fopen("./log/tree.log", "w");
 }
 
 void do_exit(void){
@@ -29,6 +31,7 @@ void do_exit(void){
     fclose(token_log);
     fclose(token_info);
     fclose(inter_info);
+    fclose(tree_info);
 }
 
 int main(int argc, char *argv[]){
@@ -46,6 +49,7 @@ int main(int argc, char *argv[]){
     
     login(the_var, global_inter);
     parser(file, global_inter);
+    traverse_tree(global_inter->global_code, 0);
     fprintf(inter_info, "----start run----\n");
     traverse_global(global_inter->global_code, the_var, global_inter);
     fprintf(inter_info, "code end...\n");

inter/interpreter.c

@@ -1027,7 +1027,7 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
             }
 
             // continued操作
-            if(value.u == code_continued){
+            else if(value.u == code_continued){
                 if(value.value.type != INT_value){
                     value.value.type = INT_value;
                     value.value.value.int_value = 0;
@@ -1044,7 +1044,7 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
             }
 
             // broken操作
-            if(value.u == code_broken){
+            else if(value.u == code_broken){
                 if(value.value.type != INT_value){
                     value.value.type = INT_value;
                     value.value.value.int_value = 0;
@@ -1060,9 +1060,12 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
 
             // rego操作
             // else层的rego和rewent是可以往上层遗传的[也就是else如果显式指定rego和rewent是会遗传的，但是如果是if或elif指定rego是不会遗传的]
-            if((value.u == code_rewent) || (value.u == code_rego)){
+            else if((value.u == code_rewent) || (value.u == code_rego)){
                 ;
             }
+            else{
+                error_space(value, to_break, value)
+            }
 
             break;  // else not next and don't need rego
         }
@@ -1106,7 +1109,7 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
                 }
                 
                 // continued操作 [设在在rewent和rego前面]
-                if(value.u == code_continued){
+                else if(value.u == code_continued){
                     if(value.value.type != INT_value){
                         value.value.type = INT_value;
                         value.value.value.int_value = 0;
@@ -1123,7 +1126,7 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
                 }
 
                 // broken操作
-                if(value.u == code_broken){
+                else if(value.u == code_broken){
                     if(value.value.type != INT_value){
                         value.value.type = INT_value;
                         value.value.value.int_value = 0;
@@ -1136,10 +1139,13 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
                 }
                 
                 // rego操作
-                if((value.u == code_rewent) || (value.u == code_rego)){
+                else if((value.u == code_rewent) || (value.u == code_rego)){
                     value.u = statement_end;  // 设置为正常语句
                     rego = true;
                 }
+                else{
+                    error_space(value, to_break, value)
+                }
 
                 // not restarted -> if is rego
                 if(!rego){
@@ -1153,6 +1159,7 @@ GWARF_result if_func(if_list *if_base, var_list *the_var, inter *global_inter){
         }
         start = start->next;
     }
+    to_break: 
     if((value.u == cycle_continue) || (value.u == cycle_restart) || (value.u == cycle_break)){  // if不处理也不计入层次 同break一样
         ;
     }
@@ -1225,7 +1232,7 @@ GWARF_result for_func(statement *the_statement, var_list *the_var, inter *global
         }
 
         // restart操作
-        if((value.u == cycle_restart) || (value.u == code_restarted)){
+        else if((value.u == cycle_restart) || (value.u == code_restarted)){
             if(value.value.type != INT_value){
                 value.value.type = INT_value;
                 value.value.value.int_value = 0;
@@ -1241,10 +1248,12 @@ GWARF_result for_func(statement *the_statement, var_list *the_var, inter *global
                 break;
             }
         }
-
-        if(value.u == rego){  // rewent认为是正常执行
+        else if(value.u == rego){  // rewent认为是正常执行
             do_else = false;
         }
+        else{
+            error_space(value, return_value, value);
+        }
     }
     if(do_else){
         GWARF_result tmp_result = traverse(the_statement->code.for_cycle.else_do, the_var, false, global_inter);
@@ -1425,7 +1434,7 @@ GWARF_result block_func(statement *the_statement, var_list *the_var, inter *glob
     }
     
     // continued操作
-    if(value.u == code_continued){
+    else if(value.u == code_continued){
         if(value.value.type != INT_value){
             value.value.type = INT_value;
             value.value.value.int_value = 0;
@@ -1441,7 +1450,7 @@ GWARF_result block_func(statement *the_statement, var_list *the_var, inter *glob
     }
 
     // broken操作
-    if(value.u == code_broken){
+    else if(value.u == code_broken){
         if(value.value.type != INT_value){
             value.value.type = INT_value;
             value.value.value.int_value = 0;
@@ -1503,7 +1512,7 @@ GWARF_result forin_func(statement *the_statement, var_list *the_var, inter *glob
         }
 
         // continue的操作
-        if((value.u == cycle_continue) || (value.u == code_continued)){
+        else if((value.u == cycle_continue) || (value.u == code_continued)){
             if(value.value.type != INT_value){
                 value.value.type = INT_value;
                 value.value.value.int_value = 0;
@@ -1520,7 +1529,7 @@ GWARF_result forin_func(statement *the_statement, var_list *the_var, inter *glob
         }
 
         // restart的操作
-        if((value.u == cycle_restart) || (value.u == code_restarted)){
+        else if((value.u == cycle_restart) || (value.u == code_restarted)){
             if(value.value.type != INT_value){
                 value.value.type = INT_value;
                 value.value.value.int_value = 0;
@@ -1535,10 +1544,12 @@ GWARF_result forin_func(statement *the_statement, var_list *the_var, inter *glob
                 break;
             }
         }
-
-        if(value.u == rego){  // rewent认为是正常执行
+        else if(value.u == rego){  // rewent认为是正常执行
             do_else = false;
         }
+        else{
+            error_space(value, return_value, value);
+        }
     }
     if(do_else){
         GWARF_result tmp_result = traverse(the_statement->code.for_in_cycle.else_do, the_var, false, global_inter);
@@ -1595,7 +1606,7 @@ GWARF_result while_func(statement *the_statement, var_list *the_var, inter *glob
         }
 
         // continue的操作
-        if((value.u == cycle_continue) || (value.u == code_continued)){
+        else if((value.u == cycle_continue) || (value.u == code_continued)){
             if(value.value.type != INT_value){
                 value.value.type = INT_value;
                 value.value.value.int_value = 0;
@@ -1612,7 +1623,7 @@ GWARF_result while_func(statement *the_statement, var_list *the_var, inter *glob
         }
 
         // restart的操作
-        if((value.u == cycle_restart) || (value.u == code_restarted)){
+        else if((value.u == cycle_restart) || (value.u == code_restarted)){
             if(value.value.type != INT_value){
                 value.value.type = INT_value;
                 value.value.value.int_value = 0;
@@ -1627,10 +1638,12 @@ GWARF_result while_func(statement *the_statement, var_list *the_var, inter *glob
                 break;
             }
         }
-
-        if(value.u == rego){  // rewent认为是正常执行
+        else if(value.u == rego){  // rewent认为是正常执行
             do_else = false;
         }
+        else{
+            error_space(value, return_value, value);
+        }
     }
     if(do_else){
         GWARF_result tmp_result = traverse(the_statement->code.while_cycle.else_do, the_var, false, global_inter);

inter/interpreter.h

@@ -781,4 +781,9 @@ GWARF_result traverse_get_value(statement *, var_list *, var_list *,inter *);
 inter *get_inter();
 void login(var_list *the_var, inter *global_inter);
 
+void traverse_tree(statement *the_statement, int lv);
+void print_statement(statement *the_statement, int lv);
+void parameter_tree(parameter *the_parameter, int lv);
+void if_tree(if_list *the_branch, int lv);
+
 #endif

inter/tree.c

@@ -0,0 +1,379 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "interpreter.h"
+
+#define print_lv(lv) \
+for(int i=0;i<lv;i++){ \
+fprintf(tree_info, "    "); \
+} \
+fprintf(tree_info, "%d-", lv);
+
+#define print_t(str, t_statement) \
+do{ \
+print_lv(lv + 1); \
+fprintf(tree_info, str); \
+traverse_tree(t_statement, lv + 2); \
+}while(0);
+
+#define print_p(str, t_statement) \
+do{ \
+print_lv(lv + 1); \
+fprintf(tree_info, str); \
+parameter_tree(t_statement, lv + 2); \
+}while(0);
+
+#define print_i(str, t_statement) \
+do{ \
+print_lv(lv + 1); \
+fprintf(tree_info, str); \
+if_tree(t_statement, lv + 2); \
+}while(0);
+
+void print_statement(statement *the_statement, int lv){  // read the statement list with case to run by func
+    print_lv(lv);
+    switch (the_statement->type)
+    {
+        case operation:  // 表达式运算
+            fprintf(tree_info, "[operation](type = %d)\n", the_statement->code.operation.type);
+
+            print_t("left\n", the_statement->code.operation.left_exp);
+            print_t("right\n", the_statement->code.operation.left_exp);
+            break;
+        case chose_exp:{
+            fprintf(tree_info, "[chose_exp]\n");
+
+            print_t("condition\n", the_statement->code.chose_exp.condition);
+            print_t("true_do\n", the_statement->code.chose_exp.true_do);
+            print_t("false_do\n", the_statement->code.chose_exp.false_do);
+            break;
+        }
+        case call:
+            fprintf(tree_info, "[call]\n");
+
+            print_t("func\n", the_statement->code.call.func);
+
+            print_p("parameter_list\n", the_statement->code.call.parameter_list);
+            break;
+        case while_cycle:
+            fprintf(tree_info, "[while_cycle]%s\n",  (the_statement->code.while_cycle.first_do ? "(do ... while)" : "(while ... )"));
+
+            print_t("condition\n", the_statement->code.while_cycle.condition);
+            print_t("done\n", the_statement->code.while_cycle.done);
+            print_t("else_do\n", the_statement->code.while_cycle.else_do);
+            break;
+        case for_cycle:
+            fprintf(tree_info, "[for_cycle]\n");
+
+            print_t("condition\n", the_statement->code.for_cycle.condition);
+            print_t("first\n", the_statement->code.for_cycle.first);
+            print_t("after\n", the_statement->code.for_cycle.after);
+            print_t("done\n", the_statement->code.for_cycle.done);
+            print_t("else_do\n", the_statement->code.for_cycle.else_do);
+            break;
+        case for_in_cycle:
+            fprintf(tree_info, "[for in ]\n");
+
+            print_t("var\n", the_statement->code.for_in_cycle.var);
+            print_t("iter\n", the_statement->code.for_in_cycle.iter);
+            print_t("done\n", the_statement->code.for_in_cycle.done);
+            print_t("else_do\n", the_statement->code.for_in_cycle.else_do);
+            break;
+        case if_branch:
+            fprintf(tree_info, "[if branch]\n");
+            
+            print_i("done", the_statement->code.if_branch.done)
+            break;
+        case pack_eq:
+            fprintf(tree_info, "[pack_eq]\n");
+
+            print_p("left\n", the_statement->code.pack_eq.left);
+            print_p("right\n", the_statement->code.pack_eq.right);
+            break;
+        case base_value:
+            fprintf(tree_info, "[base_value](type = %d)(token = %d)(value = ", the_statement->code.base_value.value.type, the_statement->code.base_value.value.lock_token);
+            switch (the_statement->code.base_value.value.type)
+            {
+            case NULL_value:
+                fprintf(tree_info, "<None>[None show]");
+                break;
+            case INT_value:
+                fprintf(tree_info, "%d[int not show]", the_statement->code.base_value.value.value.int_value);
+                break;
+            case NUMBER_value:
+                fprintf(tree_info, "%f[double not show]", the_statement->code.base_value.value.value.double_value);
+                break;
+            case STRING_value:
+                fprintf(tree_info, "'%s'[str not show]", the_statement->code.base_value.value.value.string);
+                break;
+            case FUNC_value:
+                fprintf(tree_info, "%x[func show]", the_statement->code.base_value.value.value.func_value);
+                break;
+            case CLASS_value:
+                fprintf(tree_info, "%x[class show]", the_statement->code.base_value.value.value.class_value);
+                break;
+            case OBJECT_value:
+                fprintf(tree_info, "%x[object show]", the_statement->code.base_value.value.value.object_value);
+                break;
+            case LIST_value:
+                fprintf(tree_info, "%x[list not show]", the_statement->code.base_value.value.value.list_value);
+                break;
+            case DICT_value:
+                fprintf(tree_info, "%x[list not show]", the_statement->code.base_value.value.value.dict_value);
+                break;
+            default:
+                fprintf(tree_info, "WRONG!!!");
+                break;
+            }
+            fprintf(tree_info, ")\n");
+            break;
+        case base_tuple:{
+            fprintf(tree_info, "[base_tuple]\n");
+
+            print_p("value\n", the_statement->code.base_tuple.value);
+            break;
+        }
+        case base_list:{
+            fprintf(tree_info, "[base_list]\n");
+
+            print_p("value\n", the_statement->code.base_list.value);
+            break;
+        }
+        case base_dict:{
+            fprintf(tree_info, "[base_dict]\n");
+
+            print_p("value\n", the_statement->code.base_dict.value);
+            break;
+        }
+        case slice:{
+            fprintf(tree_info, "[slice]\n");
+
+            print_t("base_var\n", the_statement->code.slice.base_var);
+            print_p("value\n", the_statement->code.slice.value);
+            break;
+        }
+        case base_var:{  // 访问变量
+            fprintf(tree_info, "[base_var](name = %s)(token = %d)\n", the_statement->code.base_var.var_name, the_statement->code.base_var.lock_token);
+
+            print_t("from\n", the_statement->code.base_var.from);
+            break;
+        }
+        case base_svar:{
+            fprintf(tree_info, "[base_svar](name = %s)\n", the_statement->code.base_svar.lock_token);
+
+            print_t("var\n", the_statement->code.base_svar.var);
+            print_t("from\n", the_statement->code.base_svar.from);
+            break;
+        }
+        case point:{
+            fprintf(tree_info, "[point]\n");
+
+            print_t("base\n", the_statement->code.point.base_var);
+            print_t("child\n", the_statement->code.point.child_var);
+            break;
+        }
+        case down:{
+            fprintf(tree_info, "[down]\n");
+
+            print_t("base_var\n", the_statement->code.down.base_var);
+            print_p("child_var\n", the_statement->code.down.child_var);
+            break;
+        }
+        case def:{
+            fprintf(tree_info, "[def](type = %d, is_inline)\n", the_statement->code.def.type, the_statement->code.def.is_inline);
+
+            print_t("var(name)\n", the_statement->code.def.var);
+            print_p("parameter_list\n", the_statement->code.def.parameter_list);
+            print_t("setup\n", the_statement->code.def.setup);
+            print_t("done\n", the_statement->code.def.done);
+            break;
+        }
+        case lambda_func:{
+            fprintf(tree_info, "[lambda_func]\n");
+
+            print_p("parameter_list\n", the_statement->code.lambda_func.parameter_list);
+            print_t("done\n", the_statement->code.lambda_func.done);
+            break;
+        }
+        case set_class:{
+            fprintf(tree_info, "[set_class]\n");
+
+            print_t("var(name)\n", the_statement->code.set_class.var);
+            print_p("father_list\n", the_statement->code.set_class.father_list);
+            print_t("done\n", the_statement->code.set_class.done);
+            break;
+        }
+        case break_cycle:
+            fprintf(tree_info, "[break_cycle]\n");
+            print_t("times\n", the_statement->code.break_cycle.times);
+            break;
+        case broken:
+            fprintf(tree_info, "[broken]\n");
+            print_t("times\n", the_statement->code.broken.times);
+            break;
+        case continue_cycle:
+            fprintf(tree_info, "[continue_cycle]\n");
+            print_t("times\n", the_statement->code.continue_cycle.times);
+            break;
+        case continued:
+            fprintf(tree_info, "[continued]\n");
+            print_t("times\n", the_statement->code.continued.times);
+            break;
+        case restart:
+            fprintf(tree_info, "[restart]\n");
+            print_t("times\n", the_statement->code.restart.times);
+            break;
+        case restarted:
+            fprintf(tree_info, "[restarted]\n");
+            print_t("times\n", the_statement->code.restarted.times);
+            break;
+        case return_code:
+            fprintf(tree_info, "[return_code]\n");
+            print_t("value\n", the_statement->code.return_code.value);
+            print_t("times\n", the_statement->code.return_code.times);
+            break;
+        case rewent:
+            fprintf(tree_info, "[rewent]\n");
+            break;
+        case rego:
+            fprintf(tree_info, "[rego]\n");
+            break;
+        case set_default:{
+            fprintf(tree_info, "[set_default] [var(name) = %s]\n", the_statement->code.set_default.name);
+            print_t("times\n", the_statement->code.set_default.times);
+            break;
+        }
+        case set_global:{
+            fprintf(tree_info, "[set_global] [var(name) = %s]\n", the_statement->code.set_global.name);
+            break;
+        }
+        case set_nonlocal:{
+            fprintf(tree_info, "[set_nonlocal] [var(name) = %s]\n", the_statement->code.set_nonlocal.name);
+            break;
+        }
+        case code_block:
+            fprintf(tree_info, "[code_block]\n");
+            print_t("done\n", the_statement->code.code_block.done);
+            break;
+        case try_code:
+            fprintf(tree_info, "[try_code]\n");
+
+            print_t("try\n", the_statement->code.try_code.try);
+            print_t("except\n", the_statement->code.try_code.except);
+            print_t("var\n", the_statement->code.try_code.var);
+            print_t("else_do\n", the_statement->code.try_code.else_do);
+            print_t("finally_do\n", the_statement->code.try_code.finally_do);
+            break;
+        case raise_e:
+            fprintf(tree_info, "[raise_e]\n");
+
+            print_t("info\n", the_statement->code.raise_e.info);
+            print_t("done\n", the_statement->code.raise_e.done);
+            break;
+        case throw_e:
+            fprintf(tree_info, "[throw_e]\n");
+
+            print_t("done\n", the_statement->code.throw_e.done);
+            break;
+        case import_class:  // import xxx as xxx 语句
+            fprintf(tree_info, "[import_class]\n");
+
+            print_t("file\n", the_statement->code.import_class.file);
+            print_t("var\n", the_statement->code.import_class.var);
+            break;
+        case include_import:  // include xxx
+            fprintf(tree_info, "[include_import]\n");
+
+            print_t("file\n", the_statement->code.include_import.file);
+            break;
+        case assert_e:
+            fprintf(tree_info, "[assert_e]\n");
+
+            print_t("condition\n", the_statement->code.assert_e.condition);
+            print_t("info\n", the_statement->code.assert_e.info);
+            break;
+        default:
+            fprintf(tree_info, "[start]\n");
+            break;
+    }
+    return_result: return;
+}
+
+void traverse_tree(statement *the_statement, int lv){
+    statement *tmp = the_statement;
+    if(the_statement == NULL){
+        print_lv(lv);
+        fprintf(tree_info, "NULL\n");
+        goto return_back;
+    }
+    else{
+    }
+    while(1){
+        if(tmp == NULL){
+            break;
+        }
+        print_statement(tmp, lv);
+        tmp = tmp->next;
+    }
+    return_back: return;
+}
+
+void parameter_tree(parameter *the_parameter, int lv){
+    parameter *tmp = the_parameter;
+    if(the_parameter == NULL){
+        print_lv(lv);
+        fprintf(tree_info, "NULL\n");
+        goto return_back;
+    }
+    while(1){
+        if(tmp == NULL){
+            break;
+        }
+        print_lv(lv);
+        fprintf(tree_info, "[parameter]\n");
+        switch (tmp->type)
+        {
+        case only_value:
+            print_t("value\n", tmp->u.value);
+            break;
+        case put_args:
+            fprintf(tree_info, "[put_args](parameter)\n");
+            print_t("value\n", tmp->u.value);
+            break;
+        case put_kwargs:
+            fprintf(tree_info, "[put_kwargs](parameter)\n");
+            print_t("value\n", tmp->u.value);
+            break;
+        case name_value:
+            fprintf(tree_info, "[name_value](parameter)\n");
+            print_t("value\n", tmp->u.value);
+            print_t("var\n", tmp->u.var);
+            break;
+        default:
+            break;
+        }
+        tmp = tmp->next;
+    }
+    return_back: return;
+}
+
+void if_tree(if_list *the_branch, int lv){
+    if_list *tmp = the_branch;
+    if(the_branch == NULL){
+        print_lv(lv);
+        fprintf(tree_info, "NULL\n");
+        goto return_back;
+    }
+    while(1){
+        if(tmp == NULL){
+            break;
+        }
+        print_lv(lv);
+        fprintf(tree_info, "[if node]\n");
+        print_t("condition\n", tmp->condition);
+        print_t("done\n", tmp->done);
+        tmp = tmp->next;
+    }
+    return_back: return;
+}

paser/paser.h

@@ -7,7 +7,7 @@
                               status.not_match_call=false,status.match_list=false,status.match_dict=false, \
                               status.is_left=true,status.is_peq=false,status.is_for=false, \
                               status.dict_to_enter=false,status.ignore_enter=false,status.is_slice=false,status.is_args=false;}
-FILE *debug = NULL, *status_log = NULL, *token_log = NULL, *token_info = NULL, *inter_info = NULL;
+FILE *debug = NULL, *status_log = NULL, *token_log = NULL, *token_info = NULL, *inter_info = NULL, *tree_info = NULL;
 
 typedef struct p_status
 {