X-Git-Url: http://nitlanguage.org diff --git a/c_src/nit__flow.sep.1.c b/c_src/nit__flow.sep.1.c new file mode 100644 index 0000000..e561cf8 --- /dev/null +++ b/c_src/nit__flow.sep.1.c @@ -0,0 +1,3214 @@ +#include "nit__flow.sep.0.h" +/* method flow#ToolContext#flow_phase for (self: ToolContext): Phase */ +val* nit__flow___ToolContext___flow_phase(val* self) { +val* var /* : Phase */; +val* var1 /* : Phase */; +var1 = self->attrs[COLOR_nit__flow__ToolContext___flow_phase].val; /* _flow_phase on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flow_phase"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 23); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowPhase#process_npropdef for (self: FlowPhase, APropdef) */ +void nit__flow___nit__flow__FlowPhase___nit__phase__Phase__process_npropdef(val* self, val* p0) { +val* var_npropdef /* var npropdef: APropdef */; +val* var /* : ToolContext */; +val* var2 /* : ToolContext */; +var_npropdef = p0; +{ +{ /* Inline phase#Phase#toolcontext (self) on */ +var2 = self->attrs[COLOR_nit__phase__Phase___toolcontext].val; /* _toolcontext on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__phase, 201); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +nit__flow___APropdef___do_flow(var_npropdef, var); /* Direct call flow#APropdef#do_flow on */ +} +RET_LABEL:; +} +/* method flow#FlowVisitor#current_flow_context for (self: FlowVisitor): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___current_flow_context(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +var1 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#current_flow_context= for (self: FlowVisitor, FlowContext) */ +void nit__flow___nit__flow__FlowVisitor___current_flow_context_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = p0; /* _current_flow_context on */ +RET_LABEL:; +} +/* method flow#FlowVisitor#toolcontext for (self: FlowVisitor): ToolContext */ +val* nit__flow___nit__flow__FlowVisitor___toolcontext(val* self) { +val* var /* : ToolContext */; +val* var1 /* : ToolContext */; +var1 = self->attrs[COLOR_nit__flow__FlowVisitor___toolcontext].val; /* _toolcontext on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 39); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#toolcontext= for (self: FlowVisitor, ToolContext) */ +void nit__flow___nit__flow__FlowVisitor___toolcontext_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowVisitor___toolcontext].val = p0; /* _toolcontext on */ +RET_LABEL:; +} +/* method flow#FlowVisitor#init for (self: FlowVisitor) */ +void nit__flow___nit__flow__FlowVisitor___standard__kernel__Object__init(val* self) { +val* var /* : Array[FlowContext] */; +val* var2 /* : Array[FlowContext] */; +val* var3 /* : FlowContext */; +val* var5 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : FlowContext */; +short int var9 /* : Bool */; +{ +((void (*)(val* self))(self->class->vft[COLOR_nit__flow___nit__flow__FlowVisitor___standard__kernel__Object__init]))(self) /* init on */; +} +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var2 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var, var3); /* Direct call array#Array#add on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var8 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +var9 = 1; +{ +{ /* Inline flow#FlowContext#is_start= (var6,var9) on */ +var6->attrs[COLOR_nit__flow__FlowContext___is_start].s = var9; /* _is_start on */ +RET_LABEL10:(void)0; +} +} +RET_LABEL:; +} +/* method flow#FlowVisitor#first for (self: FlowVisitor): nullable ANode */ +val* nit__flow___nit__flow__FlowVisitor___first(val* self) { +val* var /* : nullable ANode */; +val* var1 /* : nullable ANode */; +var1 = self->attrs[COLOR_nit__flow__FlowVisitor___first].val; /* _first on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#first= for (self: FlowVisitor, nullable ANode) */ +void nit__flow___nit__flow__FlowVisitor___first_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowVisitor___first].val = p0; /* _first on */ +RET_LABEL:; +} +/* method flow#FlowVisitor#visit for (self: FlowVisitor, ANode) */ +void nit__flow___nit__flow__FlowVisitor___nit__parser_nodes__Visitor__visit(val* self, val* p0) { +val* var_node /* var node: ANode */; +val* var /* : nullable ANode */; +val* var2 /* : nullable ANode */; +val* var3 /* : null */; +short int var4 /* : Bool */; +short int var5 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var7 /* : Bool */; +short int var9 /* : Bool */; +val* var11 /* : FlowContext */; +val* var13 /* : FlowContext */; +val* var14 /* : nullable ANode */; +val* var16 /* : nullable ANode */; +val* var17 /* : null */; +short int var18 /* : Bool */; +short int var19 /* : Bool */; +short int var21 /* : Bool */; +short int var23 /* : Bool */; +val* var24 /* : FlowContext */; +val* var26 /* : FlowContext */; +short int var28 /* : Bool */; +int cltype; +int idtype; +val* var29 /* : FlowContext */; +val* var31 /* : FlowContext */; +val* var_flow /* var flow: FlowContext */; +short int var33 /* : Bool */; +val* var34 /* : FlowContext */; +val* var36 /* : FlowContext */; +short int var37 /* : Bool */; +val* var_other39 /* var other: nullable Object */; +short int var40 /* : Bool */; +short int var41 /* : Bool */; +short int var_ /* var : Bool */; +val* var42 /* : FlowContext */; +val* var44 /* : FlowContext */; +short int var45 /* : Bool */; +short int var47 /* : Bool */; +short int var48 /* : Bool */; +val* var49 /* : FlowContext */; +val* var50 /* : FlowContext */; +val* var52 /* : FlowContext */; +static val* varonce; +val* var53 /* : String */; +char* var54 /* : NativeString */; +long var55 /* : Int */; +val* var56 /* : FlatString */; +val* var58 /* : nullable ANode */; +val* var60 /* : nullable ANode */; +short int var61 /* : Bool */; +short int var62 /* : Bool */; +short int var64 /* : Bool */; +short int var66 /* : Bool */; +var_node = p0; +{ +{ /* Inline flow#FlowVisitor#first (self) on */ +var2 = self->attrs[COLOR_nit__flow__FlowVisitor___first].val; /* _first on */ +var = var2; +RET_LABEL1:(void)0; +} +} +var3 = NULL; +if (var == NULL) { +var4 = 1; /* is null */ +} else { +var4 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var,var3) on */ +var_other = var3; +{ +{ /* Inline kernel#Object#is_same_instance (var,var_other) on */ +var9 = var == var_other; +var7 = var9; +goto RET_LABEL8; +RET_LABEL8:(void)0; +} +} +var5 = var7; +goto RET_LABEL6; +RET_LABEL6:(void)0; +} +var4 = var5; +} +if (var4){ +{ +{ /* Inline flow#FlowVisitor#first= (self,var_node) on */ +self->attrs[COLOR_nit__flow__FlowVisitor___first].val = var_node; /* _first on */ +RET_LABEL10:(void)0; +} +} +} else { +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var13 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node (var11) on */ +var16 = var11->attrs[COLOR_nit__flow__FlowContext___node].val; /* _node on */ +var14 = var16; +RET_LABEL15:(void)0; +} +} +var17 = NULL; +if (var14 == NULL) { +var18 = 1; /* is null */ +} else { +var18 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var14,var17) on */ +var_other = var17; +{ +{ /* Inline kernel#Object#is_same_instance (var14,var_other) on */ +var23 = var14 == var_other; +var21 = var23; +goto RET_LABEL22; +RET_LABEL22:(void)0; +} +} +var19 = var21; +goto RET_LABEL20; +RET_LABEL20:(void)0; +} +var18 = var19; +} +if (var18){ +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var26 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var24,var_node) on */ +var24->attrs[COLOR_nit__flow__FlowContext___node].val = var_node; /* _node on */ +RET_LABEL27:(void)0; +} +} +} else { +} +{ +((void (*)(val* self, val* p0))(var_node->class->vft[COLOR_nit__flow__ANode__accept_flow_visitor]))(var_node, self) /* accept_flow_visitor on */; +} +/* isa AExpr */ +cltype = type_nit__AExpr.color; +idtype = type_nit__AExpr.id; +if(cltype >= var_node->type->table_size) { +var28 = 0; +} else { +var28 = var_node->type->type_table[cltype] == idtype; +} +if (var28){ +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var31 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +var_flow = var29; +{ +{ /* Inline flow#AExpr#after_flow_context= (var_node,var_flow) on */ +var_node->attrs[COLOR_nit__flow__AExpr___after_flow_context].val = var_flow; /* _after_flow_context on */ +RET_LABEL32:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_true (var_flow) on */ +var36 = var_flow->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var36 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline kernel#Object#!= (var34,var_flow) on */ +var_other39 = var_flow; +{ +var40 = ((short int (*)(val* self, val* p0))(var34->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var34, var_other39) /* == on */; +} +var41 = !var40; +var37 = var41; +goto RET_LABEL38; +RET_LABEL38:(void)0; +} +} +var_ = var37; +if (var37){ +var33 = var_; +} else { +{ +{ /* Inline flow#FlowContext#when_false (var_flow) on */ +var44 = var_flow->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var42 = var44; +RET_LABEL43:(void)0; +} +} +{ +{ /* Inline kernel#Object#!= (var42,var_flow) on */ +var_other39 = var_flow; +{ +var47 = ((short int (*)(val* self, val* p0))(var42->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var42, var_other39) /* == on */; +} +var48 = !var47; +var45 = var48; +goto RET_LABEL46; +RET_LABEL46:(void)0; +} +} +var33 = var45; +} +if (var33){ +{ +var49 = nit__flow___nit__flow__FlowVisitor___make_sub_flow(self); +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var52 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var52 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var50 = var52; +RET_LABEL51:(void)0; +} +} +if (varonce) { +var53 = varonce; +} else { +var54 = "AUTOSUB"; +var55 = 7; +var56 = standard___standard__NativeString___to_s_with_length(var54, var55); +var53 = var56; +varonce = var53; +} +{ +{ /* Inline flow#FlowContext#name= (var50,var53) on */ +var50->attrs[COLOR_nit__flow__FlowContext___name].val = var53; /* _name on */ +RET_LABEL57:(void)0; +} +} +} else { +} +} else { +} +{ +{ /* Inline flow#FlowVisitor#first (self) on */ +var60 = self->attrs[COLOR_nit__flow__FlowVisitor___first].val; /* _first on */ +var58 = var60; +RET_LABEL59:(void)0; +} +} +if (var58 == NULL) { +var61 = 0; /* cannot be null */ +} else { +{ /* Inline kernel#Object#== (var58,var_node) on */ +var_other = var_node; +{ +{ /* Inline kernel#Object#is_same_instance (var58,var_other) on */ +var66 = var58 == var_other; +var64 = var66; +goto RET_LABEL65; +RET_LABEL65:(void)0; +} +} +var62 = var64; +goto RET_LABEL63; +RET_LABEL63:(void)0; +} +var61 = var62; +} +if (var61){ +} else { +} +RET_LABEL:; +} +/* method flow#FlowVisitor#visit_expr for (self: FlowVisitor, AExpr): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___visit_expr(val* self, val* p0) { +val* var /* : FlowContext */; +val* var_node /* var node: AExpr */; +val* var1 /* : nullable FlowContext */; +val* var3 /* : nullable FlowContext */; +var_node = p0; +{ +nit___nit__Visitor___enter_visit(self, var_node); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#AExpr#after_flow_context (var_node) on */ +var3 = var_node->attrs[COLOR_nit__flow__AExpr___after_flow_context].val; /* _after_flow_context on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Cast failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 73); +show_backtrace(1); +} +var = var1; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#flows for (self: FlowVisitor): Array[FlowContext] */ +val* nit__flow___nit__flow__FlowVisitor___flows(val* self) { +val* var /* : Array[FlowContext] */; +val* var1 /* : Array[FlowContext] */; +var1 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#make_sub_flow for (self: FlowVisitor): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___make_sub_flow(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +val* var_flow /* var flow: FlowContext */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +val* var6 /* : nullable ANode */; +val* var8 /* : nullable ANode */; +val* var10 /* : FlowContext */; +val* var12 /* : FlowContext */; +var1 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var1) on */ +RET_LABEL2:(void)0; +} +} +var_flow = var1; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var3, var_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var8 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_flow,var6) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var6; /* _node on */ +RET_LABEL9:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var12 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var12 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_flow, var10); /* Direct call flow#FlowContext#add_previous on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (self,var_flow) on */ +self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_flow; /* _current_flow_context on */ +RET_LABEL13:(void)0; +} +} +var = var_flow; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#make_merge_flow for (self: FlowVisitor, FlowContext, FlowContext): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___make_merge_flow(val* self, val* p0, val* p1) { +val* var /* : FlowContext */; +val* var_flow1 /* var flow1: FlowContext */; +val* var_flow2 /* var flow2: FlowContext */; +val* var1 /* : FlowContext */; +val* var_flow /* var flow: FlowContext */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +val* var6 /* : nullable ANode */; +val* var8 /* : nullable ANode */; +var_flow1 = p0; +var_flow2 = p1; +var1 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var1) on */ +RET_LABEL2:(void)0; +} +} +var_flow = var1; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var3, var_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var8 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_flow,var6) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var6; /* _node on */ +RET_LABEL9:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_flow, var_flow1); /* Direct call flow#FlowContext#add_previous on */ +} +{ +nit___nit__FlowContext___add_previous(var_flow, var_flow2); /* Direct call flow#FlowContext#add_previous on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (self,var_flow) on */ +self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_flow; /* _current_flow_context on */ +RET_LABEL10:(void)0; +} +} +var = var_flow; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#make_true_false_flow for (self: FlowVisitor, FlowContext, FlowContext): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___make_true_false_flow(val* self, val* p0, val* p1) { +val* var /* : FlowContext */; +val* var_true_flow /* var true_flow: FlowContext */; +val* var_false_flow /* var false_flow: FlowContext */; +val* var1 /* : FlowContext */; +val* var_flow /* var flow: FlowContext */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +val* var6 /* : nullable ANode */; +val* var8 /* : nullable ANode */; +var_true_flow = p0; +var_false_flow = p1; +var1 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var1) on */ +RET_LABEL2:(void)0; +} +} +var_flow = var1; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var3, var_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var8 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_flow,var6) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var6; /* _node on */ +RET_LABEL9:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_flow, var_true_flow); /* Direct call flow#FlowContext#add_previous on */ +} +{ +nit___nit__FlowContext___add_previous(var_flow, var_false_flow); /* Direct call flow#FlowContext#add_previous on */ +} +{ +{ /* Inline flow#FlowContext#when_true= (var_flow,var_true_flow) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___when_true].val = var_true_flow; /* _when_true on */ +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_false= (var_flow,var_false_flow) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___when_false].val = var_false_flow; /* _when_false on */ +RET_LABEL11:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (self,var_flow) on */ +self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_flow; /* _current_flow_context on */ +RET_LABEL12:(void)0; +} +} +var = var_flow; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#make_sub_true_false_flow for (self: FlowVisitor): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___make_sub_true_false_flow(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +val* var3 /* : FlowContext */; +val* var_orig_flow /* var orig_flow: FlowContext */; +val* var4 /* : FlowContext */; +val* var_true_flow /* var true_flow: FlowContext */; +val* var6 /* : Array[FlowContext] */; +val* var8 /* : Array[FlowContext] */; +val* var9 /* : nullable ANode */; +val* var11 /* : nullable ANode */; +static val* varonce; +val* var13 /* : String */; +char* var14 /* : NativeString */; +long var15 /* : Int */; +val* var16 /* : FlatString */; +val* var18 /* : FlowContext */; +val* var_false_flow /* var false_flow: FlowContext */; +val* var20 /* : Array[FlowContext] */; +val* var22 /* : Array[FlowContext] */; +val* var23 /* : nullable ANode */; +val* var25 /* : nullable ANode */; +static val* varonce27; +val* var28 /* : String */; +char* var29 /* : NativeString */; +long var30 /* : Int */; +val* var31 /* : FlatString */; +val* var33 /* : FlowContext */; +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var3 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var3 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var1 = var3; +RET_LABEL2:(void)0; +} +} +var_orig_flow = var1; +var4 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var4) on */ +RET_LABEL5:(void)0; +} +} +var_true_flow = var4; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var8 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var6, var_true_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var11 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_true_flow,var9) on */ +var_true_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var9; /* _node on */ +RET_LABEL12:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_true_flow, var_orig_flow); /* Direct call flow#FlowContext#add_previous on */ +} +if (varonce) { +var13 = varonce; +} else { +var14 = "TRUE"; +var15 = 4; +var16 = standard___standard__NativeString___to_s_with_length(var14, var15); +var13 = var16; +varonce = var13; +} +{ +{ /* Inline flow#FlowContext#name= (var_true_flow,var13) on */ +var_true_flow->attrs[COLOR_nit__flow__FlowContext___name].val = var13; /* _name on */ +RET_LABEL17:(void)0; +} +} +var18 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var18) on */ +RET_LABEL19:(void)0; +} +} +var_false_flow = var18; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var22 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var22 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var20 = var22; +RET_LABEL21:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var20, var_false_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var25 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var23 = var25; +RET_LABEL24:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_false_flow,var23) on */ +var_false_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var23; /* _node on */ +RET_LABEL26:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_false_flow, var_orig_flow); /* Direct call flow#FlowContext#add_previous on */ +} +if (varonce27) { +var28 = varonce27; +} else { +var29 = "FALSE"; +var30 = 5; +var31 = standard___standard__NativeString___to_s_with_length(var29, var30); +var28 = var31; +varonce27 = var28; +} +{ +{ /* Inline flow#FlowContext#name= (var_false_flow,var28) on */ +var_false_flow->attrs[COLOR_nit__flow__FlowContext___name].val = var28; /* _name on */ +RET_LABEL32:(void)0; +} +} +{ +var33 = nit__flow___nit__flow__FlowVisitor___make_true_false_flow(self, var_true_flow, var_false_flow); +} +var = var33; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#make_unreachable_flow for (self: FlowVisitor): FlowContext */ +val* nit__flow___nit__flow__FlowVisitor___make_unreachable_flow(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +val* var_flow /* var flow: FlowContext */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +val* var6 /* : nullable ANode */; +val* var8 /* : nullable ANode */; +val* var10 /* : FlowContext */; +val* var12 /* : FlowContext */; +short int var13 /* : Bool */; +var1 = NEW_nit__FlowContext(&type_nit__FlowContext); +{ +{ /* Inline kernel#Object#init (var1) on */ +RET_LABEL2:(void)0; +} +} +var_flow = var1; +{ +{ /* Inline flow#FlowVisitor#flows (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowVisitor___flows].val; /* _flows on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _flows"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 76); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var3, var_flow); /* Direct call array#Array#add on */ +} +{ +{ /* Inline parser_nodes#Visitor#current_node (self) on */ +var8 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on */ +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#node= (var_flow,var6) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___node].val = var6; /* _node on */ +RET_LABEL9:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var12 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var12 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +nit___nit__FlowContext___add_previous(var_flow, var10); /* Direct call flow#FlowContext#add_previous on */ +} +var13 = 1; +{ +{ /* Inline flow#FlowContext#is_marked_unreachable= (var_flow,var13) on */ +var_flow->attrs[COLOR_nit__flow__FlowContext___is_marked_unreachable].s = var13; /* _is_marked_unreachable on */ +RET_LABEL14:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (self,var_flow) on */ +self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_flow; /* _current_flow_context on */ +RET_LABEL15:(void)0; +} +} +var = var_flow; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowVisitor#merge_continues_to for (self: FlowVisitor, FlowContext, nullable EscapeMark) */ +void nit__flow___nit__flow__FlowVisitor___merge_continues_to(val* self, val* p0, val* p1) { +val* var_before_loop /* var before_loop: FlowContext */; +val* var_escapemark /* var escapemark: nullable EscapeMark */; +val* var /* : null */; +short int var1 /* : Bool */; +short int var2 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var4 /* : Bool */; +short int var6 /* : Bool */; +val* var7 /* : Array[AEscapeExpr] */; +val* var9 /* : Array[AEscapeExpr] */; +val* var_ /* var : Array[AEscapeExpr] */; +val* var10 /* : ArrayIterator[nullable Object] */; +val* var_11 /* var : ArrayIterator[AEscapeExpr] */; +short int var12 /* : Bool */; +val* var13 /* : nullable Object */; +val* var_b /* var b: AEscapeExpr */; +val* var14 /* : nullable FlowContext */; +val* var_before /* var before: nullable FlowContext */; +val* var15 /* : null */; +short int var16 /* : Bool */; +short int var17 /* : Bool */; +short int var19 /* : Bool */; +short int var21 /* : Bool */; +var_before_loop = p0; +var_escapemark = p1; +var = NULL; +if (var_escapemark == NULL) { +var1 = 1; /* is null */ +} else { +var1 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_escapemark,var) on */ +var_other = var; +{ +{ /* Inline kernel#Object#is_same_instance (var_escapemark,var_other) on */ +var6 = var_escapemark == var_other; +var4 = var6; +goto RET_LABEL5; +RET_LABEL5:(void)0; +} +} +var2 = var4; +goto RET_LABEL3; +RET_LABEL3:(void)0; +} +var1 = var2; +} +if (var1){ +goto RET_LABEL; +} else { +} +{ +{ /* Inline scope#EscapeMark#escapes (var_escapemark) on */ +var9 = var_escapemark->attrs[COLOR_nit__scope__EscapeMark___escapes].val; /* _escapes on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _escapes"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__scope, 58); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +var_ = var7; +{ +var10 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_); +} +var_11 = var10; +for(;;) { +{ +var12 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_11); +} +if (var12){ +{ +var13 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_11); +} +var_b = var13; +{ +var14 = nit__flow___AEscapeExpr___before_flow_context(var_b); +} +var_before = var14; +var15 = NULL; +if (var_before == NULL) { +var16 = 1; /* is null */ +} else { +var16 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_before,var15) on */ +var_other = var15; +{ +{ /* Inline kernel#Object#is_same_instance (var_before,var_other) on */ +var21 = var_before == var_other; +var19 = var21; +goto RET_LABEL20; +RET_LABEL20:(void)0; +} +} +var17 = var19; +goto RET_LABEL18; +RET_LABEL18:(void)0; +} +var16 = var17; +} +if (var16){ +goto BREAK_label; +} else { +} +{ +nit___nit__FlowContext___add_loop(var_before_loop, var_before); /* Direct call flow#FlowContext#add_loop on */ +} +BREAK_label: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_11); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label22; +} +} +BREAK_label22: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_11) on */ +RET_LABEL23:(void)0; +} +} +RET_LABEL:; +} +/* method flow#FlowVisitor#merge_breaks for (self: FlowVisitor, nullable EscapeMark) */ +void nit__flow___nit__flow__FlowVisitor___merge_breaks(val* self, val* p0) { +val* var_escapemark /* var escapemark: nullable EscapeMark */; +val* var /* : null */; +short int var1 /* : Bool */; +short int var2 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var4 /* : Bool */; +short int var6 /* : Bool */; +val* var7 /* : Array[AEscapeExpr] */; +val* var9 /* : Array[AEscapeExpr] */; +val* var_ /* var : Array[AEscapeExpr] */; +val* var10 /* : ArrayIterator[nullable Object] */; +val* var_11 /* var : ArrayIterator[AEscapeExpr] */; +short int var12 /* : Bool */; +val* var13 /* : nullable Object */; +val* var_b /* var b: AEscapeExpr */; +val* var14 /* : nullable FlowContext */; +val* var_before /* var before: nullable FlowContext */; +val* var15 /* : null */; +short int var16 /* : Bool */; +short int var17 /* : Bool */; +short int var19 /* : Bool */; +short int var21 /* : Bool */; +val* var22 /* : FlowContext */; +val* var24 /* : FlowContext */; +val* var25 /* : FlowContext */; +var_escapemark = p0; +var = NULL; +if (var_escapemark == NULL) { +var1 = 1; /* is null */ +} else { +var1 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_escapemark,var) on */ +var_other = var; +{ +{ /* Inline kernel#Object#is_same_instance (var_escapemark,var_other) on */ +var6 = var_escapemark == var_other; +var4 = var6; +goto RET_LABEL5; +RET_LABEL5:(void)0; +} +} +var2 = var4; +goto RET_LABEL3; +RET_LABEL3:(void)0; +} +var1 = var2; +} +if (var1){ +goto RET_LABEL; +} else { +} +{ +{ /* Inline scope#EscapeMark#escapes (var_escapemark) on */ +var9 = var_escapemark->attrs[COLOR_nit__scope__EscapeMark___escapes].val; /* _escapes on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _escapes"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__scope, 58); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +var_ = var7; +{ +var10 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_); +} +var_11 = var10; +for(;;) { +{ +var12 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_11); +} +if (var12){ +{ +var13 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_11); +} +var_b = var13; +{ +var14 = nit__flow___AEscapeExpr___before_flow_context(var_b); +} +var_before = var14; +var15 = NULL; +if (var_before == NULL) { +var16 = 1; /* is null */ +} else { +var16 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_before,var15) on */ +var_other = var15; +{ +{ /* Inline kernel#Object#is_same_instance (var_before,var_other) on */ +var21 = var_before == var_other; +var19 = var21; +goto RET_LABEL20; +RET_LABEL20:(void)0; +} +} +var17 = var19; +goto RET_LABEL18; +RET_LABEL18:(void)0; +} +var16 = var17; +} +if (var16){ +goto BREAK_label; +} else { +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (self) on */ +var24 = self->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var24 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var22 = var24; +RET_LABEL23:(void)0; +} +} +{ +var25 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(self, var22, var_before); +} +BREAK_label: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_11); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label26; +} +} +BREAK_label26: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_11) on */ +RET_LABEL27:(void)0; +} +} +RET_LABEL:; +} +/* method flow#FlowContext#previous for (self: FlowContext): Array[FlowContext] */ +val* nit___nit__FlowContext___previous(val* self) { +val* var /* : Array[FlowContext] */; +val* var1 /* : Array[FlowContext] */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#loops for (self: FlowContext): Array[FlowContext] */ +val* nit___nit__FlowContext___loops(val* self) { +val* var /* : Array[FlowContext] */; +val* var1 /* : Array[FlowContext] */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___loops].val; /* _loops on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _loops"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 191); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#is_marked_unreachable for (self: FlowContext): Bool */ +short int nit___nit__FlowContext___is_marked_unreachable(val* self) { +short int var /* : Bool */; +short int var1 /* : Bool */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___is_marked_unreachable].s; /* _is_marked_unreachable on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#is_marked_unreachable= for (self: FlowContext, Bool) */ +void nit___nit__FlowContext___is_marked_unreachable_61d(val* self, short int p0) { +self->attrs[COLOR_nit__flow__FlowContext___is_marked_unreachable].s = p0; /* _is_marked_unreachable on */ +RET_LABEL:; +} +/* method flow#FlowContext#is_unreachable for (self: FlowContext): Bool */ +short int nit___nit__FlowContext___is_unreachable(val* self) { +short int var /* : Bool */; +short int var1 /* : Bool */; +short int var3 /* : Bool */; +short int var4 /* : Bool */; +short int var5 /* : Bool */; +short int var7 /* : Bool */; +short int var8 /* : Bool */; +val* var9 /* : Array[FlowContext] */; +val* var11 /* : Array[FlowContext] */; +long var12 /* : Int */; +long var14 /* : Int */; +long var15 /* : Int */; +short int var16 /* : Bool */; +short int var18 /* : Bool */; +short int var19 /* : Bool */; +short int var20 /* : Bool */; +{ +{ /* Inline flow#FlowContext#is_marked_unreachable (self) on */ +var3 = self->attrs[COLOR_nit__flow__FlowContext___is_marked_unreachable].s; /* _is_marked_unreachable on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +if (var1){ +var4 = 1; +var = var4; +goto RET_LABEL; +} else { +} +{ +{ /* Inline flow#FlowContext#is_start (self) on */ +var7 = self->attrs[COLOR_nit__flow__FlowContext___is_start].s; /* _is_start on */ +var5 = var7; +RET_LABEL6:(void)0; +} +} +if (var5){ +var8 = 0; +var = var8; +goto RET_LABEL; +} else { +} +{ +{ /* Inline flow#FlowContext#previous (self) on */ +var11 = self->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline array#AbstractArrayRead#length (var9) on */ +var14 = var9->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var12 = var14; +RET_LABEL13:(void)0; +} +} +var15 = 0; +{ +{ /* Inline kernel#Int#== (var12,var15) on */ +var18 = var12 == var15; +var16 = var18; +goto RET_LABEL17; +RET_LABEL17:(void)0; +} +} +if (var16){ +var19 = 1; +var = var19; +goto RET_LABEL; +} else { +} +var20 = 0; +var = var20; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#is_already_unreachable for (self: FlowContext): Bool */ +short int nit___nit__FlowContext___is_already_unreachable(val* self) { +short int var /* : Bool */; +short int var1 /* : Bool */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___is_already_unreachable].s; /* _is_already_unreachable on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#is_already_unreachable= for (self: FlowContext, Bool) */ +void nit___nit__FlowContext___is_already_unreachable_61d(val* self, short int p0) { +self->attrs[COLOR_nit__flow__FlowContext___is_already_unreachable].s = p0; /* _is_already_unreachable on */ +RET_LABEL:; +} +/* method flow#FlowContext#is_start for (self: FlowContext): Bool */ +short int nit___nit__FlowContext___is_start(val* self) { +short int var /* : Bool */; +short int var1 /* : Bool */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___is_start].s; /* _is_start on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#is_start= for (self: FlowContext, Bool) */ +void nit___nit__FlowContext___is_start_61d(val* self, short int p0) { +self->attrs[COLOR_nit__flow__FlowContext___is_start].s = p0; /* _is_start on */ +RET_LABEL:; +} +/* method flow#FlowContext#node for (self: FlowContext): nullable ANode */ +val* nit___nit__FlowContext___node(val* self) { +val* var /* : nullable ANode */; +val* var1 /* : nullable ANode */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___node].val; /* _node on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#node= for (self: FlowContext, nullable ANode) */ +void nit___nit__FlowContext___node_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowContext___node].val = p0; /* _node on */ +RET_LABEL:; +} +/* method flow#FlowContext#name= for (self: FlowContext, String) */ +void nit___nit__FlowContext___name_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowContext___name].val = p0; /* _name on */ +RET_LABEL:; +} +/* method flow#FlowContext#when_true for (self: FlowContext): FlowContext */ +val* nit___nit__FlowContext___when_true(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#when_true= for (self: FlowContext, FlowContext) */ +void nit___nit__FlowContext___when_true_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowContext___when_true].val = p0; /* _when_true on */ +RET_LABEL:; +} +/* method flow#FlowContext#when_false for (self: FlowContext): FlowContext */ +val* nit___nit__FlowContext___when_false(val* self) { +val* var /* : FlowContext */; +val* var1 /* : FlowContext */; +var1 = self->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method flow#FlowContext#when_false= for (self: FlowContext, FlowContext) */ +void nit___nit__FlowContext___when_false_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__FlowContext___when_false].val = p0; /* _when_false on */ +RET_LABEL:; +} +/* method flow#FlowContext#add_previous for (self: FlowContext, FlowContext) */ +void nit___nit__FlowContext___add_previous(val* self, val* p0) { +val* var_flow /* var flow: FlowContext */; +short int var /* : Bool */; +short int var1 /* : Bool */; +short int var2 /* : Bool */; +short int var_ /* var : Bool */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +short int var6 /* : Bool */; +short int var7 /* : Bool */; +val* var8 /* : Array[FlowContext] */; +val* var10 /* : Array[FlowContext] */; +var_flow = p0; +{ +var1 = nit___nit__FlowContext___is_unreachable(var_flow); +} +var2 = !var1; +var_ = var2; +if (var2){ +{ +{ /* Inline flow#FlowContext#previous (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +var6 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__has(var3, var_flow); +} +var7 = !var6; +var = var7; +} else { +var = var_; +} +if (var){ +{ +{ /* Inline flow#FlowContext#previous (self) on */ +var10 = self->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var8, var_flow); /* Direct call array#Array#add on */ +} +} else { +} +RET_LABEL:; +} +/* method flow#FlowContext#add_loop for (self: FlowContext, FlowContext) */ +void nit___nit__FlowContext___add_loop(val* self, val* p0) { +val* var_flow /* var flow: FlowContext */; +short int var /* : Bool */; +short int var1 /* : Bool */; +short int var2 /* : Bool */; +short int var_ /* var : Bool */; +val* var3 /* : Array[FlowContext] */; +val* var5 /* : Array[FlowContext] */; +short int var6 /* : Bool */; +short int var7 /* : Bool */; +val* var8 /* : Array[FlowContext] */; +val* var10 /* : Array[FlowContext] */; +var_flow = p0; +{ +var1 = nit___nit__FlowContext___is_unreachable(var_flow); +} +var2 = !var1; +var_ = var2; +if (var2){ +{ +{ /* Inline flow#FlowContext#previous (self) on */ +var5 = self->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +var6 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__has(var3, var_flow); +} +var7 = !var6; +var = var7; +} else { +var = var_; +} +if (var){ +{ +{ /* Inline flow#FlowContext#loops (self) on */ +var10 = self->attrs[COLOR_nit__flow__FlowContext___loops].val; /* _loops on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _loops"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 191); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var8, var_flow); /* Direct call array#Array#add on */ +} +} else { +} +RET_LABEL:; +} +/* method flow#ANode#accept_flow_visitor for (self: ANode, FlowVisitor) */ +void nit__flow___ANode___accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__parser_nodes__ANode__visit_all]))(self, var_v) /* visit_all on */; +} +RET_LABEL:; +} +/* method flow#APropdef#do_flow for (self: APropdef, ToolContext) */ +void nit__flow___APropdef___do_flow(val* self, val* p0) { +val* var_toolcontext /* var toolcontext: ToolContext */; +val* var /* : FlowVisitor */; +val* var_v /* var v: FlowVisitor */; +var_toolcontext = p0; +var = NEW_nit__flow__FlowVisitor(&type_nit__flow__FlowVisitor); +{ +((void (*)(val* self, val* p0))(var->class->vft[COLOR_nit__flow__FlowVisitor__toolcontext_61d]))(var, var_toolcontext) /* toolcontext= on */; +} +{ +((void (*)(val* self))(var->class->vft[COLOR_standard__kernel__Object__init]))(var) /* init on */; +} +var_v = var; +{ +nit___nit__Visitor___enter_visit(var_v, self); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +RET_LABEL:; +} +/* method flow#APropdef#before_flow_context= for (self: APropdef, nullable FlowContext) */ +void nit__flow___APropdef___before_flow_context_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__APropdef___before_flow_context].val = p0; /* _before_flow_context on */ +RET_LABEL:; +} +/* method flow#APropdef#after_flow_context= for (self: APropdef, nullable FlowContext) */ +void nit__flow___APropdef___after_flow_context_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__APropdef___after_flow_context].val = p0; /* _after_flow_context on */ +RET_LABEL:; +} +/* method flow#APropdef#accept_flow_visitor for (self: APropdef, FlowVisitor) */ +void nit__flow___APropdef___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +val* var2 /* : FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var2 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline flow#APropdef#before_flow_context= (self,var) on */ +self->attrs[COLOR_nit__flow__APropdef___before_flow_context].val = var; /* _before_flow_context on */ +RET_LABEL3:(void)0; +} +} +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___APropdef___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var6 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#APropdef#after_flow_context= (self,var4) on */ +self->attrs[COLOR_nit__flow__APropdef___after_flow_context].val = var4; /* _after_flow_context on */ +RET_LABEL7:(void)0; +} +} +RET_LABEL:; +} +/* method flow#AExpr#after_flow_context for (self: AExpr): nullable FlowContext */ +val* nit__flow___AExpr___after_flow_context(val* self) { +val* var /* : nullable FlowContext */; +val* var1 /* : nullable FlowContext */; +var1 = self->attrs[COLOR_nit__flow__AExpr___after_flow_context].val; /* _after_flow_context on */ +var = var1; +RET_LABEL:; +return var; +} +/* method flow#AExpr#after_flow_context= for (self: AExpr, nullable FlowContext) */ +void nit__flow___AExpr___after_flow_context_61d(val* self, val* p0) { +self->attrs[COLOR_nit__flow__AExpr___after_flow_context].val = p0; /* _after_flow_context on */ +RET_LABEL:; +} +/* method flow#AVarAssignExpr#accept_flow_visitor for (self: AVarAssignExpr, FlowVisitor) */ +void nit__flow___AVarAssignExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AVarAssignExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_flow(var_v); +} +{ +{ /* Inline flow#AExpr#after_flow_context= (self,var) on */ +self->attrs[COLOR_nit__flow__AExpr___after_flow_context].val = var; /* _after_flow_context on */ +RET_LABEL1:(void)0; +} +} +RET_LABEL:; +} +/* method flow#AReassignFormExpr#accept_flow_visitor for (self: AReassignFormExpr, FlowVisitor) */ +void nit__flow___AReassignFormExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AReassignFormExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_flow(var_v); +} +{ +{ /* Inline flow#AExpr#after_flow_context= (self,var) on */ +self->attrs[COLOR_nit__flow__AExpr___after_flow_context].val = var; /* _after_flow_context on */ +RET_LABEL1:(void)0; +} +} +RET_LABEL:; +} +/* method flow#ABlockExpr#accept_flow_visitor for (self: ABlockExpr, FlowVisitor) */ +void nit__flow___ABlockExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : ANodes[AExpr] */; +val* var2 /* : ANodes[AExpr] */; +val* var_ /* var : ANodes[AExpr] */; +val* var3 /* : Iterator[ANode] */; +val* var_4 /* var : Iterator[AExpr] */; +short int var5 /* : Bool */; +val* var6 /* : nullable Object */; +val* var_e /* var e: AExpr */; +val* var7 /* : FlowContext */; +val* var9 /* : FlowContext */; +short int var10 /* : Bool */; +short int var11 /* : Bool */; +val* var12 /* : FlowContext */; +val* var14 /* : FlowContext */; +short int var15 /* : Bool */; +short int var17 /* : Bool */; +short int var18 /* : Bool */; +val* var19 /* : FlowContext */; +val* var21 /* : FlowContext */; +short int var22 /* : Bool */; +val* var24 /* : ToolContext */; +val* var26 /* : ToolContext */; +val* var27 /* : Location */; +static val* varonce; +val* var28 /* : String */; +char* var29 /* : NativeString */; +long var30 /* : Int */; +val* var31 /* : FlatString */; +var_v = p0; +{ +{ /* Inline parser_nodes#ABlockExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__ABlockExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1565); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +var_ = var; +{ +var3 = nit___nit__ANodes___standard__abstract_collection__Collection__iterator(var_); +} +var_4 = var3; +for(;;) { +{ +var5 = ((short int (*)(val* self))(var_4->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_4) /* is_ok on */; +} +if (var5){ +{ +var6 = ((val* (*)(val* self))(var_4->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_4) /* item on */; +} +var_e = var6; +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var9 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +var10 = nit___nit__FlowContext___is_unreachable(var7); +} +var11 = !var10; +if (var11){ +{ +nit___nit__Visitor___enter_visit(var_v, var_e); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +} else { +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var14 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#is_already_unreachable (var12) on */ +var17 = var12->attrs[COLOR_nit__flow__FlowContext___is_already_unreachable].s; /* _is_already_unreachable on */ +var15 = var17; +RET_LABEL16:(void)0; +} +} +var18 = !var15; +if (var18){ +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var21 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var21 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var19 = var21; +RET_LABEL20:(void)0; +} +} +var22 = 1; +{ +{ /* Inline flow#FlowContext#is_already_unreachable= (var19,var22) on */ +var19->attrs[COLOR_nit__flow__FlowContext___is_already_unreachable].s = var22; /* _is_already_unreachable on */ +RET_LABEL23:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#toolcontext (var_v) on */ +var26 = var_v->attrs[COLOR_nit__flow__FlowVisitor___toolcontext].val; /* _toolcontext on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 39); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = nit___nit__ANode___hot_location(var_e); +} +if (varonce) { +var28 = varonce; +} else { +var29 = "Error: unreachable statement."; +var30 = 29; +var31 = standard___standard__NativeString___to_s_with_length(var29, var30); +var28 = var31; +varonce = var28; +} +{ +nit___nit__ToolContext___error(var24, var27, var28); /* Direct call toolcontext#ToolContext#error on */ +} +} else { +} +} +{ +((void (*)(val* self))(var_4->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_4) /* next on */; +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_4) on */ +RET_LABEL32:(void)0; +} +} +RET_LABEL:; +} +/* method flow#AReturnExpr#accept_flow_visitor for (self: AReturnExpr, FlowVisitor) */ +void nit__flow___AReturnExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AReturnExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_unreachable_flow(var_v); +} +RET_LABEL:; +} +/* method flow#AEscapeExpr#before_flow_context for (self: AEscapeExpr): nullable FlowContext */ +val* nit__flow___AEscapeExpr___before_flow_context(val* self) { +val* var /* : nullable FlowContext */; +val* var1 /* : nullable FlowContext */; +val* var3 /* : nullable FlowContext */; +val* var_after /* var after: nullable FlowContext */; +val* var4 /* : null */; +short int var5 /* : Bool */; +short int var6 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var8 /* : Bool */; +short int var10 /* : Bool */; +val* var11 /* : null */; +val* var12 /* : Array[FlowContext] */; +val* var14 /* : Array[FlowContext] */; +val* var15 /* : nullable Object */; +{ +{ /* Inline flow#AExpr#after_flow_context (self) on */ +var3 = self->attrs[COLOR_nit__flow__AExpr___after_flow_context].val; /* _after_flow_context on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +var_after = var1; +var4 = NULL; +if (var_after == NULL) { +var5 = 1; /* is null */ +} else { +var5 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_after,var4) on */ +var_other = var4; +{ +{ /* Inline kernel#Object#is_same_instance (var_after,var_other) on */ +var10 = var_after == var_other; +var8 = var10; +goto RET_LABEL9; +RET_LABEL9:(void)0; +} +} +var6 = var8; +goto RET_LABEL7; +RET_LABEL7:(void)0; +} +var5 = var6; +} +if (var5){ +var11 = NULL; +var = var11; +goto RET_LABEL; +} else { +} +{ +{ /* Inline flow#FlowContext#previous (var_after) on */ +var14 = var_after->attrs[COLOR_nit__flow__FlowContext___previous].val; /* _previous on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _previous"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 188); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +var15 = standard___standard__SequenceRead___Collection__first(var12); +} +var = var15; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method flow#AEscapeExpr#accept_flow_visitor for (self: AEscapeExpr, FlowVisitor) */ +void nit__flow___AEscapeExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AEscapeExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_unreachable_flow(var_v); +} +RET_LABEL:; +} +/* method flow#AAbortExpr#accept_flow_visitor for (self: AAbortExpr, FlowVisitor) */ +void nit__flow___AAbortExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AAbortExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_unreachable_flow(var_v); +} +RET_LABEL:; +} +/* method flow#ADoExpr#accept_flow_visitor for (self: ADoExpr, FlowVisitor) */ +void nit__flow___ADoExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : nullable EscapeMark */; +val* var2 /* : nullable EscapeMark */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___ADoExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +{ /* Inline scope#ADoExpr#break_mark (self) on */ +var2 = self->attrs[COLOR_nit__scope__ADoExpr___break_mark].val; /* _break_mark on */ +var = var2; +RET_LABEL1:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_breaks(var_v, var); /* Direct call flow#FlowVisitor#merge_breaks on */ +} +RET_LABEL:; +} +/* method flow#AIfExpr#accept_flow_visitor for (self: AIfExpr, FlowVisitor) */ +void nit__flow___AIfExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : nullable AExpr */; +val* var10 /* : nullable AExpr */; +val* var11 /* : FlowContext */; +val* var13 /* : FlowContext */; +val* var_after_then /* var after_then: FlowContext */; +val* var14 /* : FlowContext */; +val* var16 /* : FlowContext */; +val* var18 /* : nullable AExpr */; +val* var20 /* : nullable AExpr */; +val* var21 /* : FlowContext */; +val* var23 /* : FlowContext */; +val* var_after_else /* var after_else: FlowContext */; +val* var24 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#AIfExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AIfExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1664); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#AIfExpr#n_then (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__AIfExpr___n_then].val; /* _n_then on */ +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var8); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var13 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +var_after_then = var11; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var16 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var14) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var14; /* _current_flow_context on */ +RET_LABEL17:(void)0; +} +} +{ +{ /* Inline parser_nodes#AIfExpr#n_else (self) on */ +var20 = self->attrs[COLOR_nit__parser_nodes__AIfExpr___n_else].val; /* _n_else on */ +var18 = var20; +RET_LABEL19:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var18); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var23 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var23 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var21 = var23; +RET_LABEL22:(void)0; +} +} +var_after_else = var21; +{ +var24 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var_after_then, var_after_else); +} +RET_LABEL:; +} +/* method flow#AIfexprExpr#accept_flow_visitor for (self: AIfexprExpr, FlowVisitor) */ +void nit__flow___AIfexprExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : AExpr */; +val* var10 /* : AExpr */; +val* var11 /* : FlowContext */; +val* var13 /* : FlowContext */; +val* var_after_then /* var after_then: FlowContext */; +val* var14 /* : FlowContext */; +val* var16 /* : FlowContext */; +val* var18 /* : AExpr */; +val* var20 /* : AExpr */; +val* var21 /* : FlowContext */; +val* var23 /* : FlowContext */; +val* var_after_else /* var after_else: FlowContext */; +val* var24 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#AIfexprExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AIfexprExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1681); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#AIfexprExpr#n_then (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__AIfexprExpr___n_then].val; /* _n_then on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_then"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1687); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var8); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var13 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +var_after_then = var11; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var16 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var14) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var14; /* _current_flow_context on */ +RET_LABEL17:(void)0; +} +} +{ +{ /* Inline parser_nodes#AIfexprExpr#n_else (self) on */ +var20 = self->attrs[COLOR_nit__parser_nodes__AIfexprExpr___n_else].val; /* _n_else on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_else"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1693); +show_backtrace(1); +} +var18 = var20; +RET_LABEL19:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var18); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var23 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var23 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var21 = var23; +RET_LABEL22:(void)0; +} +} +var_after_else = var21; +{ +var24 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var_after_then, var_after_else); +} +RET_LABEL:; +} +/* method flow#AWhileExpr#accept_flow_visitor for (self: AWhileExpr, FlowVisitor) */ +void nit__flow___AWhileExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +val* var_before_loop /* var before_loop: FlowContext */; +val* var1 /* : AExpr */; +val* var3 /* : AExpr */; +val* var4 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var5 /* : FlowContext */; +val* var7 /* : FlowContext */; +val* var9 /* : nullable AExpr */; +val* var11 /* : nullable AExpr */; +val* var12 /* : FlowContext */; +val* var14 /* : FlowContext */; +val* var_after_block /* var after_block: FlowContext */; +val* var15 /* : nullable EscapeMark */; +val* var17 /* : nullable EscapeMark */; +val* var18 /* : FlowContext */; +val* var20 /* : FlowContext */; +val* var22 /* : nullable EscapeMark */; +val* var24 /* : nullable EscapeMark */; +var_v = p0; +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_flow(var_v); +} +var_before_loop = var; +{ +{ /* Inline parser_nodes#AWhileExpr#n_expr (self) on */ +var3 = self->attrs[COLOR_nit__parser_nodes__AWhileExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var3 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1705); +show_backtrace(1); +} +var1 = var3; +RET_LABEL2:(void)0; +} +} +{ +var4 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var1); +} +var_after_expr = var4; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var7 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var7 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var5 = var7; +RET_LABEL6:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var5) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var5; /* _current_flow_context on */ +RET_LABEL8:(void)0; +} +} +{ +{ /* Inline parser_nodes#AWhileExpr#n_block (self) on */ +var11 = self->attrs[COLOR_nit__parser_nodes__AWhileExpr___n_block].val; /* _n_block on */ +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var9); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var14 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +var_after_block = var12; +{ +nit___nit__FlowContext___add_loop(var_before_loop, var_after_block); /* Direct call flow#FlowContext#add_loop on */ +} +{ +{ /* Inline scope#AWhileExpr#continue_mark (self) on */ +var17 = self->attrs[COLOR_nit__scope__AWhileExpr___continue_mark].val; /* _continue_mark on */ +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_continues_to(var_v, var_after_block, var15); /* Direct call flow#FlowVisitor#merge_continues_to on */ +} +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var20 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var18 = var20; +RET_LABEL19:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var18) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var18; /* _current_flow_context on */ +RET_LABEL21:(void)0; +} +} +{ +{ /* Inline scope#AWhileExpr#break_mark (self) on */ +var24 = self->attrs[COLOR_nit__scope__AWhileExpr___break_mark].val; /* _break_mark on */ +var22 = var24; +RET_LABEL23:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_breaks(var_v, var22); /* Direct call flow#FlowVisitor#merge_breaks on */ +} +RET_LABEL:; +} +/* method flow#ALoopExpr#accept_flow_visitor for (self: ALoopExpr, FlowVisitor) */ +void nit__flow___ALoopExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +val* var_before_loop /* var before_loop: FlowContext */; +val* var1 /* : nullable AExpr */; +val* var3 /* : nullable AExpr */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var_after_block /* var after_block: FlowContext */; +val* var7 /* : nullable EscapeMark */; +val* var9 /* : nullable EscapeMark */; +val* var10 /* : FlowContext */; +val* var11 /* : nullable EscapeMark */; +val* var13 /* : nullable EscapeMark */; +var_v = p0; +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_flow(var_v); +} +var_before_loop = var; +{ +{ /* Inline parser_nodes#ALoopExpr#n_block (self) on */ +var3 = self->attrs[COLOR_nit__parser_nodes__ALoopExpr___n_block].val; /* _n_block on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var1); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var6 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +var_after_block = var4; +{ +nit___nit__FlowContext___add_loop(var_before_loop, var_after_block); /* Direct call flow#FlowContext#add_loop on */ +} +{ +{ /* Inline scope#ALoopExpr#continue_mark (self) on */ +var9 = self->attrs[COLOR_nit__scope__ALoopExpr___continue_mark].val; /* _continue_mark on */ +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_continues_to(var_v, var_after_block, var7); /* Direct call flow#FlowVisitor#merge_continues_to on */ +} +{ +var10 = nit__flow___nit__flow__FlowVisitor___make_unreachable_flow(var_v); +} +{ +{ /* Inline scope#ALoopExpr#break_mark (self) on */ +var13 = self->attrs[COLOR_nit__scope__ALoopExpr___break_mark].val; /* _break_mark on */ +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_breaks(var_v, var11); /* Direct call flow#FlowVisitor#merge_breaks on */ +} +RET_LABEL:; +} +/* method flow#AForExpr#accept_flow_visitor for (self: AForExpr, FlowVisitor) */ +void nit__flow___AForExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_before_loop /* var before_loop: FlowContext */; +val* var4 /* : nullable AExpr */; +val* var6 /* : nullable AExpr */; +val* var7 /* : FlowContext */; +val* var9 /* : FlowContext */; +val* var_after_block /* var after_block: FlowContext */; +val* var10 /* : nullable EscapeMark */; +val* var12 /* : nullable EscapeMark */; +val* var13 /* : FlowContext */; +val* var15 /* : FlowContext */; +val* var16 /* : FlowContext */; +val* var17 /* : nullable EscapeMark */; +val* var19 /* : nullable EscapeMark */; +var_v = p0; +{ +{ /* Inline parser_nodes#AForExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AForExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1738); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___make_sub_flow(var_v); +} +var_before_loop = var3; +{ +{ /* Inline parser_nodes#AForExpr#n_block (self) on */ +var6 = self->attrs[COLOR_nit__parser_nodes__AForExpr___n_block].val; /* _n_block on */ +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var4); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var9 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +var_after_block = var7; +{ +nit___nit__FlowContext___add_loop(var_before_loop, var_after_block); /* Direct call flow#FlowContext#add_loop on */ +} +{ +{ /* Inline scope#AForExpr#continue_mark (self) on */ +var12 = self->attrs[COLOR_nit__scope__AForExpr___continue_mark].val; /* _continue_mark on */ +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_continues_to(var_v, var_after_block, var10); /* Direct call flow#FlowVisitor#merge_continues_to on */ +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context (var_v) on */ +var15 = var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val; /* _current_flow_context on */ +if (unlikely(var15 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _current_flow_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 37); +show_backtrace(1); +} +var13 = var15; +RET_LABEL14:(void)0; +} +} +{ +var16 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var13, var_before_loop); +} +{ +{ /* Inline scope#AForExpr#break_mark (self) on */ +var19 = self->attrs[COLOR_nit__scope__AForExpr___break_mark].val; /* _break_mark on */ +var17 = var19; +RET_LABEL18:(void)0; +} +} +{ +nit__flow___nit__flow__FlowVisitor___merge_breaks(var_v, var17); /* Direct call flow#FlowVisitor#merge_breaks on */ +} +RET_LABEL:; +} +/* method flow#AAssertExpr#accept_flow_visitor for (self: AAssertExpr, FlowVisitor) */ +void nit__flow___AAssertExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : nullable AExpr */; +val* var10 /* : nullable AExpr */; +val* var11 /* : FlowContext */; +val* var13 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#AAssertExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AAssertExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1758); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#AAssertExpr#n_else (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__AAssertExpr___n_else].val; /* _n_else on */ +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +nit___nit__Visitor___enter_visit(var_v, var8); /* Direct call parser_nodes#Visitor#enter_visit on */ +} +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var13 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var11) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var11; /* _current_flow_context on */ +RET_LABEL14:(void)0; +} +} +RET_LABEL:; +} +/* method flow#AOrExpr#accept_flow_visitor for (self: AOrExpr, FlowVisitor) */ +void nit__flow___AOrExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : AExpr */; +val* var10 /* : AExpr */; +val* var11 /* : FlowContext */; +val* var_after_expr2 /* var after_expr2: FlowContext */; +val* var12 /* : FlowContext */; +val* var14 /* : FlowContext */; +val* var15 /* : FlowContext */; +val* var17 /* : FlowContext */; +val* var18 /* : FlowContext */; +val* var_merge_true /* var merge_true: FlowContext */; +static val* varonce; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +val* var24 /* : FlowContext */; +val* var26 /* : FlowContext */; +val* var27 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1823); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr2 (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr2].val; /* _n_expr2 on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr2"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1826); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +var11 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var8); +} +var_after_expr2 = var11; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var14 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr2) on */ +var17 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +var18 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var12, var15); +} +var_merge_true = var18; +if (varonce) { +var19 = varonce; +} else { +var20 = "OR TRUE"; +var21 = 7; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce = var19; +} +{ +{ /* Inline flow#FlowContext#name= (var_merge_true,var19) on */ +var_merge_true->attrs[COLOR_nit__flow__FlowContext___name].val = var19; /* _name on */ +RET_LABEL23:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr2) on */ +var26 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = nit__flow___nit__flow__FlowVisitor___make_true_false_flow(var_v, var_merge_true, var24); +} +RET_LABEL:; +} +/* method flow#AImpliesExpr#accept_flow_visitor for (self: AImpliesExpr, FlowVisitor) */ +void nit__flow___AImpliesExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : AExpr */; +val* var10 /* : AExpr */; +val* var11 /* : FlowContext */; +val* var_after_expr2 /* var after_expr2: FlowContext */; +val* var12 /* : FlowContext */; +val* var14 /* : FlowContext */; +val* var15 /* : FlowContext */; +val* var17 /* : FlowContext */; +val* var18 /* : FlowContext */; +val* var_merge_true /* var merge_true: FlowContext */; +static val* varonce; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +val* var24 /* : FlowContext */; +val* var26 /* : FlowContext */; +val* var27 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1823); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr2 (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr2].val; /* _n_expr2 on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr2"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1826); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +var11 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var8); +} +var_after_expr2 = var11; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var14 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr2) on */ +var17 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +var18 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var12, var15); +} +var_merge_true = var18; +if (varonce) { +var19 = varonce; +} else { +var20 = "OR TRUE"; +var21 = 7; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce = var19; +} +{ +{ /* Inline flow#FlowContext#name= (var_merge_true,var19) on */ +var_merge_true->attrs[COLOR_nit__flow__FlowContext___name].val = var19; /* _name on */ +RET_LABEL23:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr2) on */ +var26 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = nit__flow___nit__flow__FlowVisitor___make_true_false_flow(var_v, var_merge_true, var24); +} +RET_LABEL:; +} +/* method flow#AAndExpr#accept_flow_visitor for (self: AAndExpr, FlowVisitor) */ +void nit__flow___AAndExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var8 /* : AExpr */; +val* var10 /* : AExpr */; +val* var11 /* : FlowContext */; +val* var_after_expr2 /* var after_expr2: FlowContext */; +val* var12 /* : FlowContext */; +val* var14 /* : FlowContext */; +val* var15 /* : FlowContext */; +val* var17 /* : FlowContext */; +val* var18 /* : FlowContext */; +val* var_merge_false /* var merge_false: FlowContext */; +static val* varonce; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +val* var24 /* : FlowContext */; +val* var26 /* : FlowContext */; +val* var27 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1823); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var4) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var4; /* _current_flow_context on */ +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline parser_nodes#ABinBoolExpr#n_expr2 (self) on */ +var10 = self->attrs[COLOR_nit__parser_nodes__ABinBoolExpr___n_expr2].val; /* _n_expr2 on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr2"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1826); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +var11 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var8); +} +var_after_expr2 = var11; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var14 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr2) on */ +var17 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +var18 = nit__flow___nit__flow__FlowVisitor___make_merge_flow(var_v, var12, var15); +} +var_merge_false = var18; +if (varonce) { +var19 = varonce; +} else { +var20 = "AND FALSE"; +var21 = 9; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce = var19; +} +{ +{ /* Inline flow#FlowContext#name= (var_merge_false,var19) on */ +var_merge_false->attrs[COLOR_nit__flow__FlowContext___name].val = var19; /* _name on */ +RET_LABEL23:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr2) on */ +var26 = var_after_expr2->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = nit__flow___nit__flow__FlowVisitor___make_true_false_flow(var_v, var24, var_merge_false); +} +RET_LABEL:; +} +/* method flow#ANotExpr#accept_flow_visitor for (self: ANotExpr, FlowVisitor) */ +void nit__flow___ANotExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +val* var4 /* : FlowContext */; +val* var6 /* : FlowContext */; +val* var7 /* : FlowContext */; +val* var9 /* : FlowContext */; +val* var10 /* : FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#ANotExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__ANotExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1857); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowContext#when_false (var_after_expr) on */ +var6 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_false].val; /* _when_false on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_false"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 227); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline flow#FlowContext#when_true (var_after_expr) on */ +var9 = var_after_expr->attrs[COLOR_nit__flow__FlowContext___when_true].val; /* _when_true on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _when_true"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__flow, 224); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +var10 = nit__flow___nit__flow__FlowVisitor___make_true_false_flow(var_v, var4, var7); +} +RET_LABEL:; +} +/* method flow#AOrElseExpr#accept_flow_visitor for (self: AOrElseExpr, FlowVisitor) */ +void nit__flow___AOrElseExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AOrElseExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +RET_LABEL:; +} +/* method flow#AEqExpr#accept_flow_visitor for (self: AEqExpr, FlowVisitor) */ +void nit__flow___AEqExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AEqExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_true_false_flow(var_v); +} +RET_LABEL:; +} +/* method flow#ANeExpr#accept_flow_visitor for (self: ANeExpr, FlowVisitor) */ +void nit__flow___ANeExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___ANeExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_true_false_flow(var_v); +} +RET_LABEL:; +} +/* method flow#AIsaExpr#accept_flow_visitor for (self: AIsaExpr, FlowVisitor) */ +void nit__flow___AIsaExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : FlowContext */; +var_v = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__flow___AIsaExpr___ANode__accept_flow_visitor]))(self, p0) /* accept_flow_visitor on */; +} +{ +var = nit__flow___nit__flow__FlowVisitor___make_sub_true_false_flow(var_v); +} +RET_LABEL:; +} +/* method flow#AParExpr#accept_flow_visitor for (self: AParExpr, FlowVisitor) */ +void nit__flow___AParExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#AParExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AParExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 2288); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var_after_expr) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_after_expr; /* _current_flow_context on */ +RET_LABEL4:(void)0; +} +} +RET_LABEL:; +} +/* method flow#AOnceExpr#accept_flow_visitor for (self: AOnceExpr, FlowVisitor) */ +void nit__flow___AOnceExpr___ANode__accept_flow_visitor(val* self, val* p0) { +val* var_v /* var v: FlowVisitor */; +val* var /* : AExpr */; +val* var2 /* : AExpr */; +val* var3 /* : FlowContext */; +val* var_after_expr /* var after_expr: FlowContext */; +var_v = p0; +{ +{ /* Inline parser_nodes#AOnceExpr#n_expr (self) on */ +var2 = self->attrs[COLOR_nit__parser_nodes__AOnceExpr___n_expr].val; /* _n_expr on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _n_expr"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__parser_nodes, 1794); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit__flow___nit__flow__FlowVisitor___visit_expr(var_v, var); +} +var_after_expr = var3; +{ +{ /* Inline flow#FlowVisitor#current_flow_context= (var_v,var_after_expr) on */ +var_v->attrs[COLOR_nit__flow__FlowVisitor___current_flow_context].val = var_after_expr; /* _current_flow_context on */ +RET_LABEL4:(void)0; +} +} +RET_LABEL:; +}