X-Git-Url: http://nitlanguage.org diff --git a/c_src/nit__separate_compiler.sep.1.c b/c_src/nit__separate_compiler.sep.1.c new file mode 100644 index 0000000..7bfa304 --- /dev/null +++ b/c_src/nit__separate_compiler.sep.1.c @@ -0,0 +1,8560 @@ +#include "nit__separate_compiler.sep.0.h" +/* method separate_compiler#ToolContext#opt_separate for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_separate(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_separate].val; /* _opt_separate on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_separate"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 24); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_no_inline_intern for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_no_inline_intern(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_inline_intern].val; /* _opt_no_inline_intern on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_inline_intern"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 26); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_no_union_attribute for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_no_union_attribute(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_union_attribute].val; /* _opt_no_union_attribute on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_union_attribute"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 28); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_no_shortcut_equate for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_no_shortcut_equate(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_shortcut_equate].val; /* _opt_no_shortcut_equate on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_shortcut_equate"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 30); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_colors_are_symbols for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_colors_are_symbols(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colors_are_symbols].val; /* _opt_colors_are_symbols on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colors_are_symbols"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 32); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_inline_coloring_numbers for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_inline_coloring_numbers(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_coloring_numbers].val; /* _opt_inline_coloring_numbers on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_coloring_numbers"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 35); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_inline_some_methods for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_inline_some_methods(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_some_methods].val; /* _opt_inline_some_methods on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_some_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 37); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_direct_call_monomorph for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_direct_call_monomorph(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_direct_call_monomorph].val; /* _opt_direct_call_monomorph on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_direct_call_monomorph"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 39); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_skip_dead_methods for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_skip_dead_methods(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_skip_dead_methods].val; /* _opt_skip_dead_methods on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_skip_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 41); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_semi_global for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_semi_global(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_semi_global].val; /* _opt_semi_global on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_semi_global"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 43); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_colo_dead_methods for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_colo_dead_methods(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colo_dead_methods].val; /* _opt_colo_dead_methods on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colo_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 45); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#opt_tables_metrics for (self: ToolContext): OptionBool */ +val* nit__separate_compiler___ToolContext___opt_tables_metrics(val* self) { +val* var /* : OptionBool */; +val* var1 /* : OptionBool */; +var1 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_tables_metrics].val; /* _opt_tables_metrics on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_tables_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 47); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ToolContext#init for (self: ToolContext) */ +void nit__separate_compiler___ToolContext___standard__kernel__Object__init(val* self) { +val* var /* : OptionContext */; +val* var2 /* : OptionContext */; +val* var3 /* : OptionBool */; +val* var5 /* : OptionBool */; +val* var6 /* : Array[Option] */; +long var7 /* : Int */; +val* var8 /* : NativeArray[Option] */; +val* var9 /* : OptionContext */; +val* var11 /* : OptionContext */; +val* var12 /* : OptionBool */; +val* var14 /* : OptionBool */; +val* var15 /* : Array[Option] */; +long var16 /* : Int */; +val* var17 /* : NativeArray[Option] */; +val* var18 /* : OptionContext */; +val* var20 /* : OptionContext */; +val* var21 /* : OptionBool */; +val* var23 /* : OptionBool */; +val* var24 /* : Array[Option] */; +long var25 /* : Int */; +val* var26 /* : NativeArray[Option] */; +val* var27 /* : OptionContext */; +val* var29 /* : OptionContext */; +val* var30 /* : OptionBool */; +val* var32 /* : OptionBool */; +val* var33 /* : OptionBool */; +val* var35 /* : OptionBool */; +val* var36 /* : Array[Option] */; +long var37 /* : Int */; +val* var38 /* : NativeArray[Option] */; +val* var39 /* : OptionContext */; +val* var41 /* : OptionContext */; +val* var42 /* : OptionBool */; +val* var44 /* : OptionBool */; +val* var45 /* : OptionBool */; +val* var47 /* : OptionBool */; +val* var48 /* : OptionBool */; +val* var50 /* : OptionBool */; +val* var51 /* : OptionBool */; +val* var53 /* : OptionBool */; +val* var54 /* : OptionBool */; +val* var56 /* : OptionBool */; +val* var57 /* : Array[Option] */; +long var58 /* : Int */; +val* var59 /* : NativeArray[Option] */; +val* var60 /* : OptionContext */; +val* var62 /* : OptionContext */; +val* var63 /* : OptionBool */; +val* var65 /* : OptionBool */; +val* var66 /* : Array[Option] */; +long var67 /* : Int */; +val* var68 /* : NativeArray[Option] */; +val* var69 /* : OptionContext */; +val* var71 /* : OptionContext */; +val* var72 /* : OptionBool */; +val* var74 /* : OptionBool */; +val* var75 /* : Array[Option] */; +long var76 /* : Int */; +val* var77 /* : NativeArray[Option] */; +{ +((void (*)(val* self))(self->class->vft[COLOR_nit__separate_compiler___ToolContext___standard__kernel__Object__init]))(self) /* init on */; +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var2 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_separate (self) on */ +var5 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_separate].val; /* _opt_separate on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_separate"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 24); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +var6 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var6 = array_instance Array[Option] */ +var7 = 1; +var8 = NEW_standard__NativeArray(var7, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var8)->values[0] = (val*) var3; +{ +((void (*)(val* self, val* p0, long p1))(var6->class->vft[COLOR_standard__array__Array__with_native]))(var6, var8, var7) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var, var6); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var11 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_no_inline_intern (self) on */ +var14 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_inline_intern].val; /* _opt_no_inline_intern on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_inline_intern"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 26); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +var15 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var15 = array_instance Array[Option] */ +var16 = 1; +var17 = NEW_standard__NativeArray(var16, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var17)->values[0] = (val*) var12; +{ +((void (*)(val* self, val* p0, long p1))(var15->class->vft[COLOR_standard__array__Array__with_native]))(var15, var17, var16) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var9, var15); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var20 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var18 = var20; +RET_LABEL19:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_no_union_attribute (self) on */ +var23 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_union_attribute].val; /* _opt_no_union_attribute on */ +if (unlikely(var23 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_union_attribute"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 28); +show_backtrace(1); +} +var21 = var23; +RET_LABEL22:(void)0; +} +} +var24 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var24 = array_instance Array[Option] */ +var25 = 1; +var26 = NEW_standard__NativeArray(var25, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var26)->values[0] = (val*) var21; +{ +((void (*)(val* self, val* p0, long p1))(var24->class->vft[COLOR_standard__array__Array__with_native]))(var24, var26, var25) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var18, var24); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var29 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var29 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var27 = var29; +RET_LABEL28:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_no_shortcut_equate (self) on */ +var32 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_shortcut_equate].val; /* _opt_no_shortcut_equate on */ +if (unlikely(var32 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_shortcut_equate"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 30); +show_backtrace(1); +} +var30 = var32; +RET_LABEL31:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_colors_are_symbols (self) on */ +var35 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colors_are_symbols].val; /* _opt_colors_are_symbols on */ +if (unlikely(var35 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colors_are_symbols"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 32); +show_backtrace(1); +} +var33 = var35; +RET_LABEL34:(void)0; +} +} +var36 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var36 = array_instance Array[Option] */ +var37 = 2; +var38 = NEW_standard__NativeArray(var37, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var38)->values[0] = (val*) var30; +((struct instance_standard__NativeArray*)var38)->values[1] = (val*) var33; +{ +((void (*)(val* self, val* p0, long p1))(var36->class->vft[COLOR_standard__array__Array__with_native]))(var36, var38, var37) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var27, var36); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var41 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var41 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var39 = var41; +RET_LABEL40:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_inline_coloring_numbers (self) on */ +var44 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_coloring_numbers].val; /* _opt_inline_coloring_numbers on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_coloring_numbers"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 35); +show_backtrace(1); +} +var42 = var44; +RET_LABEL43:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_inline_some_methods (self) on */ +var47 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_some_methods].val; /* _opt_inline_some_methods on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_some_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 37); +show_backtrace(1); +} +var45 = var47; +RET_LABEL46:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_direct_call_monomorph (self) on */ +var50 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_direct_call_monomorph].val; /* _opt_direct_call_monomorph on */ +if (unlikely(var50 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_direct_call_monomorph"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 39); +show_backtrace(1); +} +var48 = var50; +RET_LABEL49:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_skip_dead_methods (self) on */ +var53 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_skip_dead_methods].val; /* _opt_skip_dead_methods on */ +if (unlikely(var53 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_skip_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 41); +show_backtrace(1); +} +var51 = var53; +RET_LABEL52:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_semi_global (self) on */ +var56 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_semi_global].val; /* _opt_semi_global on */ +if (unlikely(var56 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_semi_global"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 43); +show_backtrace(1); +} +var54 = var56; +RET_LABEL55:(void)0; +} +} +var57 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var57 = array_instance Array[Option] */ +var58 = 5; +var59 = NEW_standard__NativeArray(var58, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var59)->values[0] = (val*) var42; +((struct instance_standard__NativeArray*)var59)->values[1] = (val*) var45; +((struct instance_standard__NativeArray*)var59)->values[2] = (val*) var48; +((struct instance_standard__NativeArray*)var59)->values[3] = (val*) var51; +((struct instance_standard__NativeArray*)var59)->values[4] = (val*) var54; +{ +((void (*)(val* self, val* p0, long p1))(var57->class->vft[COLOR_standard__array__Array__with_native]))(var57, var59, var58) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var39, var57); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var62 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var62 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var60 = var62; +RET_LABEL61:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_colo_dead_methods (self) on */ +var65 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colo_dead_methods].val; /* _opt_colo_dead_methods on */ +if (unlikely(var65 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colo_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 45); +show_backtrace(1); +} +var63 = var65; +RET_LABEL64:(void)0; +} +} +var66 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var66 = array_instance Array[Option] */ +var67 = 1; +var68 = NEW_standard__NativeArray(var67, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var68)->values[0] = (val*) var63; +{ +((void (*)(val* self, val* p0, long p1))(var66->class->vft[COLOR_standard__array__Array__with_native]))(var66, var68, var67) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var60, var66); /* Direct call opts#OptionContext#add_option on */ +} +{ +{ /* Inline toolcontext#ToolContext#option_context (self) on */ +var71 = self->attrs[COLOR_nit__toolcontext__ToolContext___option_context].val; /* _option_context on */ +if (unlikely(var71 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _option_context"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 270); +show_backtrace(1); +} +var69 = var71; +RET_LABEL70:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_tables_metrics (self) on */ +var74 = self->attrs[COLOR_nit__separate_compiler__ToolContext___opt_tables_metrics].val; /* _opt_tables_metrics on */ +if (unlikely(var74 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_tables_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 47); +show_backtrace(1); +} +var72 = var74; +RET_LABEL73:(void)0; +} +} +var75 = NEW_standard__Array(&type_standard__Array__opts__Option); +{ /* var75 = array_instance Array[Option] */ +var76 = 1; +var77 = NEW_standard__NativeArray(var76, &type_standard__NativeArray__opts__Option); +((struct instance_standard__NativeArray*)var77)->values[0] = (val*) var72; +{ +((void (*)(val* self, val* p0, long p1))(var75->class->vft[COLOR_standard__array__Array__with_native]))(var75, var77, var76) /* with_native on */; +} +} +{ +opts___opts__OptionContext___add_option(var69, var75); /* Direct call opts#OptionContext#add_option on */ +} +RET_LABEL:; +} +/* method separate_compiler#ToolContext#process_options for (self: ToolContext, Sequence[String]) */ +void nit__separate_compiler___ToolContext___process_options(val* self, val* p0) { +val* var_args /* var args: Sequence[String] */; +val* var_tc /* var tc: ToolContext */; +val* var /* : OptionBool */; +val* var2 /* : OptionBool */; +val* var3 /* : nullable Object */; +val* var5 /* : nullable Object */; +short int var6 /* : Bool */; +val* var7 /* : OptionBool */; +val* var9 /* : OptionBool */; +short int var10 /* : Bool */; +short int var12 /* : Bool */; +int cltype; +int idtype; +const struct type* type_struct; +const char* var_class_name; +val* var13 /* : nullable Object */; +val* var14 /* : OptionBool */; +val* var16 /* : OptionBool */; +short int var17 /* : Bool */; +short int var19 /* : Bool */; +int cltype20; +int idtype21; +const struct type* type_struct22; +const char* var_class_name23; +val* var24 /* : nullable Object */; +val* var25 /* : OptionBool */; +val* var27 /* : OptionBool */; +short int var28 /* : Bool */; +short int var30 /* : Bool */; +int cltype31; +int idtype32; +const struct type* type_struct33; +const char* var_class_name34; +val* var35 /* : nullable Object */; +val* var36 /* : OptionBool */; +val* var38 /* : OptionBool */; +short int var39 /* : Bool */; +short int var41 /* : Bool */; +int cltype42; +int idtype43; +const struct type* type_struct44; +const char* var_class_name45; +val* var46 /* : nullable Object */; +var_args = p0; +{ +((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit__separate_compiler___ToolContext___process_options]))(self, p0) /* process_options on */; +} +var_tc = self; +{ +{ /* Inline separate_compiler#ToolContext#opt_semi_global (var_tc) on */ +var2 = var_tc->attrs[COLOR_nit__separate_compiler__ToolContext___opt_semi_global].val; /* _opt_semi_global on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_semi_global"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 43); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var) on */ +var5 = var->attrs[COLOR_opts__Option___value].val; /* _value on */ +var3 = var5; +RET_LABEL4:(void)0; +} +} +var6 = ((struct instance_standard__Bool*)var3)->value; /* autounbox from nullable Object to Bool */; +if (var6){ +{ +{ /* Inline separate_compiler#ToolContext#opt_inline_coloring_numbers (var_tc) on */ +var9 = var_tc->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_coloring_numbers].val; /* _opt_inline_coloring_numbers on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_coloring_numbers"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 35); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +var10 = 1; +{ +{ /* Inline opts#Option#value= (var7,var10) on */ +/* Covariant cast for argument 0 (value) isa VALUE */ +/* isa VALUE */ +type_struct = var7->type->resolution_table->types[COLOR_opts__Option__VALUE]; +cltype = type_struct->color; +idtype = type_struct->id; +if(cltype >= (&type_standard__Bool)->table_size) { +var12 = 0; +} else { +var12 = (&type_standard__Bool)->type_table[cltype] == idtype; +} +if (unlikely(!var12)) { +var_class_name = type_standard__Bool.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VALUE", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_opts, 40); +show_backtrace(1); +} +var13 = BOX_standard__Bool(var10); /* autobox from Bool to nullable Object */ +var7->attrs[COLOR_opts__Option___value].val = var13; /* _value on */ +RET_LABEL11:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_inline_some_methods (var_tc) on */ +var16 = var_tc->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_some_methods].val; /* _opt_inline_some_methods on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_some_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 37); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +var17 = 1; +{ +{ /* Inline opts#Option#value= (var14,var17) on */ +/* Covariant cast for argument 0 (value) isa VALUE */ +/* isa VALUE */ +type_struct22 = var14->type->resolution_table->types[COLOR_opts__Option__VALUE]; +cltype20 = type_struct22->color; +idtype21 = type_struct22->id; +if(cltype20 >= (&type_standard__Bool)->table_size) { +var19 = 0; +} else { +var19 = (&type_standard__Bool)->type_table[cltype20] == idtype21; +} +if (unlikely(!var19)) { +var_class_name23 = type_standard__Bool.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VALUE", var_class_name23); +PRINT_ERROR(" (%s:%d)\n", FILE_opts, 40); +show_backtrace(1); +} +var24 = BOX_standard__Bool(var17); /* autobox from Bool to nullable Object */ +var14->attrs[COLOR_opts__Option___value].val = var24; /* _value on */ +RET_LABEL18:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_direct_call_monomorph (var_tc) on */ +var27 = var_tc->attrs[COLOR_nit__separate_compiler__ToolContext___opt_direct_call_monomorph].val; /* _opt_direct_call_monomorph on */ +if (unlikely(var27 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_direct_call_monomorph"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 39); +show_backtrace(1); +} +var25 = var27; +RET_LABEL26:(void)0; +} +} +var28 = 1; +{ +{ /* Inline opts#Option#value= (var25,var28) on */ +/* Covariant cast for argument 0 (value) isa VALUE */ +/* isa VALUE */ +type_struct33 = var25->type->resolution_table->types[COLOR_opts__Option__VALUE]; +cltype31 = type_struct33->color; +idtype32 = type_struct33->id; +if(cltype31 >= (&type_standard__Bool)->table_size) { +var30 = 0; +} else { +var30 = (&type_standard__Bool)->type_table[cltype31] == idtype32; +} +if (unlikely(!var30)) { +var_class_name34 = type_standard__Bool.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VALUE", var_class_name34); +PRINT_ERROR(" (%s:%d)\n", FILE_opts, 40); +show_backtrace(1); +} +var35 = BOX_standard__Bool(var28); /* autobox from Bool to nullable Object */ +var25->attrs[COLOR_opts__Option___value].val = var35; /* _value on */ +RET_LABEL29:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_skip_dead_methods (var_tc) on */ +var38 = var_tc->attrs[COLOR_nit__separate_compiler__ToolContext___opt_skip_dead_methods].val; /* _opt_skip_dead_methods on */ +if (unlikely(var38 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_skip_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 41); +show_backtrace(1); +} +var36 = var38; +RET_LABEL37:(void)0; +} +} +var39 = 1; +{ +{ /* Inline opts#Option#value= (var36,var39) on */ +/* Covariant cast for argument 0 (value) isa VALUE */ +/* isa VALUE */ +type_struct44 = var36->type->resolution_table->types[COLOR_opts__Option__VALUE]; +cltype42 = type_struct44->color; +idtype43 = type_struct44->id; +if(cltype42 >= (&type_standard__Bool)->table_size) { +var41 = 0; +} else { +var41 = (&type_standard__Bool)->type_table[cltype42] == idtype43; +} +if (unlikely(!var41)) { +var_class_name45 = type_standard__Bool.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VALUE", var_class_name45); +PRINT_ERROR(" (%s:%d)\n", FILE_opts, 40); +show_backtrace(1); +} +var46 = BOX_standard__Bool(var39); /* autobox from Bool to nullable Object */ +var36->attrs[COLOR_opts__Option___value].val = var46; /* _value on */ +RET_LABEL40:(void)0; +} +} +} else { +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompilerPhase#process_mainmodule for (self: SeparateCompilerPhase, MModule, SequenceRead[MModule]) */ +void nit___nit__SeparateCompilerPhase___nit__modelbuilder__Phase__process_mainmodule(val* self, val* p0, val* p1) { +val* var_mainmodule /* var mainmodule: MModule */; +val* var_given_mmodules /* var given_mmodules: SequenceRead[MModule] */; +val* var /* : ToolContext */; +val* var2 /* : ToolContext */; +val* var3 /* : OptionBool */; +val* var5 /* : OptionBool */; +val* var6 /* : nullable Object */; +val* var8 /* : nullable Object */; +short int var9 /* : Bool */; +short int var10 /* : Bool */; +val* var11 /* : ToolContext */; +val* var13 /* : ToolContext */; +val* var14 /* : ModelBuilder */; +val* var_modelbuilder /* var modelbuilder: ModelBuilder */; +val* var15 /* : RapidTypeAnalysis */; +val* var_analysis /* var analysis: RapidTypeAnalysis */; +var_mainmodule = p0; +var_given_mmodules = p1; +{ +{ /* 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; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_separate (var) on */ +var5 = var->attrs[COLOR_nit__separate_compiler__ToolContext___opt_separate].val; /* _opt_separate on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_separate"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 24); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var3) on */ +var8 = var3->attrs[COLOR_opts__Option___value].val; /* _value on */ +var6 = var8; +RET_LABEL7:(void)0; +} +} +var9 = ((struct instance_standard__Bool*)var6)->value; /* autounbox from nullable Object to Bool */; +var10 = !var9; +if (var10){ +goto RET_LABEL; +} else { +} +{ +{ /* Inline phase#Phase#toolcontext (self) on */ +var13 = self->attrs[COLOR_nit__phase__Phase___toolcontext].val; /* _toolcontext on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__phase, 201); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +var14 = nit__modelbuilder_base___ToolContext___modelbuilder(var11); +} +var_modelbuilder = var14; +{ +var15 = nit__rapid_type_analysis___ModelBuilder___do_rapid_type_analysis(var_modelbuilder, var_mainmodule); +} +var_analysis = var15; +{ +nit__separate_compiler___ModelBuilder___run_separate_compiler(var_modelbuilder, var_mainmodule, var_analysis); /* Direct call separate_compiler#ModelBuilder#run_separate_compiler on */ +} +RET_LABEL:; +} +/* method separate_compiler#ModelBuilder#run_separate_compiler for (self: ModelBuilder, MModule, nullable RapidTypeAnalysis) */ +void nit__separate_compiler___ModelBuilder___run_separate_compiler(val* self, val* p0, val* p1) { +val* var_mainmodule /* var mainmodule: MModule */; +val* var_runtime_type_analysis /* var runtime_type_analysis: nullable RapidTypeAnalysis */; +long var /* : Int */; +long var2 /* : Int for extern */; +long var_time0 /* var time0: Int */; +val* var3 /* : ToolContext */; +val* var5 /* : ToolContext */; +static val* varonce; +val* var6 /* : String */; +char* var7 /* : NativeString */; +long var8 /* : Int */; +val* var9 /* : FlatString */; +long var10 /* : Int */; +val* var11 /* : SeparateCompiler */; +val* var_compiler /* var compiler: SeparateCompiler */; +long var12 /* : Int */; +long var14 /* : Int for extern */; +long var_time1 /* var time1: Int */; +val* var15 /* : ToolContext */; +val* var17 /* : ToolContext */; +static val* varonce18; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +long var23 /* : Int */; +short int var25 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var26 /* : Int */; +static val* varonce27; +val* var28 /* : String */; +char* var29 /* : NativeString */; +long var30 /* : Int */; +val* var31 /* : FlatString */; +val* var32 /* : Array[Object] */; +long var33 /* : Int */; +val* var34 /* : NativeArray[Object] */; +val* var35 /* : Object */; +val* var36 /* : String */; +long var37 /* : Int */; +var_mainmodule = p0; +var_runtime_type_analysis = p1; +{ +{ /* Inline time#Object#get_time (self) on */ +var2 = kernel_Any_Any_get_time_0(self); +var = var2; +goto RET_LABEL1; +RET_LABEL1:(void)0; +} +} +var_time0 = var; +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (self) on */ +var5 = self->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +if (varonce) { +var6 = varonce; +} else { +var7 = "*** GENERATING C ***"; +var8 = 20; +var9 = standard___standard__NativeString___to_s_with_length(var7, var8); +var6 = var9; +varonce = var6; +} +var10 = 1; +{ +nit___nit__ToolContext___info(var3, var6, var10); /* Direct call toolcontext#ToolContext#info on */ +} +var11 = NEW_nit__SeparateCompiler(&type_nit__SeparateCompiler); +{ +((void (*)(val* self, val* p0))(var11->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__mainmodule_61d]))(var11, var_mainmodule) /* mainmodule= on */; +} +{ +((void (*)(val* self, val* p0))(var11->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__modelbuilder_61d]))(var11, self) /* modelbuilder= on */; +} +{ +((void (*)(val* self, val* p0))(var11->class->vft[COLOR_nit__separate_compiler__SeparateCompiler__runtime_type_analysis_61d]))(var11, var_runtime_type_analysis) /* runtime_type_analysis= on */; +} +{ +((void (*)(val* self))(var11->class->vft[COLOR_standard__kernel__Object__init]))(var11) /* init on */; +} +var_compiler = var11; +{ +nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__do_compilation(var_compiler); /* Direct call separate_compiler#SeparateCompiler#do_compilation on */ +} +{ +nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__display_stats(var_compiler); /* Direct call separate_compiler#SeparateCompiler#display_stats on */ +} +{ +{ /* Inline time#Object#get_time (self) on */ +var14 = kernel_Any_Any_get_time_0(self); +var12 = var14; +goto RET_LABEL13; +RET_LABEL13:(void)0; +} +} +var_time1 = var12; +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (self) on */ +var17 = self->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +if (varonce18) { +var19 = varonce18; +} else { +var20 = "*** END GENERATING C: "; +var21 = 22; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce18 = var19; +} +{ +{ /* Inline kernel#Int#- (var_time1,var_time0) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var25 = 1; /* easy isa OTHER*/ +if (unlikely(!var25)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 416); +show_backtrace(1); +} +var26 = var_time1 - var_time0; +var23 = var26; +goto RET_LABEL24; +RET_LABEL24:(void)0; +} +} +if (varonce27) { +var28 = varonce27; +} else { +var29 = " ***"; +var30 = 4; +var31 = standard___standard__NativeString___to_s_with_length(var29, var30); +var28 = var31; +varonce27 = var28; +} +var32 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var32 = array_instance Array[Object] */ +var33 = 3; +var34 = NEW_standard__NativeArray(var33, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var34)->values[0] = (val*) var19; +var35 = BOX_standard__Int(var23); /* autobox from Int to Object */ +((struct instance_standard__NativeArray*)var34)->values[1] = (val*) var35; +((struct instance_standard__NativeArray*)var34)->values[2] = (val*) var28; +{ +((void (*)(val* self, val* p0, long p1))(var32->class->vft[COLOR_standard__array__Array__with_native]))(var32, var34, var33) /* with_native on */; +} +} +{ +var36 = ((val* (*)(val* self))(var32->class->vft[COLOR_standard__string__Object__to_s]))(var32) /* to_s on */; +} +var37 = 2; +{ +nit___nit__ToolContext___info(var15, var36, var37); /* Direct call toolcontext#ToolContext#info on */ +} +{ +nit__abstract_compiler___ModelBuilder___write_and_make(self, var_compiler); /* Direct call abstract_compiler#ModelBuilder#write_and_make on */ +} +RET_LABEL:; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_tables for (self: ModelBuilder): Int */ +long nit__separate_compiler___ModelBuilder___nb_invok_by_tables(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_tables= for (self: ModelBuilder, Int) */ +void nit__separate_compiler___ModelBuilder___nb_invok_by_tables_61d(val* self, long p0) { +self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l = p0; /* _nb_invok_by_tables on */ +RET_LABEL:; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_direct for (self: ModelBuilder): Int */ +long nit__separate_compiler___ModelBuilder___nb_invok_by_direct(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_direct= for (self: ModelBuilder, Int) */ +void nit__separate_compiler___ModelBuilder___nb_invok_by_direct_61d(val* self, long p0) { +self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l = p0; /* _nb_invok_by_direct on */ +RET_LABEL:; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_inline for (self: ModelBuilder): Int */ +long nit__separate_compiler___ModelBuilder___nb_invok_by_inline(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#ModelBuilder#nb_invok_by_inline= for (self: ModelBuilder, Int) */ +void nit__separate_compiler___ModelBuilder___nb_invok_by_inline_61d(val* self, long p0) { +self->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l = p0; /* _nb_invok_by_inline on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#runtime_type_analysis for (self: SeparateCompiler): nullable RapidTypeAnalysis */ +val* nit___nit__SeparateCompiler___runtime_type_analysis(val* self) { +val* var /* : nullable RapidTypeAnalysis */; +val* var1 /* : nullable RapidTypeAnalysis */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#runtime_type_analysis= for (self: SeparateCompiler, nullable RapidTypeAnalysis) */ +void nit___nit__SeparateCompiler___runtime_type_analysis_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val = p0; /* _runtime_type_analysis on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#undead_types for (self: SeparateCompiler): Set[MType] */ +val* nit___nit__SeparateCompiler___undead_types(val* self) { +val* var /* : Set[MType] */; +val* var1 /* : Set[MType] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 121); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#live_unresolved_types for (self: SeparateCompiler): Map[MClassDef, Set[MType]] */ +val* nit___nit__SeparateCompiler___live_unresolved_types(val* self) { +val* var /* : Map[MClassDef, Set[MType]] */; +val* var1 /* : Map[MClassDef, Set[MType]] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___live_unresolved_types].val; /* _live_unresolved_types on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_unresolved_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 122); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_ids for (self: SeparateCompiler): Map[MType, Int] */ +val* nit___nit__SeparateCompiler___type_ids(val* self) { +val* var /* : Map[MType, Int] */; +val* var1 /* : Map[MType, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 124); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_ids= for (self: SeparateCompiler, Map[MType, Int]) */ +void nit___nit__SeparateCompiler___type_ids_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val = p0; /* _type_ids on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#type_colors for (self: SeparateCompiler): Map[MType, Int] */ +val* nit___nit__SeparateCompiler___type_colors(val* self) { +val* var /* : Map[MType, Int] */; +val* var1 /* : Map[MType, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_colors].val; /* _type_colors on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 125); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_colors= for (self: SeparateCompiler, Map[MType, Int]) */ +void nit___nit__SeparateCompiler___type_colors_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_colors].val = p0; /* _type_colors on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#opentype_colors for (self: SeparateCompiler): Map[MType, Int] */ +val* nit___nit__SeparateCompiler___opentype_colors(val* self) { +val* var /* : Map[MType, Int] */; +val* var1 /* : Map[MType, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val; /* _opentype_colors on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opentype_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 126); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#opentype_colors= for (self: SeparateCompiler, Map[MType, Int]) */ +void nit___nit__SeparateCompiler___opentype_colors_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val = p0; /* _opentype_colors on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#method_colors for (self: SeparateCompiler): Map[PropertyLayoutElement, Int] */ +val* nit___nit__SeparateCompiler___method_colors(val* self) { +val* var /* : Map[PropertyLayoutElement, Int] */; +val* var1 /* : Map[PropertyLayoutElement, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val; /* _method_colors on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 127); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#method_colors= for (self: SeparateCompiler, Map[PropertyLayoutElement, Int]) */ +void nit___nit__SeparateCompiler___method_colors_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val = p0; /* _method_colors on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#attr_colors for (self: SeparateCompiler): Map[MAttribute, Int] */ +val* nit___nit__SeparateCompiler___attr_colors(val* self) { +val* var /* : Map[MAttribute, Int] */; +val* var1 /* : Map[MAttribute, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val; /* _attr_colors on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 128); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#attr_colors= for (self: SeparateCompiler, Map[MAttribute, Int]) */ +void nit___nit__SeparateCompiler___attr_colors_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val = p0; /* _attr_colors on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#init for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___standard__kernel__Object__init(val* self) { +static val* varonce; +val* var /* : String */; +char* var1 /* : NativeString */; +long var2 /* : Int */; +val* var3 /* : FlatString */; +val* var4 /* : CodeFile */; +val* var_file /* var file: CodeFile */; +val* var5 /* : CodeWriter */; +{ +((void (*)(val* self))(self->class->vft[COLOR_nit___nit__SeparateCompiler___standard__kernel__Object__init]))(self) /* init on */; +} +if (varonce) { +var = varonce; +} else { +var1 = "nit.common"; +var2 = 10; +var3 = standard___standard__NativeString___to_s_with_length(var1, var2); +var = var3; +varonce = var; +} +{ +var4 = nit___nit__AbstractCompiler___new_file(self, var); +} +var_file = var4; +var5 = NEW_nit__CodeWriter(&type_nit__CodeWriter); +{ +((void (*)(val* self, val* p0))(var5->class->vft[COLOR_nit__abstract_compiler__CodeWriter__file_61d]))(var5, var_file) /* file= on */; +} +{ +((void (*)(val* self))(var5->class->vft[COLOR_standard__kernel__Object__init]))(var5) /* init on */; +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header= (self,var5) on */ +self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val = var5; /* _header on */ +RET_LABEL6:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_box_kinds(self); /* Direct call separate_compiler#SeparateCompiler#compile_box_kinds on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#do_compilation for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__do_compilation(val* self) { +val* var_compiler /* var compiler: SeparateCompiler */; +val* var /* : MModule */; +val* var2 /* : MModule */; +val* var3 /* : String */; +val* var_c_name /* var c_name: String */; +val* var4 /* : ModelBuilder */; +val* var6 /* : ModelBuilder */; +val* var7 /* : ToolContext */; +val* var9 /* : ToolContext */; +static val* varonce; +val* var10 /* : String */; +char* var11 /* : NativeString */; +long var12 /* : Int */; +val* var13 /* : FlatString */; +long var14 /* : Int */; +static val* varonce15; +val* var16 /* : String */; +char* var17 /* : NativeString */; +long var18 /* : Int */; +val* var19 /* : FlatString */; +val* var20 /* : Array[Object] */; +long var21 /* : Int */; +val* var22 /* : NativeArray[Object] */; +val* var23 /* : String */; +val* var24 /* : CodeFile */; +val* var25 /* : MModule */; +val* var27 /* : MModule */; +val* var28 /* : POSetElement[MModule] */; +val* var30 /* : POSetElement[MModule] */; +val* var31 /* : Collection[nullable Object] */; +val* var_ /* var : Collection[MModule] */; +val* var32 /* : Iterator[nullable Object] */; +val* var_33 /* var : Iterator[MModule] */; +short int var34 /* : Bool */; +val* var35 /* : nullable Object */; +val* var_m /* var m: MModule */; +val* var36 /* : Array[MClass] */; +val* var38 /* : Array[MClass] */; +val* var_39 /* var : Array[MClass] */; +val* var40 /* : ArrayIterator[nullable Object] */; +val* var_41 /* var : ArrayIterator[MClass] */; +short int var42 /* : Bool */; +val* var43 /* : nullable Object */; +val* var_mclass /* var mclass: MClass */; +static val* varonce47; +val* var48 /* : String */; +char* var49 /* : NativeString */; +long var50 /* : Int */; +val* var51 /* : FlatString */; +val* var52 /* : Array[Object] */; +long var53 /* : Int */; +val* var54 /* : NativeArray[Object] */; +val* var55 /* : String */; +val* var56 /* : CodeFile */; +val* var57 /* : MModule */; +val* var59 /* : MModule */; +val* var60 /* : POSetElement[MModule] */; +val* var62 /* : POSetElement[MModule] */; +val* var63 /* : Collection[nullable Object] */; +val* var_64 /* var : Collection[MModule] */; +val* var65 /* : Iterator[nullable Object] */; +val* var_66 /* var : Iterator[MModule] */; +short int var67 /* : Bool */; +val* var68 /* : nullable Object */; +val* var_m69 /* var m: MModule */; +val* var70 /* : ModelBuilder */; +val* var72 /* : ModelBuilder */; +val* var73 /* : ToolContext */; +val* var75 /* : ToolContext */; +static val* varonce76; +val* var77 /* : String */; +char* var78 /* : NativeString */; +long var79 /* : Int */; +val* var80 /* : FlatString */; +val* var81 /* : String */; +val* var82 /* : Array[Object] */; +long var83 /* : Int */; +val* var84 /* : NativeArray[Object] */; +val* var85 /* : String */; +long var86 /* : Int */; +val* var87 /* : String */; +static val* varonce88; +val* var89 /* : String */; +char* var90 /* : NativeString */; +long var91 /* : Int */; +val* var92 /* : FlatString */; +val* var93 /* : Array[Object] */; +long var94 /* : Int */; +val* var95 /* : NativeArray[Object] */; +val* var96 /* : String */; +val* var97 /* : CodeFile */; +val* var100 /* : ModelBuilder */; +val* var102 /* : ModelBuilder */; +val* var103 /* : ToolContext */; +val* var105 /* : ToolContext */; +static val* varonce106; +val* var107 /* : String */; +char* var108 /* : NativeString */; +long var109 /* : Int */; +val* var110 /* : FlatString */; +long var111 /* : Int */; +static val* varonce112; +val* var113 /* : String */; +char* var114 /* : NativeString */; +long var115 /* : Int */; +val* var116 /* : FlatString */; +val* var117 /* : Array[Object] */; +long var118 /* : Int */; +val* var119 /* : NativeArray[Object] */; +val* var120 /* : String */; +val* var121 /* : CodeFile */; +var_compiler = self; +{ +nit___nit__AbstractCompiler___compile_header(var_compiler); /* Direct call abstract_compiler#AbstractCompiler#compile_header on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = nit___nit__MModule___nit__model_base__MEntity__c_name(var); +} +var_c_name = var3; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var6 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var4) on */ +var9 = var4->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +if (varonce) { +var10 = varonce; +} else { +var11 = "Property coloring"; +var12 = 17; +var13 = standard___standard__NativeString___to_s_with_length(var11, var12); +var10 = var13; +varonce = var10; +} +var14 = 2; +{ +nit___nit__ToolContext___info(var7, var10, var14); /* Direct call toolcontext#ToolContext#info on */ +} +if (varonce15) { +var16 = varonce15; +} else { +var17 = ".classes"; +var18 = 8; +var19 = standard___standard__NativeString___to_s_with_length(var17, var18); +var16 = var19; +varonce15 = var16; +} +var20 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var20 = array_instance Array[Object] */ +var21 = 2; +var22 = NEW_standard__NativeArray(var21, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var22)->values[0] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var22)->values[1] = (val*) var16; +{ +((void (*)(val* self, val* p0, long p1))(var20->class->vft[COLOR_standard__array__Array__with_native]))(var20, var22, var21) /* with_native on */; +} +} +{ +var23 = ((val* (*)(val* self))(var20->class->vft[COLOR_standard__string__Object__to_s]))(var20) /* to_s on */; +} +{ +var24 = nit___nit__AbstractCompiler___new_file(var_compiler, var23); +} +{ +nit___nit__SeparateCompiler___do_property_coloring(var_compiler); /* Direct call separate_compiler#SeparateCompiler#do_property_coloring on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var27 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var27 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var25 = var27; +RET_LABEL26:(void)0; +} +} +{ +{ /* Inline mmodule#MModule#in_importation (var25) on */ +var30 = var25->attrs[COLOR_nit__mmodule__MModule___in_importation].val; /* _in_importation on */ +if (unlikely(var30 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _in_importation"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__mmodule, 96); +show_backtrace(1); +} +var28 = var30; +RET_LABEL29:(void)0; +} +} +{ +var31 = poset___poset__POSetElement___greaters(var28); +} +var_ = var31; +{ +var32 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on */; +} +var_33 = var32; +for(;;) { +{ +var34 = ((short int (*)(val* self))(var_33->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_33) /* is_ok on */; +} +if (var34){ +{ +var35 = ((val* (*)(val* self))(var_33->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_33) /* item on */; +} +var_m = var35; +{ +{ /* Inline model#MModule#intro_mclasses (var_m) on */ +var38 = var_m->attrs[COLOR_nit__model__MModule___intro_mclasses].val; /* _intro_mclasses on */ +if (unlikely(var38 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mclasses"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 128); +show_backtrace(1); +} +var36 = var38; +RET_LABEL37:(void)0; +} +} +var_39 = var36; +{ +var40 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_39); +} +var_41 = var40; +for(;;) { +{ +var42 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_41); +} +if (var42){ +{ +var43 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_41); +} +var_mclass = var43; +{ +((void (*)(val* self, val* p0))(var_compiler->class->vft[COLOR_nit__separate_compiler__SeparateCompiler__compile_class_to_c]))(var_compiler, var_mclass) /* compile_class_to_c on */; +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_41); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_41) on */ +RET_LABEL44:(void)0; +} +} +{ +((void (*)(val* self))(var_33->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_33) /* next on */; +} +} else { +goto BREAK_label45; +} +} +BREAK_label45: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_33) on */ +RET_LABEL46:(void)0; +} +} +if (varonce47) { +var48 = varonce47; +} else { +var49 = ".main"; +var50 = 5; +var51 = standard___standard__NativeString___to_s_with_length(var49, var50); +var48 = var51; +varonce47 = var48; +} +var52 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var52 = array_instance Array[Object] */ +var53 = 2; +var54 = NEW_standard__NativeArray(var53, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var54)->values[0] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var54)->values[1] = (val*) var48; +{ +((void (*)(val* self, val* p0, long p1))(var52->class->vft[COLOR_standard__array__Array__with_native]))(var52, var54, var53) /* with_native on */; +} +} +{ +var55 = ((val* (*)(val* self))(var52->class->vft[COLOR_standard__string__Object__to_s]))(var52) /* to_s on */; +} +{ +var56 = nit___nit__AbstractCompiler___new_file(var_compiler, var55); +} +{ +nit___nit__AbstractCompiler___compile_nitni_global_ref_functions(var_compiler); /* Direct call abstract_compiler#AbstractCompiler#compile_nitni_global_ref_functions on */ +} +{ +nit___nit__AbstractCompiler___compile_main_function(var_compiler); /* Direct call abstract_compiler#AbstractCompiler#compile_main_function on */ +} +{ +nit___nit__AbstractCompiler___compile_finalizer_function(var_compiler); /* Direct call abstract_compiler#AbstractCompiler#compile_finalizer_function on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var59 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var59 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var57 = var59; +RET_LABEL58:(void)0; +} +} +{ +{ /* Inline mmodule#MModule#in_importation (var57) on */ +var62 = var57->attrs[COLOR_nit__mmodule__MModule___in_importation].val; /* _in_importation on */ +if (unlikely(var62 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _in_importation"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__mmodule, 96); +show_backtrace(1); +} +var60 = var62; +RET_LABEL61:(void)0; +} +} +{ +var63 = poset___poset__POSetElement___greaters(var60); +} +var_64 = var63; +{ +var65 = ((val* (*)(val* self))(var_64->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_64) /* iterator on */; +} +var_66 = var65; +for(;;) { +{ +var67 = ((short int (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_66) /* is_ok on */; +} +if (var67){ +{ +var68 = ((val* (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_66) /* item on */; +} +var_m69 = var68; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var72 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var72 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var70 = var72; +RET_LABEL71:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var70) on */ +var75 = var70->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var75 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var73 = var75; +RET_LABEL74:(void)0; +} +} +if (varonce76) { +var77 = varonce76; +} else { +var78 = "Generate C for module "; +var79 = 22; +var80 = standard___standard__NativeString___to_s_with_length(var78, var79); +var77 = var80; +varonce76 = var77; +} +{ +var81 = nit___nit__MModule___nit__model_base__MEntity__full_name(var_m69); +} +var82 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var82 = array_instance Array[Object] */ +var83 = 2; +var84 = NEW_standard__NativeArray(var83, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var84)->values[0] = (val*) var77; +((struct instance_standard__NativeArray*)var84)->values[1] = (val*) var81; +{ +((void (*)(val* self, val* p0, long p1))(var82->class->vft[COLOR_standard__array__Array__with_native]))(var82, var84, var83) /* with_native on */; +} +} +{ +var85 = ((val* (*)(val* self))(var82->class->vft[COLOR_standard__string__Object__to_s]))(var82) /* to_s on */; +} +var86 = 2; +{ +nit___nit__ToolContext___info(var73, var85, var86); /* Direct call toolcontext#ToolContext#info on */ +} +{ +var87 = nit___nit__MModule___nit__model_base__MEntity__c_name(var_m69); +} +if (varonce88) { +var89 = varonce88; +} else { +var90 = ".sep"; +var91 = 4; +var92 = standard___standard__NativeString___to_s_with_length(var90, var91); +var89 = var92; +varonce88 = var89; +} +var93 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var93 = array_instance Array[Object] */ +var94 = 2; +var95 = NEW_standard__NativeArray(var94, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var95)->values[0] = (val*) var87; +((struct instance_standard__NativeArray*)var95)->values[1] = (val*) var89; +{ +((void (*)(val* self, val* p0, long p1))(var93->class->vft[COLOR_standard__array__Array__with_native]))(var93, var95, var94) /* with_native on */; +} +} +{ +var96 = ((val* (*)(val* self))(var93->class->vft[COLOR_standard__string__Object__to_s]))(var93) /* to_s on */; +} +{ +var97 = nit___nit__AbstractCompiler___new_file(var_compiler, var96); +} +{ +nit___nit__SeparateCompiler___compile_module_to_c(var_compiler, var_m69); /* Direct call separate_compiler#SeparateCompiler#compile_module_to_c on */ +} +{ +((void (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_66) /* next on */; +} +} else { +goto BREAK_label98; +} +} +BREAK_label98: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_66) on */ +RET_LABEL99:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var102 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var102 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var100 = var102; +RET_LABEL101:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var100) on */ +var105 = var100->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var105 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var103 = var105; +RET_LABEL104:(void)0; +} +} +if (varonce106) { +var107 = varonce106; +} else { +var108 = "Type coloring"; +var109 = 13; +var110 = standard___standard__NativeString___to_s_with_length(var108, var109); +var107 = var110; +varonce106 = var107; +} +var111 = 2; +{ +nit___nit__ToolContext___info(var103, var107, var111); /* Direct call toolcontext#ToolContext#info on */ +} +if (varonce112) { +var113 = varonce112; +} else { +var114 = ".types"; +var115 = 6; +var116 = standard___standard__NativeString___to_s_with_length(var114, var115); +var113 = var116; +varonce112 = var113; +} +var117 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var117 = array_instance Array[Object] */ +var118 = 2; +var119 = NEW_standard__NativeArray(var118, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var119)->values[0] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var119)->values[1] = (val*) var113; +{ +((void (*)(val* self, val* p0, long p1))(var117->class->vft[COLOR_standard__array__Array__with_native]))(var117, var119, var118) /* with_native on */; +} +} +{ +var120 = ((val* (*)(val* self))(var117->class->vft[COLOR_standard__string__Object__to_s]))(var117) /* to_s on */; +} +{ +var121 = nit___nit__AbstractCompiler___new_file(var_compiler, var120); +} +{ +((void (*)(val* self))(var_compiler->class->vft[COLOR_nit__separate_compiler__SeparateCompiler__compile_types]))(var_compiler) /* compile_types on */; +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_types for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___compile_types(val* self) { +val* var_compiler /* var compiler: SeparateCompiler */; +val* var /* : POSet[MType] */; +val* var_mtypes /* var mtypes: POSet[MType] */; +val* var_ /* var : POSet[MType] */; +val* var1 /* : Iterator[nullable Object] */; +val* var_2 /* var : Iterator[MType] */; +short int var3 /* : Bool */; +val* var4 /* : nullable Object */; +val* var_t /* var t: MType */; +val* var6 /* : Set[MType] */; +val* var8 /* : Set[MType] */; +val* var_9 /* var : Set[MType] */; +val* var10 /* : Iterator[nullable Object] */; +val* var_11 /* var : Iterator[MType] */; +short int var12 /* : Bool */; +val* var13 /* : nullable Object */; +val* var_t14 /* var t: MType */; +short int var15 /* : Bool */; +var_compiler = self; +{ +var = nit___nit__SeparateCompiler___do_type_coloring(var_compiler); +} +var_mtypes = var; +var_ = var_mtypes; +{ +var1 = poset___poset__POSet___standard__abstract_collection__Collection__iterator(var_); +} +var_2 = var1; +for(;;) { +{ +var3 = ((short int (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_2) /* is_ok on */; +} +if (var3){ +{ +var4 = ((val* (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_2) /* item on */; +} +var_t = var4; +{ +nit___nit__SeparateCompiler___compile_type_to_c(var_compiler, var_t); /* Direct call separate_compiler#SeparateCompiler#compile_type_to_c on */ +} +{ +((void (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_2) /* next on */; +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_2) on */ +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline separate_compiler#SeparateCompiler#undead_types (var_compiler) on */ +var8 = var_compiler->attrs[COLOR_nit__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 121); +show_backtrace(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +var_9 = var6; +{ +var10 = ((val* (*)(val* self))(var_9->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_9) /* iterator on */; +} +var_11 = var10; +for(;;) { +{ +var12 = ((short int (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_11) /* is_ok on */; +} +if (var12){ +{ +var13 = ((val* (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_11) /* item on */; +} +var_t14 = var13; +{ +var15 = poset___poset__POSet___standard__abstract_collection__Collection__has(var_mtypes, var_t14); +} +if (var15){ +goto BREAK_label16; +} else { +} +{ +nit___nit__SeparateCompiler___compile_type_to_c(var_compiler, var_t14); /* Direct call separate_compiler#SeparateCompiler#compile_type_to_c on */ +} +BREAK_label16: (void)0; +{ +((void (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_11) /* next on */; +} +} else { +goto BREAK_label17; +} +} +BREAK_label17: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_11) on */ +RET_LABEL18:(void)0; +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_header_structs for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__compile_header_structs(val* self) { +val* var /* : CodeWriter */; +val* var2 /* : CodeWriter */; +static val* varonce; +val* var3 /* : String */; +char* var4 /* : NativeString */; +long var5 /* : Int */; +val* var6 /* : FlatString */; +val* var7 /* : CodeWriter */; +val* var9 /* : CodeWriter */; +static val* varonce10; +val* var11 /* : String */; +char* var12 /* : NativeString */; +long var13 /* : Int */; +val* var14 /* : FlatString */; +val* var15 /* : CodeWriter */; +val* var17 /* : CodeWriter */; +static val* varonce18; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +val* var23 /* : CodeWriter */; +val* var25 /* : CodeWriter */; +static val* varonce26; +val* var27 /* : String */; +char* var28 /* : NativeString */; +long var29 /* : Int */; +val* var30 /* : FlatString */; +val* var31 /* : CodeWriter */; +val* var33 /* : CodeWriter */; +static val* varonce34; +val* var35 /* : String */; +char* var36 /* : NativeString */; +long var37 /* : Int */; +val* var38 /* : FlatString */; +val* var39 /* : CodeWriter */; +val* var41 /* : CodeWriter */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +long var45 /* : Int */; +val* var46 /* : FlatString */; +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +if (varonce) { +var3 = varonce; +} else { +var4 = "typedef void(*nitmethod_t)(void); /* general C type representing a Nit method. */"; +var5 = 81; +var6 = standard___standard__NativeString___to_s_with_length(var4, var5); +var3 = var6; +varonce = var3; +} +{ +nit___nit__CodeWriter___add_decl(var, var3); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +nit___nit__SeparateCompiler___compile_header_attribute_structs(self); /* Direct call separate_compiler#SeparateCompiler#compile_header_attribute_structs on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var9 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +if (varonce10) { +var11 = varonce10; +} else { +var12 = "struct class { int box_kind; nitmethod_t vft[]; }; /* general C type representing a Nit class. */"; +var13 = 97; +var14 = standard___standard__NativeString___to_s_with_length(var12, var13); +var11 = var14; +varonce10 = var11; +} +{ +nit___nit__CodeWriter___add_decl(var7, var11); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var17 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +if (varonce18) { +var19 = varonce18; +} else { +var20 = "struct type { int id; const char *name; int color; short int is_nullable; const struct types *resolution_table; int table_size; int type_table[]; }; /* general C type representing a Nit type. */"; +var21 = 194; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce18 = var19; +} +{ +nit___nit__CodeWriter___add_decl(var15, var19); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var25 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var25 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var23 = var25; +RET_LABEL24:(void)0; +} +} +if (varonce26) { +var27 = varonce26; +} else { +var28 = "struct instance { const struct type *type; const struct class *class; nitattribute_t attrs[]; }; /* general C type representing a Nit instance. */"; +var29 = 146; +var30 = standard___standard__NativeString___to_s_with_length(var28, var29); +var27 = var30; +varonce26 = var27; +} +{ +nit___nit__CodeWriter___add_decl(var23, var27); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var33 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var33 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var31 = var33; +RET_LABEL32:(void)0; +} +} +if (varonce34) { +var35 = varonce34; +} else { +var36 = "struct types { int dummy; const struct type *types[]; }; /* a list types (used for vts, fts and unresolved lists). */"; +var37 = 117; +var38 = standard___standard__NativeString___to_s_with_length(var36, var37); +var35 = var38; +varonce34 = var35; +} +{ +nit___nit__CodeWriter___add_decl(var31, var35); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var41 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var41 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var39 = var41; +RET_LABEL40:(void)0; +} +} +if (varonce42) { +var43 = varonce42; +} else { +var44 = "typedef struct instance val; /* general C type representing a Nit instance. */"; +var45 = 78; +var46 = standard___standard__NativeString___to_s_with_length(var44, var45); +var43 = var46; +varonce42 = var43; +} +{ +nit___nit__CodeWriter___add_decl(var39, var43); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_header_attribute_structs for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___compile_header_attribute_structs(val* self) { +val* var /* : ModelBuilder */; +val* var2 /* : ModelBuilder */; +val* var3 /* : ToolContext */; +val* var5 /* : ToolContext */; +val* var6 /* : OptionBool */; +val* var8 /* : OptionBool */; +val* var9 /* : nullable Object */; +val* var11 /* : nullable Object */; +short int var12 /* : Bool */; +val* var13 /* : CodeWriter */; +val* var15 /* : CodeWriter */; +static val* varonce; +val* var16 /* : String */; +char* var17 /* : NativeString */; +long var18 /* : Int */; +val* var19 /* : FlatString */; +val* var20 /* : CodeWriter */; +val* var22 /* : CodeWriter */; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +long var26 /* : Int */; +val* var27 /* : FlatString */; +val* var28 /* : CodeWriter */; +val* var30 /* : CodeWriter */; +static val* varonce31; +val* var32 /* : String */; +char* var33 /* : NativeString */; +long var34 /* : Int */; +val* var35 /* : FlatString */; +val* var36 /* : HashMap[MClass, Int] */; +val* var38 /* : HashMap[MClass, Int] */; +val* var_ /* var : HashMap[MClass, Int] */; +val* var39 /* : HashMapIterator[nullable Object, nullable Object] */; +val* var_40 /* var : HashMapIterator[MClass, Int] */; +short int var41 /* : Bool */; +val* var42 /* : nullable Object */; +val* var_c /* var c: MClass */; +val* var43 /* : nullable Object */; +long var44 /* : Int */; +long var_v /* var v: Int */; +val* var45 /* : MClassType */; +val* var47 /* : MClassType */; +val* var_t /* var t: MClassType */; +val* var48 /* : MClass */; +val* var50 /* : MClass */; +val* var51 /* : String */; +val* var53 /* : String */; +static val* varonce54; +val* var55 /* : String */; +char* var56 /* : NativeString */; +long var57 /* : Int */; +val* var58 /* : FlatString */; +short int var59 /* : Bool */; +val* var60 /* : CodeWriter */; +val* var62 /* : CodeWriter */; +val* var63 /* : String */; +static val* varonce64; +val* var65 /* : String */; +char* var66 /* : NativeString */; +long var67 /* : Int */; +val* var68 /* : FlatString */; +val* var69 /* : String */; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : NativeString */; +long var73 /* : Int */; +val* var74 /* : FlatString */; +val* var75 /* : Array[Object] */; +long var76 /* : Int */; +val* var77 /* : NativeArray[Object] */; +val* var78 /* : String */; +val* var81 /* : CodeWriter */; +val* var83 /* : CodeWriter */; +static val* varonce84; +val* var85 /* : String */; +char* var86 /* : NativeString */; +long var87 /* : Int */; +val* var88 /* : FlatString */; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var) on */ +var5 = var->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_no_union_attribute (var3) on */ +var8 = var3->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_union_attribute].val; /* _opt_no_union_attribute on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_union_attribute"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 28); +show_backtrace(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var6) on */ +var11 = var6->attrs[COLOR_opts__Option___value].val; /* _value on */ +var9 = var11; +RET_LABEL10:(void)0; +} +} +var12 = ((struct instance_standard__Bool*)var9)->value; /* autounbox from nullable Object to Bool */; +if (var12){ +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var15 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var15 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var13 = var15; +RET_LABEL14:(void)0; +} +} +if (varonce) { +var16 = varonce; +} else { +var17 = "typedef void* nitattribute_t; /* general C type representing a Nit attribute. */"; +var18 = 80; +var19 = standard___standard__NativeString___to_s_with_length(var17, var18); +var16 = var19; +varonce = var16; +} +{ +nit___nit__CodeWriter___add_decl(var13, var16); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +} else { +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var22 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var22 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var20 = var22; +RET_LABEL21:(void)0; +} +} +if (varonce23) { +var24 = varonce23; +} else { +var25 = "typedef union {"; +var26 = 15; +var27 = standard___standard__NativeString___to_s_with_length(var25, var26); +var24 = var27; +varonce23 = var24; +} +{ +nit___nit__CodeWriter___add_decl(var20, var24); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var30 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var30 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var28 = var30; +RET_LABEL29:(void)0; +} +} +if (varonce31) { +var32 = varonce31; +} else { +var33 = "void* val;"; +var34 = 10; +var35 = standard___standard__NativeString___to_s_with_length(var33, var34); +var32 = var35; +varonce31 = var32; +} +{ +nit___nit__CodeWriter___add_decl(var28, var32); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var38 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var38 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var36 = var38; +RET_LABEL37:(void)0; +} +} +var_ = var36; +{ +var39 = standard___standard__HashMap___standard__abstract_collection__MapRead__iterator(var_); +} +var_40 = var39; +for(;;) { +{ +var41 = standard___standard__HashMapIterator___standard__abstract_collection__MapIterator__is_ok(var_40); +} +if (var41){ +{ +var42 = standard___standard__HashMapIterator___standard__abstract_collection__MapIterator__key(var_40); +} +var_c = var42; +{ +var43 = standard___standard__HashMapIterator___standard__abstract_collection__MapIterator__item(var_40); +} +var44 = ((struct instance_standard__Int*)var43)->value; /* autounbox from nullable Object to Int */; +var_v = var44; +{ +{ /* Inline model#MClass#mclass_type (var_c) on */ +var47 = var_c->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); +show_backtrace(1); +} +var45 = var47; +RET_LABEL46:(void)0; +} +} +var_t = var45; +{ +{ /* Inline model#MClassType#mclass (var_t) on */ +var50 = var_t->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var50 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); +show_backtrace(1); +} +var48 = var50; +RET_LABEL49:(void)0; +} +} +{ +{ /* Inline model#MClass#name (var48) on */ +var53 = var48->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var53 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); +show_backtrace(1); +} +var51 = var53; +RET_LABEL52:(void)0; +} +} +if (varonce54) { +var55 = varonce54; +} else { +var56 = "Pointer"; +var57 = 7; +var58 = standard___standard__NativeString___to_s_with_length(var56, var57); +var55 = var58; +varonce54 = var55; +} +{ +var59 = ((short int (*)(val* self, val* p0))(var51->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var51, var55) /* == on */; +} +if (var59){ +goto BREAK_label; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var62 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var62 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var60 = var62; +RET_LABEL61:(void)0; +} +} +{ +var63 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_t); +} +if (varonce64) { +var65 = varonce64; +} else { +var66 = " "; +var67 = 1; +var68 = standard___standard__NativeString___to_s_with_length(var66, var67); +var65 = var68; +varonce64 = var65; +} +{ +var69 = nit__abstract_compiler___MClassType___MType__ctypename(var_t); +} +if (varonce70) { +var71 = varonce70; +} else { +var72 = ";"; +var73 = 1; +var74 = standard___standard__NativeString___to_s_with_length(var72, var73); +var71 = var74; +varonce70 = var71; +} +var75 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var75 = array_instance Array[Object] */ +var76 = 4; +var77 = NEW_standard__NativeArray(var76, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var77)->values[0] = (val*) var63; +((struct instance_standard__NativeArray*)var77)->values[1] = (val*) var65; +((struct instance_standard__NativeArray*)var77)->values[2] = (val*) var69; +((struct instance_standard__NativeArray*)var77)->values[3] = (val*) var71; +{ +((void (*)(val* self, val* p0, long p1))(var75->class->vft[COLOR_standard__array__Array__with_native]))(var75, var77, var76) /* with_native on */; +} +} +{ +var78 = ((val* (*)(val* self))(var75->class->vft[COLOR_standard__string__Object__to_s]))(var75) /* to_s on */; +} +{ +nit___nit__CodeWriter___add_decl(var60, var78); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +BREAK_label: (void)0; +{ +standard___standard__HashMapIterator___standard__abstract_collection__MapIterator__next(var_40); /* Direct call hash_collection#HashMapIterator#next on */ +} +} else { +goto BREAK_label79; +} +} +BREAK_label79: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_40) on */ +RET_LABEL80:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var83 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var83 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); +show_backtrace(1); +} +var81 = var83; +RET_LABEL82:(void)0; +} +} +if (varonce84) { +var85 = varonce84; +} else { +var86 = "} nitattribute_t; /* general C type representing a Nit attribute. */"; +var87 = 68; +var88 = standard___standard__NativeString___to_s_with_length(var86, var87); +var85 = var88; +varonce84 = var85; +} +{ +nit___nit__CodeWriter___add_decl(var81, var85); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_box_kinds for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___compile_box_kinds(val* self) { +val* var /* : Array[String] */; +long var1 /* : Int */; +val* var_ /* var : Array[String] */; +static val* varonce; +val* var2 /* : String */; +char* var3 /* : NativeString */; +long var4 /* : Int */; +val* var5 /* : FlatString */; +static val* varonce6; +val* var7 /* : String */; +char* var8 /* : NativeString */; +long var9 /* : Int */; +val* var10 /* : FlatString */; +static val* varonce11; +val* var12 /* : String */; +char* var13 /* : NativeString */; +long var14 /* : Int */; +val* var15 /* : FlatString */; +static val* varonce16; +val* var17 /* : String */; +char* var18 /* : NativeString */; +long var19 /* : Int */; +val* var20 /* : FlatString */; +static val* varonce21; +val* var22 /* : String */; +char* var23 /* : NativeString */; +long var24 /* : Int */; +val* var25 /* : FlatString */; +static val* varonce26; +val* var27 /* : String */; +char* var28 /* : NativeString */; +long var29 /* : Int */; +val* var30 /* : FlatString */; +val* var_31 /* var : Array[String] */; +val* var32 /* : ArrayIterator[nullable Object] */; +val* var_33 /* var : ArrayIterator[String] */; +short int var34 /* : Bool */; +val* var35 /* : nullable Object */; +val* var_classname /* var classname: String */; +val* var36 /* : MModule */; +val* var38 /* : MModule */; +val* var39 /* : Model */; +val* var41 /* : Model */; +val* var42 /* : nullable Array[MClass] */; +val* var_classes /* var classes: nullable Array[MClass] */; +val* var43 /* : null */; +short int var44 /* : Bool */; +short int var45 /* : Bool */; +long var46 /* : Int */; +long var48 /* : Int */; +long var49 /* : Int */; +short int var50 /* : Bool */; +short int var52 /* : Bool */; +static val* varonce53; +val* var54 /* : String */; +char* var55 /* : NativeString */; +long var56 /* : Int */; +val* var57 /* : FlatString */; +val* var58 /* : String */; +val* var59 /* : HashMap[MClass, Int] */; +val* var61 /* : HashMap[MClass, Int] */; +val* var62 /* : nullable Object */; +val* var63 /* : HashMap[MClass, Int] */; +val* var65 /* : HashMap[MClass, Int] */; +long var66 /* : Int */; +long var67 /* : Int */; +long var68 /* : Int */; +short int var70 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var71 /* : Int */; +val* var72 /* : nullable Object */; +var = NEW_standard__Array(&type_standard__Array__standard__String); +var1 = 6; +{ +standard___standard__Array___with_capacity(var, var1); /* Direct call array#Array#with_capacity on */ +} +var_ = var; +if (varonce) { +var2 = varonce; +} else { +var3 = "Int"; +var4 = 3; +var5 = standard___standard__NativeString___to_s_with_length(var3, var4); +var2 = var5; +varonce = var2; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var2); /* Direct call array#AbstractArray#push on */ +} +if (varonce6) { +var7 = varonce6; +} else { +var8 = "Bool"; +var9 = 4; +var10 = standard___standard__NativeString___to_s_with_length(var8, var9); +var7 = var10; +varonce6 = var7; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var7); /* Direct call array#AbstractArray#push on */ +} +if (varonce11) { +var12 = varonce11; +} else { +var13 = "Char"; +var14 = 4; +var15 = standard___standard__NativeString___to_s_with_length(var13, var14); +var12 = var15; +varonce11 = var12; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var12); /* Direct call array#AbstractArray#push on */ +} +if (varonce16) { +var17 = varonce16; +} else { +var18 = "Float"; +var19 = 5; +var20 = standard___standard__NativeString___to_s_with_length(var18, var19); +var17 = var20; +varonce16 = var17; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var17); /* Direct call array#AbstractArray#push on */ +} +if (varonce21) { +var22 = varonce21; +} else { +var23 = "NativeString"; +var24 = 12; +var25 = standard___standard__NativeString___to_s_with_length(var23, var24); +var22 = var25; +varonce21 = var22; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var22); /* Direct call array#AbstractArray#push on */ +} +if (varonce26) { +var27 = varonce26; +} else { +var28 = "Pointer"; +var29 = 7; +var30 = standard___standard__NativeString___to_s_with_length(var28, var29); +var27 = var30; +varonce26 = var27; +} +{ +standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var27); /* Direct call array#AbstractArray#push on */ +} +var_31 = var_; +{ +var32 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_31); +} +var_33 = var32; +for(;;) { +{ +var34 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_33); +} +if (var34){ +{ +var35 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_33); +} +var_classname = var35; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var38 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var38 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var36 = var38; +RET_LABEL37:(void)0; +} +} +{ +{ /* Inline mmodule#MModule#model (var36) on */ +var41 = var36->attrs[COLOR_nit__mmodule__MModule___model].val; /* _model on */ +if (unlikely(var41 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _model"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__mmodule, 73); +show_backtrace(1); +} +var39 = var41; +RET_LABEL40:(void)0; +} +} +{ +var42 = nit__model___Model___get_mclasses_by_name(var39, var_classname); +} +var_classes = var42; +var43 = NULL; +if (var_classes == NULL) { +var44 = 1; /* is null */ +} else { +var44 = 0; /* arg is null but recv is not */ +} +if (0) { +var45 = standard___standard__Array___standard__kernel__Object___61d_61d(var_classes, var43); +var44 = var45; +} +if (var44){ +goto BREAK_label; +} else { +} +{ +{ /* Inline array#AbstractArrayRead#length (var_classes) on */ +var48 = var_classes->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var46 = var48; +RET_LABEL47:(void)0; +} +} +var49 = 1; +{ +{ /* Inline kernel#Int#== (var46,var49) on */ +var52 = var46 == var49; +var50 = var52; +goto RET_LABEL51; +RET_LABEL51:(void)0; +} +} +if (unlikely(!var50)) { +if (varonce53) { +var54 = varonce53; +} else { +var55 = ", "; +var56 = 2; +var57 = standard___standard__NativeString___to_s_with_length(var55, var56); +var54 = var57; +varonce53 = var54; +} +{ +var58 = standard__string___Collection___join(var_classes, var54); +} +{ +standard__file___Object___print(self, var58); /* Direct call file#Object#print on */ +} +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 228); +show_backtrace(1); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var61 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var61 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var59 = var61; +RET_LABEL60:(void)0; +} +} +{ +var62 = standard___standard__SequenceRead___Collection__first(var_classes); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var65 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var65 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var63 = var65; +RET_LABEL64:(void)0; +} +} +{ +var66 = standard___standard__HashMap___standard__abstract_collection__MapRead__length(var63); +} +var67 = 1; +{ +{ /* Inline kernel#Int#+ (var66,var67) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var70 = 1; /* easy isa OTHER*/ +if (unlikely(!var70)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); +show_backtrace(1); +} +var71 = var66 + var67; +var68 = var71; +goto RET_LABEL69; +RET_LABEL69:(void)0; +} +} +{ +var72 = BOX_standard__Int(var68); /* autobox from Int to nullable Object */ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var59, var62, var72); /* Direct call hash_collection#HashMap#[]= on */ +} +BREAK_label: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_33); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label73; +} +} +BREAK_label73: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_33) on */ +RET_LABEL74:(void)0; +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#box_kinds for (self: SeparateCompiler): HashMap[MClass, Int] */ +val* nit___nit__SeparateCompiler___box_kinds(val* self) { +val* var /* : HashMap[MClass, Int] */; +val* var1 /* : HashMap[MClass, Int] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#box_kind_of for (self: SeparateCompiler, MClass): Int */ +long nit___nit__SeparateCompiler___box_kind_of(val* self, val* p0) { +long var /* : Int */; +val* var_mclass /* var mclass: MClass */; +val* var1 /* : MClassType */; +val* var3 /* : MClassType */; +val* var4 /* : String */; +static val* varonce; +val* var5 /* : String */; +char* var6 /* : NativeString */; +long var7 /* : Int */; +val* var8 /* : FlatString */; +short int var9 /* : Bool */; +long var10 /* : Int */; +short int var11 /* : Bool */; +val* var12 /* : MClassKind */; +val* var14 /* : MClassKind */; +val* var15 /* : MClassKind */; +short int var16 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var18 /* : Bool */; +short int var20 /* : Bool */; +short int var_ /* var : Bool */; +val* var21 /* : String */; +val* var23 /* : String */; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +long var27 /* : Int */; +val* var28 /* : FlatString */; +short int var29 /* : Bool */; +val* var_other31 /* var other: nullable Object */; +short int var32 /* : Bool */; +short int var33 /* : Bool */; +val* var34 /* : HashMap[MClass, Int] */; +val* var36 /* : HashMap[MClass, Int] */; +val* var37 /* : MModule */; +val* var39 /* : MModule */; +static val* varonce40; +val* var41 /* : String */; +char* var42 /* : NativeString */; +long var43 /* : Int */; +val* var44 /* : FlatString */; +val* var45 /* : MClass */; +val* var46 /* : nullable Object */; +long var47 /* : Int */; +val* var48 /* : HashMap[MClass, Int] */; +val* var50 /* : HashMap[MClass, Int] */; +val* var51 /* : nullable Object */; +long var52 /* : Int */; +var_mclass = p0; +{ +{ /* Inline model#MClass#mclass_type (var_mclass) on */ +var3 = var_mclass->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var3 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); +show_backtrace(1); +} +var1 = var3; +RET_LABEL2:(void)0; +} +} +{ +var4 = nit__abstract_compiler___MClassType___MType__ctype_extern(var1); +} +if (varonce) { +var5 = varonce; +} else { +var6 = "val*"; +var7 = 4; +var8 = standard___standard__NativeString___to_s_with_length(var6, var7); +var5 = var8; +varonce = var5; +} +{ +var9 = ((short int (*)(val* self, val* p0))(var4->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var4, var5) /* == on */; +} +if (var9){ +var10 = 0; +var = var10; +goto RET_LABEL; +} else { +{ +{ /* Inline model#MClass#kind (var_mclass) on */ +var14 = var_mclass->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +var15 = nit__model___standard__Object___extern_kind(self); +} +{ +{ /* Inline kernel#Object#== (var12,var15) on */ +var_other = var15; +{ +{ /* Inline kernel#Object#is_same_instance (var12,var_other) on */ +var20 = var12 == var_other; +var18 = var20; +goto RET_LABEL19; +RET_LABEL19:(void)0; +} +} +var16 = var18; +goto RET_LABEL17; +RET_LABEL17:(void)0; +} +} +var_ = var16; +if (var16){ +{ +{ /* Inline model#MClass#name (var_mclass) on */ +var23 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var23 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); +show_backtrace(1); +} +var21 = var23; +RET_LABEL22:(void)0; +} +} +if (varonce24) { +var25 = varonce24; +} else { +var26 = "NativeString"; +var27 = 12; +var28 = standard___standard__NativeString___to_s_with_length(var26, var27); +var25 = var28; +varonce24 = var25; +} +{ +{ /* Inline kernel#Object#!= (var21,var25) on */ +var_other31 = var25; +{ +var32 = ((short int (*)(val* self, val* p0))(var21->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var21, var_other31) /* == on */; +} +var33 = !var32; +var29 = var33; +goto RET_LABEL30; +RET_LABEL30:(void)0; +} +} +var11 = var29; +} else { +var11 = var_; +} +if (var11){ +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var36 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var36 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var39 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var39 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var37 = var39; +RET_LABEL38:(void)0; +} +} +if (varonce40) { +var41 = varonce40; +} else { +var42 = "Pointer"; +var43 = 7; +var44 = standard___standard__NativeString___to_s_with_length(var42, var43); +var41 = var44; +varonce40 = var41; +} +{ +var45 = nit__model___MModule___get_primitive_class(var37, var41); +} +{ +var46 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var34, var45); +} +var47 = ((struct instance_standard__Int*)var46)->value; /* autounbox from nullable Object to Int */; +var = var47; +goto RET_LABEL; +} else { +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var50 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var50 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var48 = var50; +RET_LABEL49:(void)0; +} +} +{ +var51 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var48, var_mclass); +} +var52 = ((struct instance_standard__Int*)var51)->value; /* autounbox from nullable Object to Int */; +var = var52; +goto RET_LABEL; +} +} +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#compile_color_consts for (self: SeparateCompiler, Map[Object, Int]) */ +void nit___nit__SeparateCompiler___compile_color_consts(val* self, val* p0) { +val* var_colors /* var colors: Map[Object, Int] */; +val* var /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var_ /* var : Map[Object, Int] */; +val* var1 /* : MapIterator[nullable Object, nullable Object] */; +val* var_2 /* var : MapIterator[Object, Int] */; +short int var3 /* : Bool */; +val* var4 /* : nullable Object */; +val* var_m /* var m: Object */; +val* var5 /* : nullable Object */; +long var6 /* : Int */; +long var_c /* var c: Int */; +var_colors = p0; +{ +var = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +} +var_v = var; +var_ = var_colors; +{ +var1 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_) /* iterator on */; +} +var_2 = var1; +for(;;) { +{ +var3 = ((short int (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_2) /* is_ok on */; +} +if (var3){ +{ +var4 = ((val* (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_2) /* key on */; +} +var_m = var4; +{ +var5 = ((val* (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_2) /* item on */; +} +var6 = ((struct instance_standard__Int*)var5)->value; /* autounbox from nullable Object to Int */; +var_c = var6; +{ +nit___nit__SeparateCompiler___compile_color_const(self, var_v, var_m, var_c); /* Direct call separate_compiler#SeparateCompiler#compile_color_const on */ +} +{ +((void (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_2) /* next on */; +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_2) on */ +RET_LABEL7:(void)0; +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_color_const for (self: SeparateCompiler, SeparateCompilerVisitor, Object, Int) */ +void nit___nit__SeparateCompiler___compile_color_const(val* self, val* p0, val* p1, long p2) { +val* var_v /* var v: SeparateCompilerVisitor */; +val* var_m /* var m: Object */; +long var_color /* var color: Int */; +val* var /* : HashSet[Object] */; +val* var2 /* : HashSet[Object] */; +short int var3 /* : Bool */; +short int var4 /* : Bool */; +int cltype; +int idtype; +val* var5 /* : ModelBuilder */; +val* var7 /* : ModelBuilder */; +val* var8 /* : ToolContext */; +val* var10 /* : ToolContext */; +val* var11 /* : OptionBool */; +val* var13 /* : OptionBool */; +val* var14 /* : nullable Object */; +val* var16 /* : nullable Object */; +short int var17 /* : Bool */; +val* var18 /* : String */; +static val* varonce; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : FlatString */; +val* var23 /* : String */; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +long var27 /* : Int */; +val* var28 /* : FlatString */; +val* var29 /* : Array[Object] */; +long var30 /* : Int */; +val* var31 /* : NativeArray[Object] */; +val* var32 /* : Object */; +val* var33 /* : String */; +short int var34 /* : Bool */; +val* var35 /* : ModelBuilder */; +val* var37 /* : ModelBuilder */; +val* var38 /* : ToolContext */; +val* var40 /* : ToolContext */; +val* var41 /* : OptionBool */; +val* var43 /* : OptionBool */; +val* var44 /* : nullable Object */; +val* var46 /* : nullable Object */; +short int var47 /* : Bool */; +short int var48 /* : Bool */; +short int var_ /* var : Bool */; +val* var49 /* : AbstractCompiler */; +val* var51 /* : AbstractCompiler */; +val* var52 /* : Platform */; +val* var54 /* : Platform */; +short int var55 /* : Bool */; +short int var56 /* : Bool */; +val* var57 /* : String */; +static val* varonce58; +val* var59 /* : String */; +char* var60 /* : NativeString */; +long var61 /* : Int */; +val* var62 /* : FlatString */; +val* var63 /* : String */; +static val* varonce64; +val* var65 /* : String */; +char* var66 /* : NativeString */; +long var67 /* : Int */; +val* var68 /* : FlatString */; +val* var69 /* : Array[Object] */; +long var70 /* : Int */; +val* var71 /* : NativeArray[Object] */; +val* var72 /* : String */; +static val* varonce73; +val* var74 /* : String */; +char* var75 /* : NativeString */; +long var76 /* : Int */; +val* var77 /* : FlatString */; +val* var78 /* : String */; +static val* varonce79; +val* var80 /* : String */; +char* var81 /* : NativeString */; +long var82 /* : Int */; +val* var83 /* : FlatString */; +static val* varonce84; +val* var85 /* : String */; +char* var86 /* : NativeString */; +long var87 /* : Int */; +val* var88 /* : FlatString */; +val* var89 /* : Array[Object] */; +long var90 /* : Int */; +val* var91 /* : NativeArray[Object] */; +val* var92 /* : Object */; +val* var93 /* : String */; +val* var94 /* : String */; +static val* varonce95; +val* var96 /* : String */; +char* var97 /* : NativeString */; +long var98 /* : Int */; +val* var99 /* : FlatString */; +val* var100 /* : String */; +static val* varonce101; +val* var102 /* : String */; +char* var103 /* : NativeString */; +long var104 /* : Int */; +val* var105 /* : FlatString */; +val* var106 /* : String */; +static val* varonce107; +val* var108 /* : String */; +char* var109 /* : NativeString */; +long var110 /* : Int */; +val* var111 /* : FlatString */; +val* var112 /* : String */; +static val* varonce113; +val* var114 /* : String */; +char* var115 /* : NativeString */; +long var116 /* : Int */; +val* var117 /* : FlatString */; +val* var118 /* : Array[Object] */; +long var119 /* : Int */; +val* var120 /* : NativeArray[Object] */; +val* var121 /* : String */; +long var122 /* : Int */; +long var123 /* : Int */; +long var125 /* : Int */; +short int var126 /* : Bool */; +short int var128 /* : Bool */; +long var129 /* : Int */; +val* var130 /* : Array[String] */; +val* var132 /* : Array[String] */; +static val* varonce133; +val* var134 /* : String */; +char* var135 /* : NativeString */; +long var136 /* : Int */; +val* var137 /* : FlatString */; +val* var138 /* : String */; +static val* varonce139; +val* var140 /* : String */; +char* var141 /* : NativeString */; +long var142 /* : Int */; +val* var143 /* : FlatString */; +static val* varonce144; +val* var145 /* : String */; +char* var146 /* : NativeString */; +long var147 /* : Int */; +val* var148 /* : FlatString */; +val* var149 /* : Array[Object] */; +long var150 /* : Int */; +val* var151 /* : NativeArray[Object] */; +val* var152 /* : Object */; +val* var153 /* : String */; +val* var154 /* : HashSet[Object] */; +val* var156 /* : HashSet[Object] */; +var_v = p0; +var_m = p1; +var_color = p2; +{ +{ /* Inline separate_compiler#SeparateCompiler#color_consts_done (self) on */ +var2 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___color_consts_done].val; /* _color_consts_done on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _color_consts_done"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 277); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +var3 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var, var_m); +} +if (var3){ +goto RET_LABEL; +} else { +} +/* isa MEntity */ +cltype = type_nit__MEntity.color; +idtype = type_nit__MEntity.id; +if(cltype >= var_m->type->table_size) { +var4 = 0; +} else { +var4 = var_m->type->type_table[cltype] == idtype; +} +if (var4){ +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var7 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var7 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var5 = var7; +RET_LABEL6:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var5) on */ +var10 = var5->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var10 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var8 = var10; +RET_LABEL9:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_inline_coloring_numbers (var8) on */ +var13 = var8->attrs[COLOR_nit__separate_compiler__ToolContext___opt_inline_coloring_numbers].val; /* _opt_inline_coloring_numbers on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_inline_coloring_numbers"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 35); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var11) on */ +var16 = var11->attrs[COLOR_opts__Option___value].val; /* _value on */ +var14 = var16; +RET_LABEL15:(void)0; +} +} +var17 = ((struct instance_standard__Bool*)var14)->value; /* autounbox from nullable Object to Bool */; +if (var17){ +{ +var18 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce) { +var19 = varonce; +} else { +var20 = "#define "; +var21 = 8; +var22 = standard___standard__NativeString___to_s_with_length(var20, var21); +var19 = var22; +varonce = var19; +} +{ +var23 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce24) { +var25 = varonce24; +} else { +var26 = " "; +var27 = 1; +var28 = standard___standard__NativeString___to_s_with_length(var26, var27); +var25 = var28; +varonce24 = var25; +} +var29 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var29 = array_instance Array[Object] */ +var30 = 4; +var31 = NEW_standard__NativeArray(var30, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var31)->values[0] = (val*) var19; +((struct instance_standard__NativeArray*)var31)->values[1] = (val*) var23; +((struct instance_standard__NativeArray*)var31)->values[2] = (val*) var25; +var32 = BOX_standard__Int(var_color); /* autobox from Int to Object */ +((struct instance_standard__NativeArray*)var31)->values[3] = (val*) var32; +{ +((void (*)(val* self, val* p0, long p1))(var29->class->vft[COLOR_standard__array__Array__with_native]))(var29, var31, var30) /* with_native on */; +} +} +{ +var33 = ((val* (*)(val* self))(var29->class->vft[COLOR_standard__string__Object__to_s]))(var29) /* to_s on */; +} +{ +nit___nit__AbstractCompiler___provide_declaration(self, var18, var33); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +} else { +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var37 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var37 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var35 = var37; +RET_LABEL36:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var35) on */ +var40 = var35->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var40 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var38 = var40; +RET_LABEL39:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_colors_are_symbols (var38) on */ +var43 = var38->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colors_are_symbols].val; /* _opt_colors_are_symbols on */ +if (unlikely(var43 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colors_are_symbols"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 32); +show_backtrace(1); +} +var41 = var43; +RET_LABEL42:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var41) on */ +var46 = var41->attrs[COLOR_opts__Option___value].val; /* _value on */ +var44 = var46; +RET_LABEL45:(void)0; +} +} +var47 = ((struct instance_standard__Bool*)var44)->value; /* autounbox from nullable Object to Bool */; +var48 = !var47; +var_ = var48; +if (var48){ +var34 = var_; +} else { +{ +{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ +var51 = var_v->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var51 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); +show_backtrace(1); +} +var49 = var51; +RET_LABEL50:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#target_platform (var49) on */ +var54 = var49->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___target_platform].val; /* _target_platform on */ +if (unlikely(var54 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _target_platform"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 487); +show_backtrace(1); +} +var52 = var54; +RET_LABEL53:(void)0; +} +} +{ +var55 = nit___nit__Platform___supports_linker_script(var52); +} +var56 = !var55; +var34 = var56; +} +if (var34){ +{ +var57 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce58) { +var59 = varonce58; +} else { +var60 = "extern const int "; +var61 = 17; +var62 = standard___standard__NativeString___to_s_with_length(var60, var61); +var59 = var62; +varonce58 = var59; +} +{ +var63 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce64) { +var65 = varonce64; +} else { +var66 = ";"; +var67 = 1; +var68 = standard___standard__NativeString___to_s_with_length(var66, var67); +var65 = var68; +varonce64 = var65; +} +var69 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var69 = array_instance Array[Object] */ +var70 = 3; +var71 = NEW_standard__NativeArray(var70, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var71)->values[0] = (val*) var59; +((struct instance_standard__NativeArray*)var71)->values[1] = (val*) var63; +((struct instance_standard__NativeArray*)var71)->values[2] = (val*) var65; +{ +((void (*)(val* self, val* p0, long p1))(var69->class->vft[COLOR_standard__array__Array__with_native]))(var69, var71, var70) /* with_native on */; +} +} +{ +var72 = ((val* (*)(val* self))(var69->class->vft[COLOR_standard__string__Object__to_s]))(var69) /* to_s on */; +} +{ +nit___nit__AbstractCompiler___provide_declaration(self, var57, var72); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (varonce73) { +var74 = varonce73; +} else { +var75 = "const int "; +var76 = 10; +var77 = standard___standard__NativeString___to_s_with_length(var75, var76); +var74 = var77; +varonce73 = var74; +} +{ +var78 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce79) { +var80 = varonce79; +} else { +var81 = " = "; +var82 = 3; +var83 = standard___standard__NativeString___to_s_with_length(var81, var82); +var80 = var83; +varonce79 = var80; +} +if (varonce84) { +var85 = varonce84; +} else { +var86 = ";"; +var87 = 1; +var88 = standard___standard__NativeString___to_s_with_length(var86, var87); +var85 = var88; +varonce84 = var85; +} +var89 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var89 = array_instance Array[Object] */ +var90 = 5; +var91 = NEW_standard__NativeArray(var90, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var91)->values[0] = (val*) var74; +((struct instance_standard__NativeArray*)var91)->values[1] = (val*) var78; +((struct instance_standard__NativeArray*)var91)->values[2] = (val*) var80; +var92 = BOX_standard__Int(var_color); /* autobox from Int to Object */ +((struct instance_standard__NativeArray*)var91)->values[3] = (val*) var92; +((struct instance_standard__NativeArray*)var91)->values[4] = (val*) var85; +{ +((void (*)(val* self, val* p0, long p1))(var89->class->vft[COLOR_standard__array__Array__with_native]))(var89, var91, var90) /* with_native on */; +} +} +{ +var93 = ((val* (*)(val* self))(var89->class->vft[COLOR_standard__string__Object__to_s]))(var89) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var93); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} else { +{ +var94 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce95) { +var96 = varonce95; +} else { +var97 = "#define "; +var98 = 8; +var99 = standard___standard__NativeString___to_s_with_length(var97, var98); +var96 = var99; +varonce95 = var96; +} +{ +var100 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce101) { +var102 = varonce101; +} else { +var103 = " ((long)&X"; +var104 = 10; +var105 = standard___standard__NativeString___to_s_with_length(var103, var104); +var102 = var105; +varonce101 = var102; +} +{ +var106 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce107) { +var108 = varonce107; +} else { +var109 = ")\nextern const void X"; +var110 = 21; +var111 = standard___standard__NativeString___to_s_with_length(var109, var110); +var108 = var111; +varonce107 = var108; +} +{ +var112 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce113) { +var114 = varonce113; +} else { +var115 = ";"; +var116 = 1; +var117 = standard___standard__NativeString___to_s_with_length(var115, var116); +var114 = var117; +varonce113 = var114; +} +var118 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var118 = array_instance Array[Object] */ +var119 = 7; +var120 = NEW_standard__NativeArray(var119, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var120)->values[0] = (val*) var96; +((struct instance_standard__NativeArray*)var120)->values[1] = (val*) var100; +((struct instance_standard__NativeArray*)var120)->values[2] = (val*) var102; +((struct instance_standard__NativeArray*)var120)->values[3] = (val*) var106; +((struct instance_standard__NativeArray*)var120)->values[4] = (val*) var108; +((struct instance_standard__NativeArray*)var120)->values[5] = (val*) var112; +((struct instance_standard__NativeArray*)var120)->values[6] = (val*) var114; +{ +((void (*)(val* self, val* p0, long p1))(var118->class->vft[COLOR_standard__array__Array__with_native]))(var118, var120, var119) /* with_native on */; +} +} +{ +var121 = ((val* (*)(val* self))(var118->class->vft[COLOR_standard__string__Object__to_s]))(var118) /* to_s on */; +} +{ +nit___nit__AbstractCompiler___provide_declaration(self, var94, var121); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +var122 = 1; +{ +{ /* Inline kernel#Int#unary - (var122) on */ +var125 = -var122; +var123 = var125; +goto RET_LABEL124; +RET_LABEL124:(void)0; +} +} +{ +{ /* Inline kernel#Int#== (var_color,var123) on */ +var128 = var_color == var123; +var126 = var128; +goto RET_LABEL127; +RET_LABEL127:(void)0; +} +} +if (var126){ +var129 = 0; +var_color = var129; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#linker_script (self) on */ +var132 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___linker_script].val; /* _linker_script on */ +if (unlikely(var132 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _linker_script"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 526); +show_backtrace(1); +} +var130 = var132; +RET_LABEL131:(void)0; +} +} +if (varonce133) { +var134 = varonce133; +} else { +var135 = "X"; +var136 = 1; +var137 = standard___standard__NativeString___to_s_with_length(var135, var136); +var134 = var137; +varonce133 = var134; +} +{ +var138 = nit__separate_compiler___MEntity___const_color(var_m); +} +if (varonce139) { +var140 = varonce139; +} else { +var141 = " = "; +var142 = 3; +var143 = standard___standard__NativeString___to_s_with_length(var141, var142); +var140 = var143; +varonce139 = var140; +} +if (varonce144) { +var145 = varonce144; +} else { +var146 = ";"; +var147 = 1; +var148 = standard___standard__NativeString___to_s_with_length(var146, var147); +var145 = var148; +varonce144 = var145; +} +var149 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var149 = array_instance Array[Object] */ +var150 = 5; +var151 = NEW_standard__NativeArray(var150, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var151)->values[0] = (val*) var134; +((struct instance_standard__NativeArray*)var151)->values[1] = (val*) var138; +((struct instance_standard__NativeArray*)var151)->values[2] = (val*) var140; +var152 = BOX_standard__Int(var_color); /* autobox from Int to Object */ +((struct instance_standard__NativeArray*)var151)->values[3] = (val*) var152; +((struct instance_standard__NativeArray*)var151)->values[4] = (val*) var145; +{ +((void (*)(val* self, val* p0, long p1))(var149->class->vft[COLOR_standard__array__Array__with_native]))(var149, var151, var150) /* with_native on */; +} +} +{ +var153 = ((val* (*)(val* self))(var149->class->vft[COLOR_standard__string__Object__to_s]))(var149) /* to_s on */; +} +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var130, var153); /* Direct call array#Array#add on */ +} +} +} +} else { +PRINT_ERROR("Runtime error: %s", "Aborted"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 272); +show_backtrace(1); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#color_consts_done (self) on */ +var156 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___color_consts_done].val; /* _color_consts_done on */ +if (unlikely(var156 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _color_consts_done"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 277); +show_backtrace(1); +} +var154 = var156; +RET_LABEL155:(void)0; +} +} +{ +standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var154, var_m); /* Direct call hash_collection#HashSet#add on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#color_consts_done for (self: SeparateCompiler): HashSet[Object] */ +val* nit___nit__SeparateCompiler___color_consts_done(val* self) { +val* var /* : HashSet[Object] */; +val* var1 /* : HashSet[Object] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___color_consts_done].val; /* _color_consts_done on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _color_consts_done"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 277); +show_backtrace(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#do_property_coloring for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___do_property_coloring(val* self) { +val* var /* : nullable RapidTypeAnalysis */; +val* var2 /* : nullable RapidTypeAnalysis */; +val* var_rta /* var rta: nullable RapidTypeAnalysis */; +val* var3 /* : MModule */; +val* var5 /* : MModule */; +val* var6 /* : POSet[MClass] */; +val* var_poset /* var poset: POSet[MClass] */; +val* var7 /* : HashSet[MClass] */; +val* var_mclasses /* var mclasses: HashSet[MClass] */; +val* var8 /* : POSetColorer[MClass] */; +val* var_colorer /* var colorer: POSetColorer[MClass] */; +val* var10 /* : Array[MMethod] */; +val* var_dead_methods /* var dead_methods: Array[MMethod] */; +val* var11 /* : HashMap[MClass, Set[PropertyLayoutElement]] */; +val* var_mmethods /* var mmethods: HashMap[MClass, Set[PropertyLayoutElement]] */; +val* var12 /* : HashMap[MClass, Set[MAttribute]] */; +val* var_mattributes /* var mattributes: HashMap[MClass, Set[MAttribute]] */; +val* var_ /* var : HashSet[MClass] */; +val* var13 /* : Iterator[nullable Object] */; +val* var_14 /* var : Iterator[MClass] */; +short int var15 /* : Bool */; +val* var16 /* : nullable Object */; +val* var_mclass /* var mclass: MClass */; +val* var17 /* : HashSet[PropertyLayoutElement] */; +val* var18 /* : HashSet[MAttribute] */; +val* var19 /* : MModule */; +val* var21 /* : MModule */; +val* var22 /* : Set[MProperty] */; +val* var_23 /* var : Set[MProperty] */; +val* var24 /* : Iterator[nullable Object] */; +val* var_25 /* var : Iterator[MProperty] */; +short int var26 /* : Bool */; +val* var27 /* : nullable Object */; +val* var_mprop /* var mprop: MProperty */; +short int var28 /* : Bool */; +int cltype; +int idtype; +short int var29 /* : Bool */; +short int var30 /* : Bool */; +val* var31 /* : ModelBuilder */; +val* var33 /* : ModelBuilder */; +val* var34 /* : ToolContext */; +val* var36 /* : ToolContext */; +val* var37 /* : OptionBool */; +val* var39 /* : OptionBool */; +val* var40 /* : nullable Object */; +val* var42 /* : nullable Object */; +short int var43 /* : Bool */; +short int var44 /* : Bool */; +short int var_45 /* var : Bool */; +val* var46 /* : null */; +short int var47 /* : Bool */; +short int var48 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var50 /* : Bool */; +short int var51 /* : Bool */; +short int var_52 /* var : Bool */; +val* var53 /* : HashSet[MMethod] */; +val* var55 /* : HashSet[MMethod] */; +short int var56 /* : Bool */; +short int var57 /* : Bool */; +val* var58 /* : nullable Object */; +short int var59 /* : Bool */; +int cltype60; +int idtype61; +val* var62 /* : nullable Object */; +val* var67 /* : HashSet[MMethodDef] */; +val* var_all_super_calls /* var all_super_calls: HashSet[MMethodDef] */; +val* var68 /* : MModule */; +val* var70 /* : MModule */; +val* var71 /* : POSetElement[MModule] */; +val* var73 /* : POSetElement[MModule] */; +val* var74 /* : Collection[nullable Object] */; +val* var_75 /* var : Collection[MModule] */; +val* var76 /* : Iterator[nullable Object] */; +val* var_77 /* var : Iterator[MModule] */; +short int var78 /* : Bool */; +val* var79 /* : nullable Object */; +val* var_mmodule /* var mmodule: MModule */; +val* var80 /* : Array[MClassDef] */; +val* var82 /* : Array[MClassDef] */; +val* var_83 /* var : Array[MClassDef] */; +val* var84 /* : ArrayIterator[nullable Object] */; +val* var_85 /* var : ArrayIterator[MClassDef] */; +short int var86 /* : Bool */; +val* var87 /* : nullable Object */; +val* var_mclassdef /* var mclassdef: MClassDef */; +val* var88 /* : Array[MPropDef] */; +val* var90 /* : Array[MPropDef] */; +val* var_91 /* var : Array[MPropDef] */; +val* var92 /* : ArrayIterator[nullable Object] */; +val* var_93 /* var : ArrayIterator[MPropDef] */; +short int var94 /* : Bool */; +val* var95 /* : nullable Object */; +val* var_mpropdef /* var mpropdef: MPropDef */; +short int var96 /* : Bool */; +int cltype97; +int idtype98; +short int var99 /* : Bool */; +short int var101 /* : Bool */; +short int var103 /* : Bool */; +val* var110 /* : null */; +short int var111 /* : Bool */; +short int var112 /* : Bool */; +short int var114 /* : Bool */; +short int var115 /* : Bool */; +val* var116 /* : HashSet[MMethodDef] */; +val* var118 /* : HashSet[MMethodDef] */; +val* var_super_calls /* var super_calls: nullable Object */; +val* var_119 /* var : HashSet[MMethodDef] */; +val* var120 /* : Iterator[nullable Object] */; +val* var_121 /* var : Iterator[MMethodDef] */; +short int var122 /* : Bool */; +val* var123 /* : nullable Object */; +val* var_mmethoddef /* var mmethoddef: MMethodDef */; +val* var124 /* : MClassDef */; +val* var126 /* : MClassDef */; +val* var127 /* : MClass */; +val* var129 /* : MClass */; +val* var_mclass130 /* var mclass: MClass */; +val* var131 /* : nullable Object */; +val* var132 /* : MModule */; +val* var134 /* : MModule */; +val* var135 /* : POSetElement[MClass] */; +val* var136 /* : Collection[nullable Object] */; +val* var_137 /* var : Collection[MClass] */; +val* var138 /* : Iterator[nullable Object] */; +val* var_139 /* var : Iterator[MClass] */; +short int var140 /* : Bool */; +val* var141 /* : nullable Object */; +val* var_descendant /* var descendant: MClass */; +val* var142 /* : nullable Object */; +val* var147 /* : POSetBucketsColorer[MClass, PropertyLayoutElement] */; +val* var148 /* : Map[Object, Set[Object]] */; +val* var_meth_colorer /* var meth_colorer: POSetBucketsColorer[MClass, PropertyLayoutElement] */; +val* var149 /* : Map[Object, Int] */; +val* var151 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var153 /* : Map[PropertyLayoutElement, Int] */; +val* var155 /* : Map[PropertyLayoutElement, Int] */; +val* var_156 /* var : Array[MMethod] */; +val* var157 /* : ArrayIterator[nullable Object] */; +val* var_158 /* var : ArrayIterator[MMethod] */; +short int var159 /* : Bool */; +val* var160 /* : nullable Object */; +val* var_mproperty /* var mproperty: MMethod */; +val* var161 /* : AbstractCompilerVisitor */; +long var162 /* : Int */; +long var163 /* : Int */; +long var165 /* : Int */; +val* var_168 /* var : HashSet[MMethodDef] */; +val* var169 /* : Iterator[nullable Object] */; +val* var_170 /* var : Iterator[MMethodDef] */; +short int var171 /* : Bool */; +val* var172 /* : nullable Object */; +val* var_mpropdef173 /* var mpropdef: MMethodDef */; +short int var174 /* : Bool */; +val* var176 /* : AbstractCompilerVisitor */; +long var177 /* : Int */; +long var178 /* : Int */; +long var180 /* : Int */; +val* var183 /* : POSetBucketsColorer[MClass, MAttribute] */; +val* var184 /* : Map[Object, Set[Object]] */; +val* var_attr_colorer /* var attr_colorer: POSetBucketsColorer[MClass, MAttribute] */; +val* var185 /* : Map[Object, Int] */; +val* var187 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var189 /* : Map[MAttribute, Int] */; +val* var191 /* : Map[MAttribute, Int] */; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var2 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var = var2; +RET_LABEL1:(void)0; +} +} +var_rta = var; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var5 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +var6 = nit__model___MModule___flatten_mclass_hierarchy(var3); +} +var_poset = var6; +var7 = NEW_standard__HashSet(&type_standard__HashSet__nit__MClass); +{ +standard___standard__HashSet___from(var7, var_poset); /* Direct call hash_collection#HashSet#from on */ +} +var_mclasses = var7; +var8 = NEW_nit__POSetColorer(&type_nit__POSetColorer__nit__MClass); +{ +{ /* Inline kernel#Object#init (var8) on */ +RET_LABEL9:(void)0; +} +} +var_colorer = var8; +{ +nit___nit__POSetColorer___colorize(var_colorer, var_poset); /* Direct call coloring#POSetColorer#colorize on */ +} +var10 = NEW_standard__Array(&type_standard__Array__nit__MMethod); +{ +standard___standard__Array___standard__kernel__Object__init(var10); /* Direct call array#Array#init on */ +} +var_dead_methods = var10; +var11 = NEW_standard__HashMap(&type_standard__HashMap__nit__MClass__standard__Set__nit__PropertyLayoutElement); +{ +standard___standard__HashMap___standard__kernel__Object__init(var11); /* Direct call hash_collection#HashMap#init on */ +} +var_mmethods = var11; +var12 = NEW_standard__HashMap(&type_standard__HashMap__nit__MClass__standard__Set__nit__MAttribute); +{ +standard___standard__HashMap___standard__kernel__Object__init(var12); /* Direct call hash_collection#HashMap#init on */ +} +var_mattributes = var12; +var_ = var_mclasses; +{ +var13 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_); +} +var_14 = var13; +for(;;) { +{ +var15 = ((short int (*)(val* self))(var_14->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_14) /* is_ok on */; +} +if (var15){ +{ +var16 = ((val* (*)(val* self))(var_14->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_14) /* item on */; +} +var_mclass = var16; +var17 = NEW_standard__HashSet(&type_standard__HashSet__nit__PropertyLayoutElement); +{ +standard___standard__HashSet___standard__kernel__Object__init(var17); /* Direct call hash_collection#HashSet#init on */ +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_mmethods, var_mclass, var17); /* Direct call hash_collection#HashMap#[]= on */ +} +var18 = NEW_standard__HashSet(&type_standard__HashSet__nit__MAttribute); +{ +standard___standard__HashSet___standard__kernel__Object__init(var18); /* Direct call hash_collection#HashSet#init on */ +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_mattributes, var_mclass, var18); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var21 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var21 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var19 = var21; +RET_LABEL20:(void)0; +} +} +{ +var22 = nit__abstract_compiler___MModule___properties(var19, var_mclass); +} +var_23 = var22; +{ +var24 = ((val* (*)(val* self))(var_23->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_23) /* iterator on */; +} +var_25 = var24; +for(;;) { +{ +var26 = ((short int (*)(val* self))(var_25->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_25) /* is_ok on */; +} +if (var26){ +{ +var27 = ((val* (*)(val* self))(var_25->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_25) /* item on */; +} +var_mprop = var27; +/* isa MMethod */ +cltype = type_nit__MMethod.color; +idtype = type_nit__MMethod.id; +if(cltype >= var_mprop->type->table_size) { +var28 = 0; +} else { +var28 = var_mprop->type->type_table[cltype] == idtype; +} +if (var28){ +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var33 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var33 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var31 = var33; +RET_LABEL32:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var31) on */ +var36 = var31->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var36 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_colo_dead_methods (var34) on */ +var39 = var34->attrs[COLOR_nit__separate_compiler__ToolContext___opt_colo_dead_methods].val; /* _opt_colo_dead_methods on */ +if (unlikely(var39 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_colo_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 45); +show_backtrace(1); +} +var37 = var39; +RET_LABEL38:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var37) on */ +var42 = var37->attrs[COLOR_opts__Option___value].val; /* _value on */ +var40 = var42; +RET_LABEL41:(void)0; +} +} +var43 = ((struct instance_standard__Bool*)var40)->value; /* autounbox from nullable Object to Bool */; +var44 = !var43; +var_45 = var44; +if (var44){ +var46 = NULL; +if (var_rta == NULL) { +var47 = 0; /* is null */ +} else { +var47 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_rta,var46) on */ +var_other = var46; +{ +var50 = ((short int (*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other) /* == on */; +} +var51 = !var50; +var48 = var51; +goto RET_LABEL49; +RET_LABEL49:(void)0; +} +var47 = var48; +} +var30 = var47; +} else { +var30 = var_45; +} +var_52 = var30; +if (var30){ +{ +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methods (var_rta) on */ +var55 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on */ +if (unlikely(var55 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75); +show_backtrace(1); +} +var53 = var55; +RET_LABEL54:(void)0; +} +} +{ +var56 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var53, var_mprop); +} +var57 = !var56; +var29 = var57; +} else { +var29 = var_52; +} +if (var29){ +{ +standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var_dead_methods, var_mprop); /* Direct call array#Array#add on */ +} +goto BREAK_label; +} else { +} +{ +var58 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_mmethods, var_mclass); +} +{ +((void (*)(val* self, val* p0))(var58->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var58, var_mprop) /* add on */; +} +} else { +/* isa MAttribute */ +cltype60 = type_nit__MAttribute.color; +idtype61 = type_nit__MAttribute.id; +if(cltype60 >= var_mprop->type->table_size) { +var59 = 0; +} else { +var59 = var_mprop->type->type_table[cltype60] == idtype61; +} +if (var59){ +{ +var62 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_mattributes, var_mclass); +} +{ +((void (*)(val* self, val* p0))(var62->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var62, var_mprop) /* add on */; +} +} else { +} +} +BREAK_label: (void)0; +{ +((void (*)(val* self))(var_25->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_25) /* next on */; +} +} else { +goto BREAK_label63; +} +} +BREAK_label63: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_25) on */ +RET_LABEL64:(void)0; +} +} +{ +((void (*)(val* self))(var_14->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_14) /* next on */; +} +} else { +goto BREAK_label65; +} +} +BREAK_label65: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_14) on */ +RET_LABEL66:(void)0; +} +} +var67 = NEW_standard__HashSet(&type_standard__HashSet__nit__MMethodDef); +{ +standard___standard__HashSet___standard__kernel__Object__init(var67); /* Direct call hash_collection#HashSet#init on */ +} +var_all_super_calls = var67; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var70 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var70 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var68 = var70; +RET_LABEL69:(void)0; +} +} +{ +{ /* Inline mmodule#MModule#in_importation (var68) on */ +var73 = var68->attrs[COLOR_nit__mmodule__MModule___in_importation].val; /* _in_importation on */ +if (unlikely(var73 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _in_importation"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__mmodule, 96); +show_backtrace(1); +} +var71 = var73; +RET_LABEL72:(void)0; +} +} +{ +var74 = poset___poset__POSetElement___greaters(var71); +} +var_75 = var74; +{ +var76 = ((val* (*)(val* self))(var_75->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_75) /* iterator on */; +} +var_77 = var76; +for(;;) { +{ +var78 = ((short int (*)(val* self))(var_77->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_77) /* is_ok on */; +} +if (var78){ +{ +var79 = ((val* (*)(val* self))(var_77->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_77) /* item on */; +} +var_mmodule = var79; +{ +{ /* Inline model#MModule#mclassdefs (var_mmodule) on */ +var82 = var_mmodule->attrs[COLOR_nit__model__MModule___mclassdefs].val; /* _mclassdefs on */ +if (unlikely(var82 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 131); +show_backtrace(1); +} +var80 = var82; +RET_LABEL81:(void)0; +} +} +var_83 = var80; +{ +var84 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_83); +} +var_85 = var84; +for(;;) { +{ +var86 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_85); +} +if (var86){ +{ +var87 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_85); +} +var_mclassdef = var87; +{ +{ /* Inline model#MClassDef#mpropdefs (var_mclassdef) on */ +var90 = var_mclassdef->attrs[COLOR_nit__model__MClassDef___mpropdefs].val; /* _mpropdefs on */ +if (unlikely(var90 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 623); +show_backtrace(1); +} +var88 = var90; +RET_LABEL89:(void)0; +} +} +var_91 = var88; +{ +var92 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_91); +} +var_93 = var92; +for(;;) { +{ +var94 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_93); +} +if (var94){ +{ +var95 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_93); +} +var_mpropdef = var95; +/* isa MMethodDef */ +cltype97 = type_nit__MMethodDef.color; +idtype98 = type_nit__MMethodDef.id; +if(cltype97 >= var_mpropdef->type->table_size) { +var96 = 0; +} else { +var96 = var_mpropdef->type->type_table[cltype97] == idtype98; +} +var99 = !var96; +if (var99){ +goto BREAK_label100; +} else { +} +{ +{ /* Inline modelize_property#MPropDef#has_supercall (var_mpropdef) on */ +var103 = var_mpropdef->attrs[COLOR_nit__modelize_property__MPropDef___has_supercall].s; /* _has_supercall on */ +var101 = var103; +RET_LABEL102:(void)0; +} +} +if (var101){ +{ +standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var_all_super_calls, var_mpropdef); /* Direct call hash_collection#HashSet#add on */ +} +} else { +} +BREAK_label100: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_93); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label104; +} +} +BREAK_label104: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_93) on */ +RET_LABEL105:(void)0; +} +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_85); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label106; +} +} +BREAK_label106: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_85) on */ +RET_LABEL107:(void)0; +} +} +{ +((void (*)(val* self))(var_77->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_77) /* next on */; +} +} else { +goto BREAK_label108; +} +} +BREAK_label108: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_77) on */ +RET_LABEL109:(void)0; +} +} +var110 = NULL; +if (var_rta == NULL) { +var111 = 0; /* is null */ +} else { +var111 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_rta,var110) on */ +var_other = var110; +{ +var114 = ((short int (*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other) /* == on */; +} +var115 = !var114; +var112 = var115; +goto RET_LABEL113; +RET_LABEL113:(void)0; +} +var111 = var112; +} +if (var111){ +{ +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (var_rta) on */ +var118 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on */ +if (unlikely(var118 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 107); +show_backtrace(1); +} +var116 = var118; +RET_LABEL117:(void)0; +} +} +var_super_calls = var116; +} else { +var_super_calls = var_all_super_calls; +} +var_119 = var_super_calls; +{ +var120 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_119); +} +var_121 = var120; +for(;;) { +{ +var122 = ((short int (*)(val* self))(var_121->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_121) /* is_ok on */; +} +if (var122){ +{ +var123 = ((val* (*)(val* self))(var_121->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_121) /* item on */; +} +var_mmethoddef = var123; +{ +{ /* Inline model#MPropDef#mclassdef (var_mmethoddef) on */ +var126 = var_mmethoddef->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var126 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); +show_backtrace(1); +} +var124 = var126; +RET_LABEL125:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mclass (var124) on */ +var129 = var124->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var129 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 492); +show_backtrace(1); +} +var127 = var129; +RET_LABEL128:(void)0; +} +} +var_mclass130 = var127; +{ +var131 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_mmethods, var_mclass130); +} +{ +((void (*)(val* self, val* p0))(var131->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var131, var_mmethoddef) /* add on */; +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var134 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var134 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var132 = var134; +RET_LABEL133:(void)0; +} +} +{ +var135 = nit___nit__MClass___in_hierarchy(var_mclass130, var132); +} +{ +var136 = poset___poset__POSetElement___smallers(var135); +} +var_137 = var136; +{ +var138 = ((val* (*)(val* self))(var_137->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_137) /* iterator on */; +} +var_139 = var138; +for(;;) { +{ +var140 = ((short int (*)(val* self))(var_139->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_139) /* is_ok on */; +} +if (var140){ +{ +var141 = ((val* (*)(val* self))(var_139->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_139) /* item on */; +} +var_descendant = var141; +{ +var142 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_mmethods, var_descendant); +} +{ +((void (*)(val* self, val* p0))(var142->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var142, var_mmethoddef) /* add on */; +} +{ +((void (*)(val* self))(var_139->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_139) /* next on */; +} +} else { +goto BREAK_label143; +} +} +BREAK_label143: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_139) on */ +RET_LABEL144:(void)0; +} +} +{ +((void (*)(val* self))(var_121->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_121) /* next on */; +} +} else { +goto BREAK_label145; +} +} +BREAK_label145: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_121) on */ +RET_LABEL146:(void)0; +} +} +var147 = NEW_nit__POSetBucketsColorer(&type_nit__POSetBucketsColorer__nit__MClass__nit__PropertyLayoutElement); +{ +var148 = nit___nit__POSetColorer___conflicts(var_colorer); +} +{ +((void (*)(val* self, val* p0))(var147->class->vft[COLOR_nit__coloring__POSetBucketsColorer__poset_61d]))(var147, var_poset) /* poset= on */; +} +{ +((void (*)(val* self, val* p0))(var147->class->vft[COLOR_nit__coloring__POSetBucketsColorer__conflicts_61d]))(var147, var148) /* conflicts= on */; +} +{ +((void (*)(val* self))(var147->class->vft[COLOR_standard__kernel__Object__init]))(var147) /* init on */; +} +var_meth_colorer = var147; +{ +var149 = nit___nit__POSetBucketsColorer___colorize(var_meth_colorer, var_mmethods); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_colors= (self,var149) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val = var149; /* _method_colors on */ +RET_LABEL150:(void)0; +} +} +{ +var151 = nit___nit__SeparateCompiler___build_method_tables(self, var_mclasses, var_super_calls); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_tables= (self,var151) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val = var151; /* _method_tables on */ +RET_LABEL152:(void)0; +} +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_colors (self) on */ +var155 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val; /* _method_colors on */ +if (unlikely(var155 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 127); +show_backtrace(1); +} +var153 = var155; +RET_LABEL154:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_color_consts(self, var153); /* Direct call separate_compiler#SeparateCompiler#compile_color_consts on */ +} +var_156 = var_dead_methods; +{ +var157 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_156); +} +var_158 = var157; +for(;;) { +{ +var159 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_158); +} +if (var159){ +{ +var160 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_158); +} +var_mproperty = var160; +{ +var161 = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +} +var162 = 1; +{ +{ /* Inline kernel#Int#unary - (var162) on */ +var165 = -var162; +var163 = var165; +goto RET_LABEL164; +RET_LABEL164:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_color_const(self, var161, var_mproperty, var163); /* Direct call separate_compiler#SeparateCompiler#compile_color_const on */ +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_158); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label166; +} +} +BREAK_label166: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_158) on */ +RET_LABEL167:(void)0; +} +} +var_168 = var_all_super_calls; +{ +var169 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_168); +} +var_170 = var169; +for(;;) { +{ +var171 = ((short int (*)(val* self))(var_170->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_170) /* is_ok on */; +} +if (var171){ +{ +var172 = ((val* (*)(val* self))(var_170->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_170) /* item on */; +} +var_mpropdef173 = var172; +{ +var174 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var_super_calls, var_mpropdef173); +} +if (var174){ +goto BREAK_label175; +} else { +} +{ +var176 = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +} +var177 = 1; +{ +{ /* Inline kernel#Int#unary - (var177) on */ +var180 = -var177; +var178 = var180; +goto RET_LABEL179; +RET_LABEL179:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_color_const(self, var176, var_mpropdef173, var178); /* Direct call separate_compiler#SeparateCompiler#compile_color_const on */ +} +BREAK_label175: (void)0; +{ +((void (*)(val* self))(var_170->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_170) /* next on */; +} +} else { +goto BREAK_label181; +} +} +BREAK_label181: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_170) on */ +RET_LABEL182:(void)0; +} +} +var183 = NEW_nit__POSetBucketsColorer(&type_nit__POSetBucketsColorer__nit__MClass__nit__MAttribute); +{ +var184 = nit___nit__POSetColorer___conflicts(var_colorer); +} +{ +((void (*)(val* self, val* p0))(var183->class->vft[COLOR_nit__coloring__POSetBucketsColorer__poset_61d]))(var183, var_poset) /* poset= on */; +} +{ +((void (*)(val* self, val* p0))(var183->class->vft[COLOR_nit__coloring__POSetBucketsColorer__conflicts_61d]))(var183, var184) /* conflicts= on */; +} +{ +((void (*)(val* self))(var183->class->vft[COLOR_standard__kernel__Object__init]))(var183) /* init on */; +} +var_attr_colorer = var183; +{ +var185 = nit___nit__POSetBucketsColorer___colorize(var_attr_colorer, var_mattributes); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_colors= (self,var185) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val = var185; /* _attr_colors on */ +RET_LABEL186:(void)0; +} +} +{ +var187 = nit___nit__SeparateCompiler___build_attr_tables(self, var_mclasses); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_tables= (self,var187) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val = var187; /* _attr_tables on */ +RET_LABEL188:(void)0; +} +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_colors (self) on */ +var191 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val; /* _attr_colors on */ +if (unlikely(var191 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 128); +show_backtrace(1); +} +var189 = var191; +RET_LABEL190:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_color_consts(self, var189); /* Direct call separate_compiler#SeparateCompiler#compile_color_consts on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#build_method_tables for (self: SeparateCompiler, Set[MClass], Set[MMethodDef]): Map[MClass, Array[nullable MPropDef]] */ +val* nit___nit__SeparateCompiler___build_method_tables(val* self, val* p0, val* p1) { +val* var /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_mclasses /* var mclasses: Set[MClass] */; +val* var_super_calls /* var super_calls: Set[MMethodDef] */; +val* var1 /* : HashMap[MClass, Array[nullable MPropDef]] */; +val* var_tables /* var tables: HashMap[MClass, Array[nullable MPropDef]] */; +val* var_ /* var : Set[MClass] */; +val* var2 /* : Iterator[nullable Object] */; +val* var_3 /* var : Iterator[MClass] */; +short int var4 /* : Bool */; +val* var5 /* : nullable Object */; +val* var_mclass /* var mclass: MClass */; +val* var6 /* : Array[nullable MPropDef] */; +val* var_table /* var table: Array[nullable MPropDef] */; +val* var7 /* : MModule */; +val* var9 /* : MModule */; +val* var10 /* : Set[MProperty] */; +val* var_mproperties /* var mproperties: Set[MProperty] */; +val* var11 /* : MClassDef */; +val* var13 /* : MClassDef */; +val* var14 /* : MClassType */; +val* var16 /* : MClassType */; +val* var_mtype /* var mtype: MClassType */; +val* var_17 /* var : Set[MProperty] */; +val* var18 /* : Iterator[nullable Object] */; +val* var_19 /* var : Iterator[MProperty] */; +short int var20 /* : Bool */; +val* var21 /* : nullable Object */; +val* var_mproperty /* var mproperty: MProperty */; +short int var22 /* : Bool */; +int cltype; +int idtype; +short int var23 /* : Bool */; +val* var24 /* : Map[PropertyLayoutElement, Int] */; +val* var26 /* : Map[PropertyLayoutElement, Int] */; +short int var27 /* : Bool */; +short int var28 /* : Bool */; +val* var29 /* : Map[PropertyLayoutElement, Int] */; +val* var31 /* : Map[PropertyLayoutElement, Int] */; +val* var32 /* : nullable Object */; +long var33 /* : Int */; +long var_color /* var color: Int */; +long var34 /* : Int */; +long var36 /* : Int */; +short int var37 /* : Bool */; +short int var39 /* : Bool */; +int cltype40; +int idtype41; +const char* var_class_name; +short int var42 /* : Bool */; +long var43 /* : Int */; +long var45 /* : Int */; +long var_i /* var i: Int */; +long var_46 /* var : Int */; +short int var47 /* : Bool */; +short int var49 /* : Bool */; +int cltype50; +int idtype51; +const char* var_class_name52; +short int var53 /* : Bool */; +val* var54 /* : null */; +long var55 /* : Int */; +long var56 /* : Int */; +val* var58 /* : MModule */; +val* var60 /* : MModule */; +val* var61 /* : MPropDef */; +val* var_64 /* var : Set[MMethodDef] */; +val* var65 /* : Iterator[nullable Object] */; +val* var_66 /* var : Iterator[MMethodDef] */; +short int var67 /* : Bool */; +val* var68 /* : nullable Object */; +val* var_supercall /* var supercall: MMethodDef */; +val* var69 /* : MModule */; +val* var71 /* : MModule */; +val* var72 /* : Set[MClassDef] */; +val* var73 /* : MClassDef */; +val* var75 /* : MClassDef */; +short int var76 /* : Bool */; +short int var77 /* : Bool */; +val* var79 /* : Map[PropertyLayoutElement, Int] */; +val* var81 /* : Map[PropertyLayoutElement, Int] */; +val* var82 /* : nullable Object */; +long var83 /* : Int */; +long var_color84 /* var color: Int */; +long var85 /* : Int */; +long var87 /* : Int */; +short int var88 /* : Bool */; +short int var90 /* : Bool */; +int cltype91; +int idtype92; +const char* var_class_name93; +short int var94 /* : Bool */; +long var95 /* : Int */; +long var97 /* : Int */; +long var_i98 /* var i: Int */; +long var_99 /* var : Int */; +short int var100 /* : Bool */; +short int var102 /* : Bool */; +int cltype103; +int idtype104; +const char* var_class_name105; +short int var106 /* : Bool */; +val* var107 /* : null */; +long var108 /* : Int */; +long var109 /* : Int */; +val* var111 /* : MModule */; +val* var113 /* : MModule */; +val* var114 /* : MPropDef */; +val* var_mmethoddef /* var mmethoddef: MMethodDef */; +var_mclasses = p0; +var_super_calls = p1; +var1 = NEW_standard__HashMap(&type_standard__HashMap__nit__MClass__standard__Array__nullable__nit__MPropDef); +{ +standard___standard__HashMap___standard__kernel__Object__init(var1); /* Direct call hash_collection#HashMap#init on */ +} +var_tables = var1; +var_ = var_mclasses; +{ +var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on */; +} +var_3 = var2; +for(;;) { +{ +var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on */; +} +if (var4){ +{ +var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on */; +} +var_mclass = var5; +var6 = NEW_standard__Array(&type_standard__Array__nullable__nit__MPropDef); +{ +standard___standard__Array___standard__kernel__Object__init(var6); /* Direct call array#Array#init on */ +} +var_table = var6; +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_tables, var_mclass, var_table); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var9 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +var10 = nit__abstract_compiler___MModule___properties(var7, var_mclass); +} +var_mproperties = var10; +{ +{ /* Inline model#MClass#intro (var_mclass) on */ +var13 = var_mclass->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 423); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var11) on */ +var16 = var11->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +var_mtype = var14; +var_17 = var_mproperties; +{ +var18 = ((val* (*)(val* self))(var_17->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_17) /* iterator on */; +} +var_19 = var18; +for(;;) { +{ +var20 = ((short int (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_19) /* is_ok on */; +} +if (var20){ +{ +var21 = ((val* (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_19) /* item on */; +} +var_mproperty = var21; +/* isa MMethod */ +cltype = type_nit__MMethod.color; +idtype = type_nit__MMethod.id; +if(cltype >= var_mproperty->type->table_size) { +var22 = 0; +} else { +var22 = var_mproperty->type->type_table[cltype] == idtype; +} +var23 = !var22; +if (var23){ +goto BREAK_label; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_colors (self) on */ +var26 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val; /* _method_colors on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 127); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = standard___standard__MapRead___has_key(var24, var_mproperty); +} +var28 = !var27; +if (var28){ +goto BREAK_label; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_colors (self) on */ +var31 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val; /* _method_colors on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 127); +show_backtrace(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +{ +var32 = ((val* (*)(val* self, val* p0))(var29->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var29, var_mproperty) /* [] on */; +} +var33 = ((struct instance_standard__Int*)var32)->value; /* autounbox from nullable Object to Int */; +var_color = var33; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var36 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline kernel#Int#<= (var34,var_color) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var39 = 1; /* easy isa OTHER*/ +if (unlikely(!var39)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 409); +show_backtrace(1); +} +var42 = var34 <= var_color; +var37 = var42; +goto RET_LABEL38; +RET_LABEL38:(void)0; +} +} +if (var37){ +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var45 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var43 = var45; +RET_LABEL44:(void)0; +} +} +var_i = var43; +var_46 = var_color; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_46) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var49 = 1; /* easy isa OTHER*/ +if (unlikely(!var49)) { +var_class_name52 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name52); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); +show_backtrace(1); +} +var53 = var_i < var_46; +var47 = var53; +goto RET_LABEL48; +RET_LABEL48:(void)0; +} +} +if (var47){ +var54 = NULL; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_i, var54); /* Direct call array#Array#[]= on */ +} +var55 = 1; +{ +var56 = standard___standard__Int___Discrete__successor(var_i, var55); +} +var_i = var56; +} else { +goto BREAK_label57; +} +} +BREAK_label57: (void)0; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var60 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var60 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var58 = var60; +RET_LABEL59:(void)0; +} +} +{ +var61 = nit___nit__MProperty___lookup_first_definition(var_mproperty, var58, var_mtype); +} +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_color, var61); /* Direct call array#Array#[]= on */ +} +BREAK_label: (void)0; +{ +((void (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_19) /* next on */; +} +} else { +goto BREAK_label62; +} +} +BREAK_label62: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_19) on */ +RET_LABEL63:(void)0; +} +} +var_64 = var_super_calls; +{ +var65 = ((val* (*)(val* self))(var_64->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_64) /* iterator on */; +} +var_66 = var65; +for(;;) { +{ +var67 = ((short int (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_66) /* is_ok on */; +} +if (var67){ +{ +var68 = ((val* (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_66) /* item on */; +} +var_supercall = var68; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var71 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var71 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var69 = var71; +RET_LABEL70:(void)0; +} +} +{ +var72 = nit___nit__MClassType___MType__collect_mclassdefs(var_mtype, var69); +} +{ +{ /* Inline model#MPropDef#mclassdef (var_supercall) on */ +var75 = var_supercall->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var75 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); +show_backtrace(1); +} +var73 = var75; +RET_LABEL74:(void)0; +} +} +{ +var76 = ((short int (*)(val* self, val* p0))(var72->class->vft[COLOR_standard__abstract_collection__Collection__has]))(var72, var73) /* has on */; +} +var77 = !var76; +if (var77){ +goto BREAK_label78; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_colors (self) on */ +var81 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_colors].val; /* _method_colors on */ +if (unlikely(var81 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 127); +show_backtrace(1); +} +var79 = var81; +RET_LABEL80:(void)0; +} +} +{ +var82 = ((val* (*)(val* self, val* p0))(var79->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var79, var_supercall) /* [] on */; +} +var83 = ((struct instance_standard__Int*)var82)->value; /* autounbox from nullable Object to Int */; +var_color84 = var83; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var87 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var85 = var87; +RET_LABEL86:(void)0; +} +} +{ +{ /* Inline kernel#Int#<= (var85,var_color84) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var90 = 1; /* easy isa OTHER*/ +if (unlikely(!var90)) { +var_class_name93 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name93); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 409); +show_backtrace(1); +} +var94 = var85 <= var_color84; +var88 = var94; +goto RET_LABEL89; +RET_LABEL89:(void)0; +} +} +if (var88){ +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var97 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var95 = var97; +RET_LABEL96:(void)0; +} +} +var_i98 = var95; +var_99 = var_color84; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i98,var_99) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var102 = 1; /* easy isa OTHER*/ +if (unlikely(!var102)) { +var_class_name105 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name105); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); +show_backtrace(1); +} +var106 = var_i98 < var_99; +var100 = var106; +goto RET_LABEL101; +RET_LABEL101:(void)0; +} +} +if (var100){ +var107 = NULL; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_i98, var107); /* Direct call array#Array#[]= on */ +} +var108 = 1; +{ +var109 = standard___standard__Int___Discrete__successor(var_i98, var108); +} +var_i98 = var109; +} else { +goto BREAK_label110; +} +} +BREAK_label110: (void)0; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var113 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var113 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var111 = var113; +RET_LABEL112:(void)0; +} +} +{ +var114 = nit___nit__MPropDef___lookup_next_definition(var_supercall, var111, var_mtype); +} +var_mmethoddef = var114; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_color84, var_mmethoddef); /* Direct call array#Array#[]= on */ +} +BREAK_label78: (void)0; +{ +((void (*)(val* self))(var_66->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_66) /* next on */; +} +} else { +goto BREAK_label115; +} +} +BREAK_label115: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_66) on */ +RET_LABEL116:(void)0; +} +} +{ +((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on */; +} +} else { +goto BREAK_label117; +} +} +BREAK_label117: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_3) on */ +RET_LABEL118:(void)0; +} +} +var = var_tables; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#build_attr_tables for (self: SeparateCompiler, Set[MClass]): Map[MClass, Array[nullable MPropDef]] */ +val* nit___nit__SeparateCompiler___build_attr_tables(val* self, val* p0) { +val* var /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_mclasses /* var mclasses: Set[MClass] */; +val* var1 /* : HashMap[MClass, Array[nullable MPropDef]] */; +val* var_tables /* var tables: HashMap[MClass, Array[nullable MPropDef]] */; +val* var_ /* var : Set[MClass] */; +val* var2 /* : Iterator[nullable Object] */; +val* var_3 /* var : Iterator[MClass] */; +short int var4 /* : Bool */; +val* var5 /* : nullable Object */; +val* var_mclass /* var mclass: MClass */; +val* var6 /* : Array[nullable MPropDef] */; +val* var_table /* var table: Array[nullable MPropDef] */; +val* var7 /* : MModule */; +val* var9 /* : MModule */; +val* var10 /* : Set[MProperty] */; +val* var_mproperties /* var mproperties: Set[MProperty] */; +val* var11 /* : MClassDef */; +val* var13 /* : MClassDef */; +val* var14 /* : MClassType */; +val* var16 /* : MClassType */; +val* var_mtype /* var mtype: MClassType */; +val* var_17 /* var : Set[MProperty] */; +val* var18 /* : Iterator[nullable Object] */; +val* var_19 /* var : Iterator[MProperty] */; +short int var20 /* : Bool */; +val* var21 /* : nullable Object */; +val* var_mproperty /* var mproperty: MProperty */; +short int var22 /* : Bool */; +int cltype; +int idtype; +short int var23 /* : Bool */; +val* var24 /* : Map[MAttribute, Int] */; +val* var26 /* : Map[MAttribute, Int] */; +short int var27 /* : Bool */; +short int var28 /* : Bool */; +val* var29 /* : Map[MAttribute, Int] */; +val* var31 /* : Map[MAttribute, Int] */; +val* var32 /* : nullable Object */; +long var33 /* : Int */; +long var_color /* var color: Int */; +long var34 /* : Int */; +long var36 /* : Int */; +short int var37 /* : Bool */; +short int var39 /* : Bool */; +int cltype40; +int idtype41; +const char* var_class_name; +short int var42 /* : Bool */; +long var43 /* : Int */; +long var45 /* : Int */; +long var_i /* var i: Int */; +long var_46 /* var : Int */; +short int var47 /* : Bool */; +short int var49 /* : Bool */; +int cltype50; +int idtype51; +const char* var_class_name52; +short int var53 /* : Bool */; +val* var54 /* : null */; +long var55 /* : Int */; +long var56 /* : Int */; +val* var58 /* : MModule */; +val* var60 /* : MModule */; +val* var61 /* : MPropDef */; +var_mclasses = p0; +var1 = NEW_standard__HashMap(&type_standard__HashMap__nit__MClass__standard__Array__nullable__nit__MPropDef); +{ +standard___standard__HashMap___standard__kernel__Object__init(var1); /* Direct call hash_collection#HashMap#init on */ +} +var_tables = var1; +var_ = var_mclasses; +{ +var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on */; +} +var_3 = var2; +for(;;) { +{ +var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on */; +} +if (var4){ +{ +var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on */; +} +var_mclass = var5; +var6 = NEW_standard__Array(&type_standard__Array__nullable__nit__MPropDef); +{ +standard___standard__Array___standard__kernel__Object__init(var6); /* Direct call array#Array#init on */ +} +var_table = var6; +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_tables, var_mclass, var_table); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var9 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +var10 = nit__abstract_compiler___MModule___properties(var7, var_mclass); +} +var_mproperties = var10; +{ +{ /* Inline model#MClass#intro (var_mclass) on */ +var13 = var_mclass->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 423); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var11) on */ +var16 = var11->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +var_mtype = var14; +var_17 = var_mproperties; +{ +var18 = ((val* (*)(val* self))(var_17->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_17) /* iterator on */; +} +var_19 = var18; +for(;;) { +{ +var20 = ((short int (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_19) /* is_ok on */; +} +if (var20){ +{ +var21 = ((val* (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_19) /* item on */; +} +var_mproperty = var21; +/* isa MAttribute */ +cltype = type_nit__MAttribute.color; +idtype = type_nit__MAttribute.id; +if(cltype >= var_mproperty->type->table_size) { +var22 = 0; +} else { +var22 = var_mproperty->type->type_table[cltype] == idtype; +} +var23 = !var22; +if (var23){ +goto BREAK_label; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_colors (self) on */ +var26 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val; /* _attr_colors on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 128); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +var27 = standard___standard__MapRead___has_key(var24, var_mproperty); +} +var28 = !var27; +if (var28){ +goto BREAK_label; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_colors (self) on */ +var31 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_colors].val; /* _attr_colors on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 128); +show_backtrace(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +{ +var32 = ((val* (*)(val* self, val* p0))(var29->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var29, var_mproperty) /* [] on */; +} +var33 = ((struct instance_standard__Int*)var32)->value; /* autounbox from nullable Object to Int */; +var_color = var33; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var36 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline kernel#Int#<= (var34,var_color) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var39 = 1; /* easy isa OTHER*/ +if (unlikely(!var39)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 409); +show_backtrace(1); +} +var42 = var34 <= var_color; +var37 = var42; +goto RET_LABEL38; +RET_LABEL38:(void)0; +} +} +if (var37){ +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var45 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var43 = var45; +RET_LABEL44:(void)0; +} +} +var_i = var43; +var_46 = var_color; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_46) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var49 = 1; /* easy isa OTHER*/ +if (unlikely(!var49)) { +var_class_name52 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name52); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); +show_backtrace(1); +} +var53 = var_i < var_46; +var47 = var53; +goto RET_LABEL48; +RET_LABEL48:(void)0; +} +} +if (var47){ +var54 = NULL; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_i, var54); /* Direct call array#Array#[]= on */ +} +var55 = 1; +{ +var56 = standard___standard__Int___Discrete__successor(var_i, var55); +} +var_i = var56; +} else { +goto BREAK_label57; +} +} +BREAK_label57: (void)0; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var60 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var60 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var58 = var60; +RET_LABEL59:(void)0; +} +} +{ +var61 = nit___nit__MProperty___lookup_first_definition(var_mproperty, var58, var_mtype); +} +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_color, var61); /* Direct call array#Array#[]= on */ +} +BREAK_label: (void)0; +{ +((void (*)(val* self))(var_19->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_19) /* next on */; +} +} else { +goto BREAK_label62; +} +} +BREAK_label62: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_19) on */ +RET_LABEL63:(void)0; +} +} +{ +((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on */; +} +} else { +goto BREAK_label64; +} +} +BREAK_label64: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_3) on */ +RET_LABEL65:(void)0; +} +} +var = var_tables; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#do_type_coloring for (self: SeparateCompiler): POSet[MType] */ +val* nit___nit__SeparateCompiler___do_type_coloring(val* self) { +val* var /* : POSet[MType] */; +val* var1 /* : nullable RapidTypeAnalysis */; +val* var3 /* : nullable RapidTypeAnalysis */; +val* var4 /* : HashSet[MClassType] */; +val* var6 /* : HashSet[MClassType] */; +val* var_live_types /* var live_types: HashSet[MClassType] */; +val* var7 /* : nullable RapidTypeAnalysis */; +val* var9 /* : nullable RapidTypeAnalysis */; +val* var10 /* : HashSet[MType] */; +val* var12 /* : HashSet[MType] */; +val* var_live_cast_types /* var live_cast_types: HashSet[MType] */; +val* var13 /* : HashSet[MType] */; +val* var_mtypes /* var mtypes: HashSet[MType] */; +val* var14 /* : HashMap[MClass, Int] */; +val* var16 /* : HashMap[MClass, Int] */; +val* var17 /* : RemovableCollection[nullable Object] */; +val* var19 /* : RemovableCollection[nullable Object] */; +val* var_ /* var : RemovableCollection[MClass] */; +val* var20 /* : Iterator[nullable Object] */; +val* var_21 /* var : Iterator[MClass] */; +short int var22 /* : Bool */; +val* var23 /* : nullable Object */; +val* var_c /* var c: MClass */; +val* var24 /* : MClassType */; +val* var26 /* : MClassType */; +val* var28 /* : POSet[MType] */; +val* var_poset /* var poset: POSet[MType] */; +val* var29 /* : POSetColorer[MType] */; +val* var_colorer /* var colorer: POSetColorer[MType] */; +val* var31 /* : Map[Object, Int] */; +val* var33 /* : Map[Object, Int] */; +val* var35 /* : Map[MType, Array[nullable MType]] */; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var3 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +if (var1 == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 428); +show_backtrace(1); +} else { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var1) on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var6 = var1->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +var_live_types = var4; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var9 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var7 = var9; +RET_LABEL8:(void)0; +} +} +if (var7 == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 429); +show_backtrace(1); +} else { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (var7) on */ +if (unlikely(var7 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65); +show_backtrace(1); +} +var12 = var7->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on */ +if (unlikely(var12 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65); +show_backtrace(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +var_live_cast_types = var10; +var13 = NEW_standard__HashSet(&type_standard__HashSet__nit__MType); +{ +standard___standard__HashSet___standard__kernel__Object__init(var13); /* Direct call hash_collection#HashSet#init on */ +} +var_mtypes = var13; +{ +standard___standard__SimpleCollection___add_all(var_mtypes, var_live_types); /* Direct call abstract_collection#SimpleCollection#add_all on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var16 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 233); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +{ /* Inline hash_collection#HashMap#keys (var14) on */ +var19 = var14->attrs[COLOR_standard__hash_collection__HashMap___keys].val; /* _keys on */ +if (unlikely(var19 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _keys"); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__hash_collection, 275); +show_backtrace(1); +} +var17 = var19; +RET_LABEL18:(void)0; +} +} +var_ = var17; +{ +var20 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on */; +} +var_21 = var20; +for(;;) { +{ +var22 = ((short int (*)(val* self))(var_21->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_21) /* is_ok on */; +} +if (var22){ +{ +var23 = ((val* (*)(val* self))(var_21->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_21) /* item on */; +} +var_c = var23; +{ +{ /* Inline model#MClass#mclass_type (var_c) on */ +var26 = var_c->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var26 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); +show_backtrace(1); +} +var24 = var26; +RET_LABEL25:(void)0; +} +} +{ +standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var_mtypes, var24); /* Direct call hash_collection#HashSet#add on */ +} +{ +((void (*)(val* self))(var_21->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_21) /* next on */; +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_21) on */ +RET_LABEL27:(void)0; +} +} +{ +var28 = nit___nit__SeparateCompiler___poset_from_mtypes(self, var_mtypes, var_live_cast_types); +} +var_poset = var28; +var29 = NEW_nit__POSetColorer(&type_nit__POSetColorer__nit__MType); +{ +{ /* Inline kernel#Object#init (var29) on */ +RET_LABEL30:(void)0; +} +} +var_colorer = var29; +{ +nit___nit__POSetColorer___colorize(var_colorer, var_poset); /* Direct call coloring#POSetColorer#colorize on */ +} +{ +var31 = nit___nit__POSetColorer___ids(var_colorer); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids= (self,var31) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val = var31; /* _type_ids on */ +RET_LABEL32:(void)0; +} +} +{ +var33 = nit___nit__POSetColorer___colors(var_colorer); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#type_colors= (self,var33) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_colors].val = var33; /* _type_colors on */ +RET_LABEL34:(void)0; +} +} +{ +var35 = nit___nit__SeparateCompiler___build_type_tables(self, var_poset); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#type_tables= (self,var35) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val = var35; /* _type_tables on */ +RET_LABEL36:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_resolution_tables(self, var_mtypes); /* Direct call separate_compiler#SeparateCompiler#compile_resolution_tables on */ +} +var = var_poset; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#poset_from_mtypes for (self: SeparateCompiler, Set[MType], Set[MType]): POSet[MType] */ +val* nit___nit__SeparateCompiler___poset_from_mtypes(val* self, val* p0, val* p1) { +val* var /* : POSet[MType] */; +val* var_mtypes /* var mtypes: Set[MType] */; +val* var_cast_types /* var cast_types: Set[MType] */; +val* var1 /* : POSet[MType] */; +val* var_poset /* var poset: POSet[MType] */; +val* var_ /* var : Set[MType] */; +val* var3 /* : Iterator[nullable Object] */; +val* var_4 /* var : Iterator[MType] */; +short int var5 /* : Bool */; +val* var6 /* : nullable Object */; +val* var_e /* var e: MType */; +val* var7 /* : POSetElement[nullable Object] */; +val* var_8 /* var : Set[MType] */; +val* var9 /* : Iterator[nullable Object] */; +val* var_10 /* var : Iterator[MType] */; +short int var11 /* : Bool */; +val* var12 /* : nullable Object */; +val* var_o /* var o: MType */; +short int var13 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var15 /* : Bool */; +short int var17 /* : Bool */; +val* var18 /* : POSetElement[nullable Object] */; +val* var19 /* : MModule */; +val* var21 /* : MModule */; +val* var22 /* : null */; +short int var23 /* : Bool */; +var_mtypes = p0; +var_cast_types = p1; +var1 = NEW_poset__POSet(&type_poset__POSet__nit__MType); +{ +{ /* Inline kernel#Object#init (var1) on */ +RET_LABEL2:(void)0; +} +} +var_poset = var1; +var_ = var_mtypes; +{ +var3 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on */; +} +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; +{ +var7 = poset___poset__POSet___add_node(var_poset, var_e); +} +var_8 = var_cast_types; +{ +var9 = ((val* (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_8) /* iterator on */; +} +var_10 = var9; +for(;;) { +{ +var11 = ((short int (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_10) /* is_ok on */; +} +if (var11){ +{ +var12 = ((val* (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_10) /* item on */; +} +var_o = var12; +{ +{ /* Inline kernel#Object#== (var_e,var_o) on */ +var_other = var_o; +{ +{ /* Inline kernel#Object#is_same_instance (var_e,var_other) on */ +var17 = var_e == var_other; +var15 = var17; +goto RET_LABEL16; +RET_LABEL16:(void)0; +} +} +var13 = var15; +goto RET_LABEL14; +RET_LABEL14:(void)0; +} +} +if (var13){ +goto BREAK_label; +} else { +} +{ +var18 = poset___poset__POSet___add_node(var_poset, var_o); +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var21 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var21 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var19 = var21; +RET_LABEL20:(void)0; +} +} +var22 = NULL; +{ +var23 = nit___nit__MType___is_subtype(var_e, var19, var22, var_o); +} +if (var23){ +{ +poset___poset__POSet___add_edge(var_poset, var_e, var_o); /* Direct call poset#POSet#add_edge on */ +} +} else { +} +BREAK_label: (void)0; +{ +((void (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_10) /* next on */; +} +} else { +goto BREAK_label24; +} +} +BREAK_label24: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_10) on */ +RET_LABEL25:(void)0; +} +} +{ +((void (*)(val* self))(var_4->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_4) /* next on */; +} +} else { +goto BREAK_label26; +} +} +BREAK_label26: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_4) on */ +RET_LABEL27:(void)0; +} +} +var = var_poset; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#build_type_tables for (self: SeparateCompiler, POSet[MType]): Map[MType, Array[nullable MType]] */ +val* nit___nit__SeparateCompiler___build_type_tables(val* self, val* p0) { +val* var /* : Map[MType, Array[nullable MType]] */; +val* var_mtypes /* var mtypes: POSet[MType] */; +val* var1 /* : HashMap[MType, Array[nullable MType]] */; +val* var_tables /* var tables: HashMap[MType, Array[nullable MType]] */; +val* var_ /* var : POSet[MType] */; +val* var2 /* : Iterator[nullable Object] */; +val* var_3 /* var : Iterator[MType] */; +short int var4 /* : Bool */; +val* var5 /* : nullable Object */; +val* var_mtype /* var mtype: MType */; +val* var6 /* : Array[nullable MType] */; +val* var_table /* var table: Array[nullable MType] */; +val* var7 /* : POSetElement[nullable Object] */; +val* var8 /* : Collection[nullable Object] */; +val* var_9 /* var : Collection[MType] */; +val* var10 /* : Iterator[nullable Object] */; +val* var_11 /* var : Iterator[MType] */; +short int var12 /* : Bool */; +val* var13 /* : nullable Object */; +val* var_sup /* var sup: MType */; +val* var14 /* : Map[MType, Int] */; +val* var16 /* : Map[MType, Int] */; +val* var17 /* : nullable Object */; +long var18 /* : Int */; +long var_color /* var color: Int */; +long var19 /* : Int */; +long var21 /* : Int */; +short int var22 /* : Bool */; +short int var24 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var25 /* : Bool */; +long var26 /* : Int */; +long var28 /* : Int */; +long var_i /* var i: Int */; +long var_29 /* var : Int */; +short int var30 /* : Bool */; +short int var32 /* : Bool */; +int cltype33; +int idtype34; +const char* var_class_name35; +short int var36 /* : Bool */; +val* var37 /* : null */; +long var38 /* : Int */; +long var39 /* : Int */; +var_mtypes = p0; +var1 = NEW_standard__HashMap(&type_standard__HashMap__nit__MType__standard__Array__nullable__nit__MType); +{ +standard___standard__HashMap___standard__kernel__Object__init(var1); /* Direct call hash_collection#HashMap#init on */ +} +var_tables = var1; +var_ = var_mtypes; +{ +var2 = poset___poset__POSet___standard__abstract_collection__Collection__iterator(var_); +} +var_3 = var2; +for(;;) { +{ +var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on */; +} +if (var4){ +{ +var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on */; +} +var_mtype = var5; +var6 = NEW_standard__Array(&type_standard__Array__nullable__nit__MType); +{ +standard___standard__Array___standard__kernel__Object__init(var6); /* Direct call array#Array#init on */ +} +var_table = var6; +{ +var7 = poset___poset__POSet____91d_93d(var_mtypes, var_mtype); +} +{ +var8 = poset___poset__POSetElement___greaters(var7); +} +var_9 = var8; +{ +var10 = ((val* (*)(val* self))(var_9->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_9) /* iterator on */; +} +var_11 = var10; +for(;;) { +{ +var12 = ((short int (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_11) /* is_ok on */; +} +if (var12){ +{ +var13 = ((val* (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_11) /* item on */; +} +var_sup = var13; +{ +{ /* Inline separate_compiler#SeparateCompiler#type_colors (self) on */ +var16 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_colors].val; /* _type_colors on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 125); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +var17 = ((val* (*)(val* self, val* p0))(var14->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var14, var_sup) /* [] on */; +} +var18 = ((struct instance_standard__Int*)var17)->value; /* autounbox from nullable Object to Int */; +var_color = var18; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var21 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var19 = var21; +RET_LABEL20:(void)0; +} +} +{ +{ /* Inline kernel#Int#<= (var19,var_color) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var24 = 1; /* easy isa OTHER*/ +if (unlikely(!var24)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 409); +show_backtrace(1); +} +var25 = var19 <= var_color; +var22 = var25; +goto RET_LABEL23; +RET_LABEL23:(void)0; +} +} +if (var22){ +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var28 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var26 = var28; +RET_LABEL27:(void)0; +} +} +var_i = var26; +var_29 = var_color; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_29) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var32 = 1; /* easy isa OTHER*/ +if (unlikely(!var32)) { +var_class_name35 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name35); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); +show_backtrace(1); +} +var36 = var_i < var_29; +var30 = var36; +goto RET_LABEL31; +RET_LABEL31:(void)0; +} +} +if (var30){ +var37 = NULL; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_i, var37); /* Direct call array#Array#[]= on */ +} +var38 = 1; +{ +var39 = standard___standard__Int___Discrete__successor(var_i, var38); +} +var_i = var39; +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +} else { +} +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_color, var_sup); /* Direct call array#Array#[]= on */ +} +{ +((void (*)(val* self))(var_11->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_11) /* next on */; +} +} else { +goto BREAK_label40; +} +} +BREAK_label40: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_11) on */ +RET_LABEL41:(void)0; +} +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_tables, var_mtype, var_table); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on */; +} +} else { +goto BREAK_label42; +} +} +BREAK_label42: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_3) on */ +RET_LABEL43:(void)0; +} +} +var = var_tables; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#compile_resolution_tables for (self: SeparateCompiler, Set[MType]) */ +void nit___nit__SeparateCompiler___compile_resolution_tables(val* self, val* p0) { +val* var_mtypes /* var mtypes: Set[MType] */; +val* var /* : HashMap[MClassType, Set[MType]] */; +val* var_mtype2unresolved /* var mtype2unresolved: HashMap[MClassType, Set[MType]] */; +val* var1 /* : nullable RapidTypeAnalysis */; +val* var3 /* : nullable RapidTypeAnalysis */; +val* var4 /* : HashSet[MClassType] */; +val* var6 /* : HashSet[MClassType] */; +val* var_ /* var : HashSet[MClassType] */; +val* var7 /* : Iterator[nullable Object] */; +val* var_8 /* var : Iterator[MClassType] */; +short int var9 /* : Bool */; +val* var10 /* : nullable Object */; +val* var_mtype /* var mtype: MClassType */; +val* var11 /* : HashSet[MType] */; +val* var_set /* var set: HashSet[MType] */; +val* var12 /* : MModule */; +val* var14 /* : MModule */; +val* var15 /* : Set[MClassDef] */; +val* var_16 /* var : Set[MClassDef] */; +val* var17 /* : Iterator[nullable Object] */; +val* var_18 /* var : Iterator[MClassDef] */; +short int var19 /* : Bool */; +val* var20 /* : nullable Object */; +val* var_cd /* var cd: MClassDef */; +val* var21 /* : Map[MClassDef, Set[MType]] */; +val* var23 /* : Map[MClassDef, Set[MType]] */; +short int var24 /* : Bool */; +val* var25 /* : Map[MClassDef, Set[MType]] */; +val* var27 /* : Map[MClassDef, Set[MType]] */; +val* var28 /* : nullable Object */; +val* var32 /* : BucketsColorer[MType, MType] */; +val* var_colorer /* var colorer: BucketsColorer[MType, MType] */; +val* var34 /* : Map[Object, Int] */; +val* var36 /* : Map[MClassType, Array[nullable MType]] */; +val* var38 /* : HashSet[MType] */; +val* var_all_unresolved /* var all_unresolved: HashSet[MType] */; +val* var39 /* : Map[MClassDef, Set[MType]] */; +val* var41 /* : Map[MClassDef, Set[MType]] */; +val* var42 /* : Collection[nullable Object] */; +val* var_43 /* var : RemovableCollection[Set[MType]] */; +val* var44 /* : Iterator[nullable Object] */; +val* var_45 /* var : Iterator[Set[MType]] */; +short int var46 /* : Bool */; +val* var47 /* : nullable Object */; +val* var_t /* var t: Set[MType] */; +val* var50 /* : HashMap[MType, Int] */; +val* var_all_unresolved_types_colors /* var all_unresolved_types_colors: HashMap[MType, Int] */; +val* var_51 /* var : HashSet[MType] */; +val* var52 /* : Iterator[nullable Object] */; +val* var_53 /* var : Iterator[MType] */; +short int var54 /* : Bool */; +val* var55 /* : nullable Object */; +val* var_t56 /* var t: MType */; +val* var57 /* : Map[MType, Int] */; +val* var59 /* : Map[MType, Int] */; +short int var60 /* : Bool */; +val* var61 /* : Map[MType, Int] */; +val* var63 /* : Map[MType, Int] */; +val* var64 /* : nullable Object */; +long var65 /* : Int */; +long var66 /* : Int */; +long var68 /* : Int */; +val* var69 /* : nullable Object */; +var_mtypes = p0; +var = NEW_standard__HashMap(&type_standard__HashMap__nit__MClassType__standard__Set__nit__MType); +{ +standard___standard__HashMap___standard__kernel__Object__init(var); /* Direct call hash_collection#HashMap#init on */ +} +var_mtype2unresolved = var; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var3 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var1 = var3; +RET_LABEL2:(void)0; +} +} +if (var1 == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 493); +show_backtrace(1); +} else { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var1) on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var6 = var1->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +var_ = var4; +{ +var7 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_); +} +var_8 = var7; +for(;;) { +{ +var9 = ((short int (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_8) /* is_ok on */; +} +if (var9){ +{ +var10 = ((val* (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_8) /* item on */; +} +var_mtype = var10; +var11 = NEW_standard__HashSet(&type_standard__HashSet__nit__MType); +{ +standard___standard__HashSet___standard__kernel__Object__init(var11); /* Direct call hash_collection#HashSet#init on */ +} +var_set = var11; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var14 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +var15 = nit___nit__MClassType___MType__collect_mclassdefs(var_mtype, var12); +} +var_16 = var15; +{ +var17 = ((val* (*)(val* self))(var_16->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_16) /* iterator on */; +} +var_18 = var17; +for(;;) { +{ +var19 = ((short int (*)(val* self))(var_18->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_18) /* is_ok on */; +} +if (var19){ +{ +var20 = ((val* (*)(val* self))(var_18->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_18) /* item on */; +} +var_cd = var20; +{ +{ /* Inline separate_compiler#SeparateCompiler#live_unresolved_types (self) on */ +var23 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___live_unresolved_types].val; /* _live_unresolved_types on */ +if (unlikely(var23 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_unresolved_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 122); +show_backtrace(1); +} +var21 = var23; +RET_LABEL22:(void)0; +} +} +{ +var24 = standard___standard__MapRead___has_key(var21, var_cd); +} +if (var24){ +{ +{ /* Inline separate_compiler#SeparateCompiler#live_unresolved_types (self) on */ +var27 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___live_unresolved_types].val; /* _live_unresolved_types on */ +if (unlikely(var27 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_unresolved_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 122); +show_backtrace(1); +} +var25 = var27; +RET_LABEL26:(void)0; +} +} +{ +var28 = ((val* (*)(val* self, val* p0))(var25->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var25, var_cd) /* [] on */; +} +{ +standard___standard__SimpleCollection___add_all(var_set, var28); /* Direct call abstract_collection#SimpleCollection#add_all on */ +} +} else { +} +{ +((void (*)(val* self))(var_18->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_18) /* next on */; +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_18) on */ +RET_LABEL29:(void)0; +} +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_mtype2unresolved, var_mtype, var_set); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +((void (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_8) /* next on */; +} +} else { +goto BREAK_label30; +} +} +BREAK_label30: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_8) on */ +RET_LABEL31:(void)0; +} +} +var32 = NEW_nit__BucketsColorer(&type_nit__BucketsColorer__nit__MType__nit__MType); +{ +{ /* Inline kernel#Object#init (var32) on */ +RET_LABEL33:(void)0; +} +} +var_colorer = var32; +{ +var34 = nit___nit__BucketsColorer___colorize(var_colorer, var_mtype2unresolved); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#opentype_colors= (self,var34) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val = var34; /* _opentype_colors on */ +RET_LABEL35:(void)0; +} +} +{ +var36 = nit___nit__SeparateCompiler___build_resolution_tables(self, var_mtype2unresolved); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables= (self,var36) on */ +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val = var36; /* _resolution_tables on */ +RET_LABEL37:(void)0; +} +} +var38 = NEW_standard__HashSet(&type_standard__HashSet__nit__MType); +{ +standard___standard__HashSet___standard__kernel__Object__init(var38); /* Direct call hash_collection#HashSet#init on */ +} +var_all_unresolved = var38; +{ +{ /* Inline separate_compiler#SeparateCompiler#live_unresolved_types (self) on */ +var41 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___live_unresolved_types].val; /* _live_unresolved_types on */ +if (unlikely(var41 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_unresolved_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 122); +show_backtrace(1); +} +var39 = var41; +RET_LABEL40:(void)0; +} +} +{ +var42 = ((val* (*)(val* self))(var39->class->vft[COLOR_standard__abstract_collection__MapRead__values]))(var39) /* values on */; +} +var_43 = var42; +{ +var44 = ((val* (*)(val* self))(var_43->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_43) /* iterator on */; +} +var_45 = var44; +for(;;) { +{ +var46 = ((short int (*)(val* self))(var_45->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_45) /* is_ok on */; +} +if (var46){ +{ +var47 = ((val* (*)(val* self))(var_45->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_45) /* item on */; +} +var_t = var47; +{ +standard___standard__SimpleCollection___add_all(var_all_unresolved, var_t); /* Direct call abstract_collection#SimpleCollection#add_all on */ +} +{ +((void (*)(val* self))(var_45->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_45) /* next on */; +} +} else { +goto BREAK_label48; +} +} +BREAK_label48: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_45) on */ +RET_LABEL49:(void)0; +} +} +var50 = NEW_standard__HashMap(&type_standard__HashMap__nit__MType__standard__Int); +{ +standard___standard__HashMap___standard__kernel__Object__init(var50); /* Direct call hash_collection#HashMap#init on */ +} +var_all_unresolved_types_colors = var50; +var_51 = var_all_unresolved; +{ +var52 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_51); +} +var_53 = var52; +for(;;) { +{ +var54 = ((short int (*)(val* self))(var_53->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_53) /* is_ok on */; +} +if (var54){ +{ +var55 = ((val* (*)(val* self))(var_53->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_53) /* item on */; +} +var_t56 = var55; +{ +{ /* Inline separate_compiler#SeparateCompiler#opentype_colors (self) on */ +var59 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val; /* _opentype_colors on */ +if (unlikely(var59 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opentype_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 126); +show_backtrace(1); +} +var57 = var59; +RET_LABEL58:(void)0; +} +} +{ +var60 = standard___standard__MapRead___has_key(var57, var_t56); +} +if (var60){ +{ +{ /* Inline separate_compiler#SeparateCompiler#opentype_colors (self) on */ +var63 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val; /* _opentype_colors on */ +if (unlikely(var63 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opentype_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 126); +show_backtrace(1); +} +var61 = var63; +RET_LABEL62:(void)0; +} +} +{ +var64 = ((val* (*)(val* self, val* p0))(var61->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var61, var_t56) /* [] on */; +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_all_unresolved_types_colors, var_t56, var64); /* Direct call hash_collection#HashMap#[]= on */ +} +} else { +var65 = 1; +{ +{ /* Inline kernel#Int#unary - (var65) on */ +var68 = -var65; +var66 = var68; +goto RET_LABEL67; +RET_LABEL67:(void)0; +} +} +{ +var69 = BOX_standard__Int(var66); /* autobox from Int to nullable Object */ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_all_unresolved_types_colors, var_t56, var69); /* Direct call hash_collection#HashMap#[]= on */ +} +} +{ +((void (*)(val* self))(var_53->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_53) /* next on */; +} +} else { +goto BREAK_label70; +} +} +BREAK_label70: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_53) on */ +RET_LABEL71:(void)0; +} +} +{ +nit___nit__SeparateCompiler___compile_color_consts(self, var_all_unresolved_types_colors); /* Direct call separate_compiler#SeparateCompiler#compile_color_consts on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#build_resolution_tables for (self: SeparateCompiler, Map[MClassType, Set[MType]]): Map[MClassType, Array[nullable MType]] */ +val* nit___nit__SeparateCompiler___build_resolution_tables(val* self, val* p0) { +val* var /* : Map[MClassType, Array[nullable MType]] */; +val* var_elements /* var elements: Map[MClassType, Set[MType]] */; +val* var1 /* : HashMap[MClassType, Array[nullable MType]] */; +val* var_tables /* var tables: HashMap[MClassType, Array[nullable MType]] */; +val* var_ /* var : Map[MClassType, Set[MType]] */; +val* var2 /* : MapIterator[nullable Object, nullable Object] */; +val* var_3 /* var : MapIterator[MClassType, Set[MType]] */; +short int var4 /* : Bool */; +val* var5 /* : nullable Object */; +val* var_mclasstype /* var mclasstype: MClassType */; +val* var6 /* : nullable Object */; +val* var_mtypes /* var mtypes: Set[MType] */; +val* var7 /* : Array[nullable MType] */; +val* var_table /* var table: Array[nullable MType] */; +val* var_8 /* var : Set[MType] */; +val* var9 /* : Iterator[nullable Object] */; +val* var_10 /* var : Iterator[MType] */; +short int var11 /* : Bool */; +val* var12 /* : nullable Object */; +val* var_mtype /* var mtype: MType */; +val* var13 /* : Map[MType, Int] */; +val* var15 /* : Map[MType, Int] */; +val* var16 /* : nullable Object */; +long var17 /* : Int */; +long var_color /* var color: Int */; +long var18 /* : Int */; +long var20 /* : Int */; +short int var21 /* : Bool */; +short int var23 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var24 /* : Bool */; +long var25 /* : Int */; +long var27 /* : Int */; +long var_i /* var i: Int */; +long var_28 /* var : Int */; +short int var29 /* : Bool */; +short int var31 /* : Bool */; +int cltype32; +int idtype33; +const char* var_class_name34; +short int var35 /* : Bool */; +val* var36 /* : null */; +long var37 /* : Int */; +long var38 /* : Int */; +var_elements = p0; +var1 = NEW_standard__HashMap(&type_standard__HashMap__nit__MClassType__standard__Array__nullable__nit__MType); +{ +standard___standard__HashMap___standard__kernel__Object__init(var1); /* Direct call hash_collection#HashMap#init on */ +} +var_tables = var1; +var_ = var_elements; +{ +var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_) /* iterator on */; +} +var_3 = var2; +for(;;) { +{ +var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_3) /* is_ok on */; +} +if (var4){ +{ +var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_3) /* key on */; +} +var_mclasstype = var5; +{ +var6 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_3) /* item on */; +} +var_mtypes = var6; +var7 = NEW_standard__Array(&type_standard__Array__nullable__nit__MType); +{ +standard___standard__Array___standard__kernel__Object__init(var7); /* Direct call array#Array#init on */ +} +var_table = var7; +var_8 = var_mtypes; +{ +var9 = ((val* (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_8) /* iterator on */; +} +var_10 = var9; +for(;;) { +{ +var11 = ((short int (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_10) /* is_ok on */; +} +if (var11){ +{ +var12 = ((val* (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_10) /* item on */; +} +var_mtype = var12; +{ +{ /* Inline separate_compiler#SeparateCompiler#opentype_colors (self) on */ +var15 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___opentype_colors].val; /* _opentype_colors on */ +if (unlikely(var15 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opentype_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 126); +show_backtrace(1); +} +var13 = var15; +RET_LABEL14:(void)0; +} +} +{ +var16 = ((val* (*)(val* self, val* p0))(var13->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var13, var_mtype) /* [] on */; +} +var17 = ((struct instance_standard__Int*)var16)->value; /* autounbox from nullable Object to Int */; +var_color = var17; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var20 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var18 = var20; +RET_LABEL19:(void)0; +} +} +{ +{ /* Inline kernel#Int#<= (var18,var_color) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var23 = 1; /* easy isa OTHER*/ +if (unlikely(!var23)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 409); +show_backtrace(1); +} +var24 = var18 <= var_color; +var21 = var24; +goto RET_LABEL22; +RET_LABEL22:(void)0; +} +} +if (var21){ +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var27 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var25 = var27; +RET_LABEL26:(void)0; +} +} +var_i = var25; +var_28 = var_color; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_28) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var31 = 1; /* easy isa OTHER*/ +if (unlikely(!var31)) { +var_class_name34 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name34); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); +show_backtrace(1); +} +var35 = var_i < var_28; +var29 = var35; +goto RET_LABEL30; +RET_LABEL30:(void)0; +} +} +if (var29){ +var36 = NULL; +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_i, var36); /* Direct call array#Array#[]= on */ +} +var37 = 1; +{ +var38 = standard___standard__Int___Discrete__successor(var_i, var37); +} +var_i = var38; +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +} else { +} +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_table, var_color, var_mtype); /* Direct call array#Array#[]= on */ +} +{ +((void (*)(val* self))(var_10->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_10) /* next on */; +} +} else { +goto BREAK_label39; +} +} +BREAK_label39: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_10) on */ +RET_LABEL40:(void)0; +} +} +{ +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_tables, var_mclasstype, var_table); /* Direct call hash_collection#HashMap#[]= on */ +} +{ +((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_3) /* next on */; +} +} else { +goto BREAK_label41; +} +} +BREAK_label41: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_3) on */ +RET_LABEL42:(void)0; +} +} +var = var_tables; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#compile_module_to_c for (self: SeparateCompiler, MModule) */ +void nit___nit__SeparateCompiler___compile_module_to_c(val* self, val* p0) { +val* var_mmodule /* var mmodule: MModule */; +val* var /* : MModule */; +val* var2 /* : MModule */; +val* var_old_module /* var old_module: MModule */; +val* var4 /* : Array[MClassDef] */; +val* var6 /* : Array[MClassDef] */; +val* var_ /* var : Array[MClassDef] */; +val* var7 /* : ArrayIterator[nullable Object] */; +val* var_8 /* var : ArrayIterator[MClassDef] */; +short int var9 /* : Bool */; +val* var10 /* : nullable Object */; +val* var_cd /* var cd: MClassDef */; +val* var11 /* : Array[MPropDef] */; +val* var13 /* : Array[MPropDef] */; +val* var_14 /* var : Array[MPropDef] */; +val* var15 /* : ArrayIterator[nullable Object] */; +val* var_16 /* var : ArrayIterator[MPropDef] */; +short int var17 /* : Bool */; +val* var18 /* : nullable Object */; +val* var_pd /* var pd: MPropDef */; +short int var19 /* : Bool */; +int cltype; +int idtype; +short int var20 /* : Bool */; +val* var21 /* : nullable RapidTypeAnalysis */; +val* var23 /* : nullable RapidTypeAnalysis */; +val* var_rta /* var rta: nullable RapidTypeAnalysis */; +short int var24 /* : Bool */; +short int var25 /* : Bool */; +val* var26 /* : ModelBuilder */; +val* var28 /* : ModelBuilder */; +val* var29 /* : ToolContext */; +val* var31 /* : ToolContext */; +val* var32 /* : OptionBool */; +val* var34 /* : OptionBool */; +val* var35 /* : nullable Object */; +val* var37 /* : nullable Object */; +short int var38 /* : Bool */; +short int var_39 /* var : Bool */; +val* var40 /* : null */; +short int var41 /* : Bool */; +short int var42 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var44 /* : Bool */; +short int var45 /* : Bool */; +short int var_46 /* var : Bool */; +val* var47 /* : HashSet[MMethodDef] */; +val* var49 /* : HashSet[MMethodDef] */; +short int var50 /* : Bool */; +short int var51 /* : Bool */; +val* var52 /* : SeparateRuntimeFunction */; +val* var_r /* var r: SeparateRuntimeFunction */; +val* var53 /* : SeparateRuntimeFunction */; +val* var_r2 /* var r2: SeparateRuntimeFunction */; +short int var54 /* : Bool */; +short int var56 /* : Bool */; +short int var57 /* : Bool */; +var_mmodule = p0; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +var_old_module = var; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_mmodule) on */ +self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_mmodule; /* _mainmodule on */ +RET_LABEL3:(void)0; +} +} +{ +{ /* Inline model#MModule#mclassdefs (var_mmodule) on */ +var6 = var_mmodule->attrs[COLOR_nit__model__MModule___mclassdefs].val; /* _mclassdefs on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 131); +show_backtrace(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +var_ = var4; +{ +var7 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_); +} +var_8 = var7; +for(;;) { +{ +var9 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_8); +} +if (var9){ +{ +var10 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_8); +} +var_cd = var10; +{ +{ /* Inline model#MClassDef#mpropdefs (var_cd) on */ +var13 = var_cd->attrs[COLOR_nit__model__MClassDef___mpropdefs].val; /* _mpropdefs on */ +if (unlikely(var13 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 623); +show_backtrace(1); +} +var11 = var13; +RET_LABEL12:(void)0; +} +} +var_14 = var11; +{ +var15 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_14); +} +var_16 = var15; +for(;;) { +{ +var17 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_16); +} +if (var17){ +{ +var18 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_16); +} +var_pd = var18; +/* isa MMethodDef */ +cltype = type_nit__MMethodDef.color; +idtype = type_nit__MMethodDef.id; +if(cltype >= var_pd->type->table_size) { +var19 = 0; +} else { +var19 = var_pd->type->type_table[cltype] == idtype; +} +var20 = !var19; +if (var20){ +goto BREAK_label; +} else { +} +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var23 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var21 = var23; +RET_LABEL22:(void)0; +} +} +var_rta = var21; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var28 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var28 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); +show_backtrace(1); +} +var26 = var28; +RET_LABEL27:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var26) on */ +var31 = var26->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +show_backtrace(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_skip_dead_methods (var29) on */ +var34 = var29->attrs[COLOR_nit__separate_compiler__ToolContext___opt_skip_dead_methods].val; /* _opt_skip_dead_methods on */ +if (unlikely(var34 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_skip_dead_methods"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 41); +show_backtrace(1); +} +var32 = var34; +RET_LABEL33:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var32) on */ +var37 = var32->attrs[COLOR_opts__Option___value].val; /* _value on */ +var35 = var37; +RET_LABEL36:(void)0; +} +} +var38 = ((struct instance_standard__Bool*)var35)->value; /* autounbox from nullable Object to Bool */; +var_39 = var38; +if (var38){ +var40 = NULL; +if (var_rta == NULL) { +var41 = 0; /* is null */ +} else { +var41 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_rta,var40) on */ +var_other = var40; +{ +var44 = ((short int (*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other) /* == on */; +} +var45 = !var44; +var42 = var45; +goto RET_LABEL43; +RET_LABEL43:(void)0; +} +var41 = var42; +} +var25 = var41; +} else { +var25 = var_39; +} +var_46 = var25; +if (var25){ +{ +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (var_rta) on */ +var49 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on */ +if (unlikely(var49 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72); +show_backtrace(1); +} +var47 = var49; +RET_LABEL48:(void)0; +} +} +{ +var50 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var47, var_pd); +} +var51 = !var50; +var24 = var51; +} else { +var24 = var_46; +} +if (var24){ +goto BREAK_label; +} else { +} +{ +var52 = nit__separate_compiler___MMethodDef___separate_runtime_function(var_pd); +} +var_r = var52; +{ +nit___nit__SeparateRuntimeFunction___nit__abstract_compiler__AbstractRuntimeFunction__compile_to_c(var_r, self); /* Direct call separate_compiler#SeparateRuntimeFunction#compile_to_c on */ +} +{ +var53 = nit__separate_compiler___MMethodDef___virtual_runtime_function(var_pd); +} +var_r2 = var53; +{ +{ /* Inline kernel#Object#!= (var_r2,var_r) on */ +var_other = var_r; +{ +var56 = ((short int (*)(val* self, val* p0))(var_r2->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_r2, var_other) /* == on */; +} +var57 = !var56; +var54 = var57; +goto RET_LABEL55; +RET_LABEL55:(void)0; +} +} +if (var54){ +{ +nit___nit__SeparateRuntimeFunction___nit__abstract_compiler__AbstractRuntimeFunction__compile_to_c(var_r2, self); /* Direct call separate_compiler#SeparateRuntimeFunction#compile_to_c on */ +} +} else { +} +BREAK_label: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_16); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label58; +} +} +BREAK_label58: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_16) on */ +RET_LABEL59:(void)0; +} +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_8); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label60; +} +} +BREAK_label60: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_8) on */ +RET_LABEL61:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_old_module) on */ +self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_old_module; /* _mainmodule on */ +RET_LABEL62:(void)0; +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_type_to_c for (self: SeparateCompiler, MType) */ +void nit___nit__SeparateCompiler___compile_type_to_c(val* self, val* p0) { +val* var_mtype /* var mtype: MType */; +short int var /* : Bool */; +short int var1 /* : Bool */; +short int var2 /* : Bool */; +short int var3 /* : Bool */; +int cltype; +int idtype; +short int var_ /* var : Bool */; +val* var4 /* : nullable RapidTypeAnalysis */; +val* var6 /* : nullable RapidTypeAnalysis */; +val* var7 /* : HashSet[MClassType] */; +val* var9 /* : HashSet[MClassType] */; +short int var10 /* : Bool */; +short int var_is_live /* var is_live: Bool */; +val* var11 /* : nullable RapidTypeAnalysis */; +val* var13 /* : nullable RapidTypeAnalysis */; +val* var14 /* : HashSet[MType] */; +val* var16 /* : HashSet[MType] */; +short int var17 /* : Bool */; +short int var_is_cast_live /* var is_cast_live: Bool */; +val* var18 /* : String */; +val* var_c_name /* var c_name: String */; +val* var19 /* : SeparateCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +static val* varonce; +val* var20 /* : String */; +char* var21 /* : NativeString */; +long var22 /* : Int */; +val* var23 /* : FlatString */; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +long var27 /* : Int */; +val* var28 /* : FlatString */; +val* var29 /* : Array[Object] */; +long var30 /* : Int */; +val* var31 /* : NativeArray[Object] */; +val* var32 /* : String */; +static val* varonce33; +val* var34 /* : String */; +char* var35 /* : NativeString */; +long var36 /* : Int */; +val* var37 /* : FlatString */; +val* var38 /* : Array[Object] */; +long var39 /* : Int */; +val* var40 /* : NativeArray[Object] */; +val* var41 /* : String */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +long var45 /* : Int */; +val* var46 /* : FlatString */; +static val* varonce47; +val* var48 /* : String */; +char* var49 /* : NativeString */; +long var50 /* : Int */; +val* var51 /* : FlatString */; +val* var52 /* : Array[Object] */; +long var53 /* : Int */; +val* var54 /* : NativeArray[Object] */; +val* var55 /* : String */; +static val* varonce56; +val* var57 /* : String */; +char* var58 /* : NativeString */; +long var59 /* : Int */; +val* var60 /* : FlatString */; +static val* varonce61; +val* var62 /* : String */; +char* var63 /* : NativeString */; +long var64 /* : Int */; +val* var65 /* : FlatString */; +val* var66 /* : Array[Object] */; +long var67 /* : Int */; +val* var68 /* : NativeArray[Object] */; +val* var69 /* : String */; +val* var70 /* : Map[MType, Int] */; +val* var72 /* : Map[MType, Int] */; +val* var73 /* : nullable Object */; +static val* varonce74; +val* var75 /* : String */; +char* var76 /* : NativeString */; +long var77 /* : Int */; +val* var78 /* : FlatString */; +val* var79 /* : Array[Object] */; +long var80 /* : Int */; +val* var81 /* : NativeArray[Object] */; +val* var82 /* : String */; +static val* varonce83; +val* var84 /* : String */; +char* var85 /* : NativeString */; +long var86 /* : Int */; +val* var87 /* : FlatString */; +static val* varonce88; +val* var89 /* : String */; +char* var90 /* : NativeString */; +long var91 /* : Int */; +val* var92 /* : FlatString */; +static val* varonce93; +val* var94 /* : String */; +char* var95 /* : NativeString */; +long var96 /* : Int */; +val* var97 /* : FlatString */; +val* var98 /* : Array[Object] */; +long var99 /* : Int */; +val* var100 /* : NativeArray[Object] */; +val* var101 /* : String */; +val* var102 /* : Map[MType, Int] */; +val* var104 /* : Map[MType, Int] */; +val* var105 /* : nullable Object */; +static val* varonce106; +val* var107 /* : String */; +char* var108 /* : NativeString */; +long var109 /* : Int */; +val* var110 /* : FlatString */; +val* var111 /* : Array[Object] */; +long var112 /* : Int */; +val* var113 /* : NativeArray[Object] */; +val* var114 /* : String */; +static val* varonce115; +val* var116 /* : String */; +char* var117 /* : NativeString */; +long var118 /* : Int */; +val* var119 /* : FlatString */; +short int var120 /* : Bool */; +int cltype121; +int idtype122; +static val* varonce123; +val* var124 /* : String */; +char* var125 /* : NativeString */; +long var126 /* : Int */; +val* var127 /* : FlatString */; +static val* varonce128; +val* var129 /* : String */; +char* var130 /* : NativeString */; +long var131 /* : Int */; +val* var132 /* : FlatString */; +val* var133 /* : MType */; +val* var_mclass_type /* var mclass_type: MType */; +short int var134 /* : Bool */; +int cltype135; +int idtype136; +val* var137 /* : Map[MClassType, Array[nullable MType]] */; +val* var139 /* : Map[MClassType, Array[nullable MType]] */; +val* var140 /* : nullable Object */; +short int var141 /* : Bool */; +static val* varonce142; +val* var143 /* : String */; +char* var144 /* : NativeString */; +long var145 /* : Int */; +val* var146 /* : FlatString */; +static val* varonce147; +val* var148 /* : String */; +char* var149 /* : NativeString */; +long var150 /* : Int */; +val* var151 /* : FlatString */; +val* var152 /* : Array[Object] */; +long var153 /* : Int */; +val* var154 /* : NativeArray[Object] */; +val* var155 /* : String */; +static val* varonce156; +val* var157 /* : String */; +char* var158 /* : NativeString */; +long var159 /* : Int */; +val* var160 /* : FlatString */; +static val* varonce161; +val* var162 /* : String */; +char* var163 /* : NativeString */; +long var164 /* : Int */; +val* var165 /* : FlatString */; +val* var166 /* : Array[Object] */; +long var167 /* : Int */; +val* var168 /* : NativeArray[Object] */; +val* var169 /* : String */; +static val* varonce170; +val* var171 /* : String */; +char* var172 /* : NativeString */; +long var173 /* : Int */; +val* var174 /* : FlatString */; +val* var175 /* : Map[MType, Array[nullable MType]] */; +val* var177 /* : Map[MType, Array[nullable MType]] */; +val* var178 /* : nullable Object */; +long var179 /* : Int */; +long var181 /* : Int */; +static val* varonce182; +val* var183 /* : String */; +char* var184 /* : NativeString */; +long var185 /* : Int */; +val* var186 /* : FlatString */; +val* var187 /* : Array[Object] */; +long var188 /* : Int */; +val* var189 /* : NativeArray[Object] */; +val* var190 /* : Object */; +val* var191 /* : String */; +static val* varonce192; +val* var193 /* : String */; +char* var194 /* : NativeString */; +long var195 /* : Int */; +val* var196 /* : FlatString */; +val* var197 /* : Map[MType, Array[nullable MType]] */; +val* var199 /* : Map[MType, Array[nullable MType]] */; +val* var200 /* : nullable Object */; +val* var_201 /* var : Array[nullable MType] */; +val* var202 /* : ArrayIterator[nullable Object] */; +val* var_203 /* var : ArrayIterator[nullable MType] */; +short int var204 /* : Bool */; +val* var205 /* : nullable Object */; +val* var_stype /* var stype: nullable MType */; +val* var206 /* : null */; +short int var207 /* : Bool */; +short int var208 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var210 /* : Bool */; +short int var212 /* : Bool */; +static val* varonce213; +val* var214 /* : String */; +char* var215 /* : NativeString */; +long var216 /* : Int */; +val* var217 /* : FlatString */; +val* var218 /* : Map[MType, Int] */; +val* var220 /* : Map[MType, Int] */; +val* var221 /* : nullable Object */; +static val* varonce222; +val* var223 /* : String */; +char* var224 /* : NativeString */; +long var225 /* : Int */; +val* var226 /* : FlatString */; +static val* varonce227; +val* var228 /* : String */; +char* var229 /* : NativeString */; +long var230 /* : Int */; +val* var231 /* : FlatString */; +val* var232 /* : Array[Object] */; +long var233 /* : Int */; +val* var234 /* : NativeArray[Object] */; +val* var235 /* : String */; +static val* varonce237; +val* var238 /* : String */; +char* var239 /* : NativeString */; +long var240 /* : Int */; +val* var241 /* : FlatString */; +static val* varonce242; +val* var243 /* : String */; +char* var244 /* : NativeString */; +long var245 /* : Int */; +val* var246 /* : FlatString */; +static val* varonce247; +val* var248 /* : String */; +char* var249 /* : NativeString */; +long var250 /* : Int */; +val* var251 /* : FlatString */; +var_mtype = p0; +{ +var = ((short int (*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__need_anchor]))(var_mtype) /* need_anchor on */; +} +var1 = !var; +if (unlikely(!var1)) { +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 572); +show_backtrace(1); +} +/* isa MClassType */ +cltype = type_nit__MClassType.color; +idtype = type_nit__MClassType.id; +if(cltype >= var_mtype->type->table_size) { +var3 = 0; +} else { +var3 = var_mtype->type->type_table[cltype] == idtype; +} +var_ = var3; +if (var3){ +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var6 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var4 = var6; +RET_LABEL5:(void)0; +} +} +if (var4 == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 573); +show_backtrace(1); +} else { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var4) on */ +if (unlikely(var4 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var9 = var4->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); +show_backtrace(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +var10 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var7, var_mtype); +} +var2 = var10; +} else { +var2 = var_; +} +var_is_live = var2; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var13 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var11 = var13; +RET_LABEL12:(void)0; +} +} +if (var11 == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 574); +show_backtrace(1); +} else { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (var11) on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65); +show_backtrace(1); +} +var16 = var11->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65); +show_backtrace(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +var17 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var14, var_mtype); +} +var_is_cast_live = var17; +{ +var18 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +} +var_c_name = var18; +var19 = NEW_nit__SeparateCompilerVisitor(&type_nit__SeparateCompilerVisitor); +{ +((void (*)(val* self, val* p0))(var19->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__compiler_61d]))(var19, self) /* compiler= on */; +} +{ +((void (*)(val* self))(var19->class->vft[COLOR_standard__kernel__Object__init]))(var19) /* init on */; +} +var_v = var19; +if (varonce) { +var20 = varonce; +} else { +var21 = "/* runtime type "; +var22 = 16; +var23 = standard___standard__NativeString___to_s_with_length(var21, var22); +var20 = var23; +varonce = var20; +} +if (varonce24) { +var25 = varonce24; +} else { +var26 = " */"; +var27 = 3; +var28 = standard___standard__NativeString___to_s_with_length(var26, var27); +var25 = var28; +varonce24 = var25; +} +var29 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var29 = array_instance Array[Object] */ +var30 = 3; +var31 = NEW_standard__NativeArray(var30, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var31)->values[0] = (val*) var20; +((struct instance_standard__NativeArray*)var31)->values[1] = (val*) var_mtype; +((struct instance_standard__NativeArray*)var31)->values[2] = (val*) var25; +{ +((void (*)(val* self, val* p0, long p1))(var29->class->vft[COLOR_standard__array__Array__with_native]))(var29, var31, var30) /* with_native on */; +} +} +{ +var32 = ((val* (*)(val* self))(var29->class->vft[COLOR_standard__string__Object__to_s]))(var29) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var32); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (varonce33) { +var34 = varonce33; +} else { +var35 = "type_"; +var36 = 5; +var37 = standard___standard__NativeString___to_s_with_length(var35, var36); +var34 = var37; +varonce33 = var34; +} +var38 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var38 = array_instance Array[Object] */ +var39 = 2; +var40 = NEW_standard__NativeArray(var39, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var40)->values[0] = (val*) var34; +((struct instance_standard__NativeArray*)var40)->values[1] = (val*) var_c_name; +{ +((void (*)(val* self, val* p0, long p1))(var38->class->vft[COLOR_standard__array__Array__with_native]))(var38, var40, var39) /* with_native on */; +} +} +{ +var41 = ((val* (*)(val* self))(var38->class->vft[COLOR_standard__string__Object__to_s]))(var38) /* to_s on */; +} +if (varonce42) { +var43 = varonce42; +} else { +var44 = "extern const struct type type_"; +var45 = 30; +var46 = standard___standard__NativeString___to_s_with_length(var44, var45); +var43 = var46; +varonce42 = var43; +} +if (varonce47) { +var48 = varonce47; +} else { +var49 = ";"; +var50 = 1; +var51 = standard___standard__NativeString___to_s_with_length(var49, var50); +var48 = var51; +varonce47 = var48; +} +var52 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var52 = array_instance Array[Object] */ +var53 = 3; +var54 = NEW_standard__NativeArray(var53, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var54)->values[0] = (val*) var43; +((struct instance_standard__NativeArray*)var54)->values[1] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var54)->values[2] = (val*) var48; +{ +((void (*)(val* self, val* p0, long p1))(var52->class->vft[COLOR_standard__array__Array__with_native]))(var52, var54, var53) /* with_native on */; +} +} +{ +var55 = ((val* (*)(val* self))(var52->class->vft[COLOR_standard__string__Object__to_s]))(var52) /* to_s on */; +} +{ +nit___nit__AbstractCompiler___provide_declaration(self, var41, var55); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (varonce56) { +var57 = varonce56; +} else { +var58 = "const struct type type_"; +var59 = 23; +var60 = standard___standard__NativeString___to_s_with_length(var58, var59); +var57 = var60; +varonce56 = var57; +} +if (varonce61) { +var62 = varonce61; +} else { +var63 = " = {"; +var64 = 4; +var65 = standard___standard__NativeString___to_s_with_length(var63, var64); +var62 = var65; +varonce61 = var62; +} +var66 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var66 = array_instance Array[Object] */ +var67 = 3; +var68 = NEW_standard__NativeArray(var67, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var68)->values[0] = (val*) var57; +((struct instance_standard__NativeArray*)var68)->values[1] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var68)->values[2] = (val*) var62; +{ +((void (*)(val* self, val* p0, long p1))(var66->class->vft[COLOR_standard__array__Array__with_native]))(var66, var68, var67) /* with_native on */; +} +} +{ +var69 = ((val* (*)(val* self))(var66->class->vft[COLOR_standard__string__Object__to_s]))(var66) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var69); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (var_is_cast_live){ +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids (self) on */ +var72 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var72 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 124); +show_backtrace(1); +} +var70 = var72; +RET_LABEL71:(void)0; +} +} +{ +var73 = ((val* (*)(val* self, val* p0))(var70->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var70, var_mtype) /* [] on */; +} +if (varonce74) { +var75 = varonce74; +} else { +var76 = ","; +var77 = 1; +var78 = standard___standard__NativeString___to_s_with_length(var76, var77); +var75 = var78; +varonce74 = var75; +} +var79 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var79 = array_instance Array[Object] */ +var80 = 2; +var81 = NEW_standard__NativeArray(var80, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var81)->values[0] = (val*) var73; +((struct instance_standard__NativeArray*)var81)->values[1] = (val*) var75; +{ +((void (*)(val* self, val* p0, long p1))(var79->class->vft[COLOR_standard__array__Array__with_native]))(var79, var81, var80) /* with_native on */; +} +} +{ +var82 = ((val* (*)(val* self))(var79->class->vft[COLOR_standard__string__Object__to_s]))(var79) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var82); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (varonce83) { +var84 = varonce83; +} else { +var85 = "-1, /*CAST DEAD*/"; +var86 = 17; +var87 = standard___standard__NativeString___to_s_with_length(var85, var86); +var84 = var87; +varonce83 = var84; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var84); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +if (varonce88) { +var89 = varonce88; +} else { +var90 = "\""; +var91 = 1; +var92 = standard___standard__NativeString___to_s_with_length(var90, var91); +var89 = var92; +varonce88 = var89; +} +if (varonce93) { +var94 = varonce93; +} else { +var95 = "\", /* class_name_string */"; +var96 = 26; +var97 = standard___standard__NativeString___to_s_with_length(var95, var96); +var94 = var97; +varonce93 = var94; +} +var98 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var98 = array_instance Array[Object] */ +var99 = 3; +var100 = NEW_standard__NativeArray(var99, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var100)->values[0] = (val*) var89; +((struct instance_standard__NativeArray*)var100)->values[1] = (val*) var_mtype; +((struct instance_standard__NativeArray*)var100)->values[2] = (val*) var94; +{ +((void (*)(val* self, val* p0, long p1))(var98->class->vft[COLOR_standard__array__Array__with_native]))(var98, var100, var99) /* with_native on */; +} +} +{ +var101 = ((val* (*)(val* self))(var98->class->vft[COLOR_standard__string__Object__to_s]))(var98) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var101); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (var_is_cast_live){ +{ +{ /* Inline separate_compiler#SeparateCompiler#type_colors (self) on */ +var104 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_colors].val; /* _type_colors on */ +if (unlikely(var104 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_colors"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 125); +show_backtrace(1); +} +var102 = var104; +RET_LABEL103:(void)0; +} +} +{ +var105 = ((val* (*)(val* self, val* p0))(var102->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var102, var_mtype) /* [] on */; +} +if (varonce106) { +var107 = varonce106; +} else { +var108 = ","; +var109 = 1; +var110 = standard___standard__NativeString___to_s_with_length(var108, var109); +var107 = var110; +varonce106 = var107; +} +var111 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var111 = array_instance Array[Object] */ +var112 = 2; +var113 = NEW_standard__NativeArray(var112, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var113)->values[0] = (val*) var105; +((struct instance_standard__NativeArray*)var113)->values[1] = (val*) var107; +{ +((void (*)(val* self, val* p0, long p1))(var111->class->vft[COLOR_standard__array__Array__with_native]))(var111, var113, var112) /* with_native on */; +} +} +{ +var114 = ((val* (*)(val* self))(var111->class->vft[COLOR_standard__string__Object__to_s]))(var111) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var114); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (varonce115) { +var116 = varonce115; +} else { +var117 = "-1, /*CAST DEAD*/"; +var118 = 17; +var119 = standard___standard__NativeString___to_s_with_length(var117, var118); +var116 = var119; +varonce115 = var116; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var116); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +/* isa MNullableType */ +cltype121 = type_nit__MNullableType.color; +idtype122 = type_nit__MNullableType.id; +if(cltype121 >= var_mtype->type->table_size) { +var120 = 0; +} else { +var120 = var_mtype->type->type_table[cltype121] == idtype122; +} +if (var120){ +if (varonce123) { +var124 = varonce123; +} else { +var125 = "1,"; +var126 = 2; +var127 = standard___standard__NativeString___to_s_with_length(var125, var126); +var124 = var127; +varonce123 = var124; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var124); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (varonce128) { +var129 = varonce128; +} else { +var130 = "0,"; +var131 = 2; +var132 = standard___standard__NativeString___to_s_with_length(var130, var131); +var129 = var132; +varonce128 = var129; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var129); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +if (var_is_live){ +{ +var133 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__as_notnullable]))(var_mtype) /* as_notnullable on */; +} +var_mclass_type = var133; +/* isa MClassType */ +cltype135 = type_nit__MClassType.color; +idtype136 = type_nit__MClassType.id; +if(cltype135 >= var_mclass_type->type->table_size) { +var134 = 0; +} else { +var134 = var_mclass_type->type->type_table[cltype135] == idtype136; +} +if (unlikely(!var134)) { +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 612); +show_backtrace(1); +} +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var139 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var139 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 855); +show_backtrace(1); +} +var137 = var139; +RET_LABEL138:(void)0; +} +} +{ +var140 = ((val* (*)(val* self, val* p0))(var137->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var137, var_mclass_type) /* [] on */; +} +{ +var141 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__is_empty(var140); +} +if (var141){ +if (varonce142) { +var143 = varonce142; +} else { +var144 = "NULL, /*NO RESOLUTIONS*/"; +var145 = 24; +var146 = standard___standard__NativeString___to_s_with_length(var144, var145); +var143 = var146; +varonce142 = var143; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var143); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +{ +nit___nit__SeparateCompiler___compile_type_resolution_table(self, var_mtype); /* Direct call separate_compiler#SeparateCompiler#compile_type_resolution_table on */ +} +if (varonce147) { +var148 = varonce147; +} else { +var149 = "resolution_table_"; +var150 = 17; +var151 = standard___standard__NativeString___to_s_with_length(var149, var150); +var148 = var151; +varonce147 = var148; +} +var152 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var152 = array_instance Array[Object] */ +var153 = 2; +var154 = NEW_standard__NativeArray(var153, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var154)->values[0] = (val*) var148; +((struct instance_standard__NativeArray*)var154)->values[1] = (val*) var_c_name; +{ +((void (*)(val* self, val* p0, long p1))(var152->class->vft[COLOR_standard__array__Array__with_native]))(var152, var154, var153) /* with_native on */; +} +} +{ +var155 = ((val* (*)(val* self))(var152->class->vft[COLOR_standard__string__Object__to_s]))(var152) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var155); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (varonce156) { +var157 = varonce156; +} else { +var158 = "&resolution_table_"; +var159 = 18; +var160 = standard___standard__NativeString___to_s_with_length(var158, var159); +var157 = var160; +varonce156 = var157; +} +if (varonce161) { +var162 = varonce161; +} else { +var163 = ","; +var164 = 1; +var165 = standard___standard__NativeString___to_s_with_length(var163, var164); +var162 = var165; +varonce161 = var162; +} +var166 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var166 = array_instance Array[Object] */ +var167 = 3; +var168 = NEW_standard__NativeArray(var167, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var168)->values[0] = (val*) var157; +((struct instance_standard__NativeArray*)var168)->values[1] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var168)->values[2] = (val*) var162; +{ +((void (*)(val* self, val* p0, long p1))(var166->class->vft[COLOR_standard__array__Array__with_native]))(var166, var168, var167) /* with_native on */; +} +} +{ +var169 = ((val* (*)(val* self))(var166->class->vft[COLOR_standard__string__Object__to_s]))(var166) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var169); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +} else { +if (varonce170) { +var171 = varonce170; +} else { +var172 = "NULL, /*DEAD*/"; +var173 = 14; +var174 = standard___standard__NativeString___to_s_with_length(var172, var173); +var171 = var174; +varonce170 = var171; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var171); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +if (var_is_live){ +{ +{ /* Inline separate_compiler#SeparateCompiler#type_tables (self) on */ +var177 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var177 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 854); +show_backtrace(1); +} +var175 = var177; +RET_LABEL176:(void)0; +} +} +{ +var178 = ((val* (*)(val* self, val* p0))(var175->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var175, var_mtype) /* [] on */; +} +{ +{ /* Inline array#AbstractArrayRead#length (var178) on */ +var181 = var178->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var179 = var181; +RET_LABEL180:(void)0; +} +} +if (varonce182) { +var183 = varonce182; +} else { +var184 = ","; +var185 = 1; +var186 = standard___standard__NativeString___to_s_with_length(var184, var185); +var183 = var186; +varonce182 = var183; +} +var187 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var187 = array_instance Array[Object] */ +var188 = 2; +var189 = NEW_standard__NativeArray(var188, &type_standard__NativeArray__standard__Object); +var190 = BOX_standard__Int(var179); /* autobox from Int to Object */ +((struct instance_standard__NativeArray*)var189)->values[0] = (val*) var190; +((struct instance_standard__NativeArray*)var189)->values[1] = (val*) var183; +{ +((void (*)(val* self, val* p0, long p1))(var187->class->vft[COLOR_standard__array__Array__with_native]))(var187, var189, var188) /* with_native on */; +} +} +{ +var191 = ((val* (*)(val* self))(var187->class->vft[COLOR_standard__string__Object__to_s]))(var187) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var191); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (varonce192) { +var193 = varonce192; +} else { +var194 = "{"; +var195 = 1; +var196 = standard___standard__NativeString___to_s_with_length(var194, var195); +var193 = var196; +varonce192 = var193; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var193); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#type_tables (self) on */ +var199 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var199 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 854); +show_backtrace(1); +} +var197 = var199; +RET_LABEL198:(void)0; +} +} +{ +var200 = ((val* (*)(val* self, val* p0))(var197->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var197, var_mtype) /* [] on */; +} +var_201 = var200; +{ +var202 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_201); +} +var_203 = var202; +for(;;) { +{ +var204 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_203); +} +if (var204){ +{ +var205 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_203); +} +var_stype = var205; +var206 = NULL; +if (var_stype == NULL) { +var207 = 1; /* is null */ +} else { +var207 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_stype,var206) on */ +var_other = var206; +{ +{ /* Inline kernel#Object#is_same_instance (var_stype,var_other) on */ +var212 = var_stype == var_other; +var210 = var212; +goto RET_LABEL211; +RET_LABEL211:(void)0; +} +} +var208 = var210; +goto RET_LABEL209; +RET_LABEL209:(void)0; +} +var207 = var208; +} +if (var207){ +if (varonce213) { +var214 = varonce213; +} else { +var215 = "-1, /* empty */"; +var216 = 15; +var217 = standard___standard__NativeString___to_s_with_length(var215, var216); +var214 = var217; +varonce213 = var214; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var214); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids (self) on */ +var220 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var220 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 124); +show_backtrace(1); +} +var218 = var220; +RET_LABEL219:(void)0; +} +} +{ +var221 = ((val* (*)(val* self, val* p0))(var218->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var218, var_stype) /* [] on */; +} +if (varonce222) { +var223 = varonce222; +} else { +var224 = ", /* "; +var225 = 5; +var226 = standard___standard__NativeString___to_s_with_length(var224, var225); +var223 = var226; +varonce222 = var223; +} +if (varonce227) { +var228 = varonce227; +} else { +var229 = " */"; +var230 = 3; +var231 = standard___standard__NativeString___to_s_with_length(var229, var230); +var228 = var231; +varonce227 = var228; +} +var232 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var232 = array_instance Array[Object] */ +var233 = 4; +var234 = NEW_standard__NativeArray(var233, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var234)->values[0] = (val*) var221; +((struct instance_standard__NativeArray*)var234)->values[1] = (val*) var223; +((struct instance_standard__NativeArray*)var234)->values[2] = (val*) var_stype; +((struct instance_standard__NativeArray*)var234)->values[3] = (val*) var228; +{ +((void (*)(val* self, val* p0, long p1))(var232->class->vft[COLOR_standard__array__Array__with_native]))(var232, var234, var233) /* with_native on */; +} +} +{ +var235 = ((val* (*)(val* self))(var232->class->vft[COLOR_standard__string__Object__to_s]))(var232) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var235); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_203); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_203) on */ +RET_LABEL236:(void)0; +} +} +if (varonce237) { +var238 = varonce237; +} else { +var239 = "},"; +var240 = 2; +var241 = standard___standard__NativeString___to_s_with_length(var239, var240); +var238 = var241; +varonce237 = var238; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var238); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (varonce242) { +var243 = varonce242; +} else { +var244 = "0, {}, /*DEAD TYPE*/"; +var245 = 20; +var246 = standard___standard__NativeString___to_s_with_length(var244, var245); +var243 = var246; +varonce242 = var243; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var243); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +if (varonce247) { +var248 = varonce247; +} else { +var249 = "};"; +var250 = 2; +var251 = standard___standard__NativeString___to_s_with_length(var249, var250); +var248 = var251; +varonce247 = var248; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var248); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_type_resolution_table for (self: SeparateCompiler, MType) */ +void nit___nit__SeparateCompiler___compile_type_resolution_table(val* self, val* p0) { +val* var_mtype /* var mtype: MType */; +val* var /* : MType */; +short int var1 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +val* var_mclass_type /* var mclass_type: MClassType */; +static val* varonce; +val* var2 /* : String */; +char* var3 /* : NativeString */; +long var4 /* : Int */; +val* var5 /* : FlatString */; +val* var6 /* : String */; +val* var7 /* : Array[Object] */; +long var8 /* : Int */; +val* var9 /* : NativeArray[Object] */; +val* var10 /* : String */; +static val* varonce11; +val* var12 /* : String */; +char* var13 /* : NativeString */; +long var14 /* : Int */; +val* var15 /* : FlatString */; +val* var16 /* : String */; +static val* varonce17; +val* var18 /* : String */; +char* var19 /* : NativeString */; +long var20 /* : Int */; +val* var21 /* : FlatString */; +val* var22 /* : Array[Object] */; +long var23 /* : Int */; +val* var24 /* : NativeArray[Object] */; +val* var25 /* : String */; +val* var26 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +static val* varonce27; +val* var28 /* : String */; +char* var29 /* : NativeString */; +long var30 /* : Int */; +val* var31 /* : FlatString */; +val* var32 /* : String */; +static val* varonce33; +val* var34 /* : String */; +char* var35 /* : NativeString */; +long var36 /* : Int */; +val* var37 /* : FlatString */; +val* var38 /* : Array[Object] */; +long var39 /* : Int */; +val* var40 /* : NativeArray[Object] */; +val* var41 /* : String */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +long var45 /* : Int */; +val* var46 /* : FlatString */; +static val* varonce47; +val* var48 /* : String */; +char* var49 /* : NativeString */; +long var50 /* : Int */; +val* var51 /* : FlatString */; +val* var52 /* : Map[MClassType, Array[nullable MType]] */; +val* var54 /* : Map[MClassType, Array[nullable MType]] */; +val* var55 /* : nullable Object */; +val* var_ /* var : Array[nullable MType] */; +val* var56 /* : ArrayIterator[nullable Object] */; +val* var_57 /* var : ArrayIterator[nullable MType] */; +short int var58 /* : Bool */; +val* var59 /* : nullable Object */; +val* var_t /* var t: nullable MType */; +val* var60 /* : null */; +short int var61 /* : Bool */; +short int var62 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var64 /* : Bool */; +short int var66 /* : Bool */; +static val* varonce67; +val* var68 /* : String */; +char* var69 /* : NativeString */; +long var70 /* : Int */; +val* var71 /* : FlatString */; +val* var72 /* : MModule */; +val* var74 /* : MModule */; +short int var75 /* : Bool */; +val* var76 /* : MType */; +val* var_tv /* var tv: MType */; +val* var77 /* : Map[MType, Int] */; +val* var79 /* : Map[MType, Int] */; +short int var80 /* : Bool */; +static val* varonce81; +val* var82 /* : String */; +char* var83 /* : NativeString */; +long var84 /* : Int */; +val* var85 /* : FlatString */; +val* var86 /* : String */; +val* var87 /* : Array[Object] */; +long var88 /* : Int */; +val* var89 /* : NativeArray[Object] */; +val* var90 /* : String */; +static val* varonce91; +val* var92 /* : String */; +char* var93 /* : NativeString */; +long var94 /* : Int */; +val* var95 /* : FlatString */; +val* var96 /* : String */; +static val* varonce97; +val* var98 /* : String */; +char* var99 /* : NativeString */; +long var100 /* : Int */; +val* var101 /* : FlatString */; +static val* varonce102; +val* var103 /* : String */; +char* var104 /* : NativeString */; +long var105 /* : Int */; +val* var106 /* : FlatString */; +static val* varonce107; +val* var108 /* : String */; +char* var109 /* : NativeString */; +long var110 /* : Int */; +val* var111 /* : FlatString */; +val* var112 /* : Array[Object] */; +long var113 /* : Int */; +val* var114 /* : NativeArray[Object] */; +val* var115 /* : String */; +static val* varonce116; +val* var117 /* : String */; +char* var118 /* : NativeString */; +long var119 /* : Int */; +val* var120 /* : FlatString */; +static val* varonce121; +val* var122 /* : String */; +char* var123 /* : NativeString */; +long var124 /* : Int */; +val* var125 /* : FlatString */; +static val* varonce126; +val* var127 /* : String */; +char* var128 /* : NativeString */; +long var129 /* : Int */; +val* var130 /* : FlatString */; +val* var131 /* : Array[Object] */; +long var132 /* : Int */; +val* var133 /* : NativeArray[Object] */; +val* var134 /* : String */; +static val* varonce136; +val* var137 /* : String */; +char* var138 /* : NativeString */; +long var139 /* : Int */; +val* var140 /* : FlatString */; +static val* varonce141; +val* var142 /* : String */; +char* var143 /* : NativeString */; +long var144 /* : Int */; +val* var145 /* : FlatString */; +var_mtype = p0; +{ +var = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__as_notnullable]))(var_mtype) /* as_notnullable on */; +} +/* isa MClassType */ +cltype = type_nit__MClassType.color; +idtype = type_nit__MClassType.id; +if(cltype >= var->type->table_size) { +var1 = 0; +} else { +var1 = var->type->type_table[cltype] == idtype; +} +if (unlikely(!var1)) { +var_class_name = var == NULL ? "null" : var->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 644); +show_backtrace(1); +} +var_mclass_type = var; +if (varonce) { +var2 = varonce; +} else { +var3 = "resolution_table_"; +var4 = 17; +var5 = standard___standard__NativeString___to_s_with_length(var3, var4); +var2 = var5; +varonce = var2; +} +{ +var6 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +} +var7 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var7 = array_instance Array[Object] */ +var8 = 2; +var9 = NEW_standard__NativeArray(var8, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var9)->values[0] = (val*) var2; +((struct instance_standard__NativeArray*)var9)->values[1] = (val*) var6; +{ +((void (*)(val* self, val* p0, long p1))(var7->class->vft[COLOR_standard__array__Array__with_native]))(var7, var9, var8) /* with_native on */; +} +} +{ +var10 = ((val* (*)(val* self))(var7->class->vft[COLOR_standard__string__Object__to_s]))(var7) /* to_s on */; +} +if (varonce11) { +var12 = varonce11; +} else { +var13 = "extern const struct types resolution_table_"; +var14 = 43; +var15 = standard___standard__NativeString___to_s_with_length(var13, var14); +var12 = var15; +varonce11 = var12; +} +{ +var16 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +} +if (varonce17) { +var18 = varonce17; +} else { +var19 = ";"; +var20 = 1; +var21 = standard___standard__NativeString___to_s_with_length(var19, var20); +var18 = var21; +varonce17 = var18; +} +var22 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var22 = array_instance Array[Object] */ +var23 = 3; +var24 = NEW_standard__NativeArray(var23, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var24)->values[0] = (val*) var12; +((struct instance_standard__NativeArray*)var24)->values[1] = (val*) var16; +((struct instance_standard__NativeArray*)var24)->values[2] = (val*) var18; +{ +((void (*)(val* self, val* p0, long p1))(var22->class->vft[COLOR_standard__array__Array__with_native]))(var22, var24, var23) /* with_native on */; +} +} +{ +var25 = ((val* (*)(val* self))(var22->class->vft[COLOR_standard__string__Object__to_s]))(var22) /* to_s on */; +} +{ +nit___nit__AbstractCompiler___provide_declaration(self, var10, var25); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +{ +var26 = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +} +var_v = var26; +if (varonce27) { +var28 = varonce27; +} else { +var29 = "const struct types resolution_table_"; +var30 = 36; +var31 = standard___standard__NativeString___to_s_with_length(var29, var30); +var28 = var31; +varonce27 = var28; +} +{ +var32 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +} +if (varonce33) { +var34 = varonce33; +} else { +var35 = " = {"; +var36 = 4; +var37 = standard___standard__NativeString___to_s_with_length(var35, var36); +var34 = var37; +varonce33 = var34; +} +var38 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var38 = array_instance Array[Object] */ +var39 = 3; +var40 = NEW_standard__NativeArray(var39, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var40)->values[0] = (val*) var28; +((struct instance_standard__NativeArray*)var40)->values[1] = (val*) var32; +((struct instance_standard__NativeArray*)var40)->values[2] = (val*) var34; +{ +((void (*)(val* self, val* p0, long p1))(var38->class->vft[COLOR_standard__array__Array__with_native]))(var38, var40, var39) /* with_native on */; +} +} +{ +var41 = ((val* (*)(val* self))(var38->class->vft[COLOR_standard__string__Object__to_s]))(var38) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var41); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (varonce42) { +var43 = varonce42; +} else { +var44 = "0, /* dummy */"; +var45 = 14; +var46 = standard___standard__NativeString___to_s_with_length(var44, var45); +var43 = var46; +varonce42 = var43; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var43); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (varonce47) { +var48 = varonce47; +} else { +var49 = "{"; +var50 = 1; +var51 = standard___standard__NativeString___to_s_with_length(var49, var50); +var48 = var51; +varonce47 = var48; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var48); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var54 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var54 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 855); +show_backtrace(1); +} +var52 = var54; +RET_LABEL53:(void)0; +} +} +{ +var55 = ((val* (*)(val* self, val* p0))(var52->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var52, var_mclass_type) /* [] on */; +} +var_ = var55; +{ +var56 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_); +} +var_57 = var56; +for(;;) { +{ +var58 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_57); +} +if (var58){ +{ +var59 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_57); +} +var_t = var59; +var60 = NULL; +if (var_t == NULL) { +var61 = 1; /* is null */ +} else { +var61 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t,var60) on */ +var_other = var60; +{ +{ /* Inline kernel#Object#is_same_instance (var_t,var_other) on */ +var66 = var_t == var_other; +var64 = var66; +goto RET_LABEL65; +RET_LABEL65:(void)0; +} +} +var62 = var64; +goto RET_LABEL63; +RET_LABEL63:(void)0; +} +var61 = var62; +} +if (var61){ +if (varonce67) { +var68 = varonce67; +} else { +var69 = "NULL, /* empty */"; +var70 = 17; +var71 = standard___standard__NativeString___to_s_with_length(var69, var70); +var68 = var71; +varonce67 = var68; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var68); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var74 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var74 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); +show_backtrace(1); +} +var72 = var74; +RET_LABEL73:(void)0; +} +} +var75 = 1; +{ +var76 = ((val* (*)(val* self, val* p0, val* p1, val* p2, short int p3))(var_t->class->vft[COLOR_nit__model__MType__resolve_for]))(var_t, var_mclass_type, var_mclass_type, var72, var75) /* resolve_for on */; +} +var_tv = var76; +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids (self) on */ +var79 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var79 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 124); +show_backtrace(1); +} +var77 = var79; +RET_LABEL78:(void)0; +} +} +{ +var80 = standard___standard__MapRead___has_key(var77, var_tv); +} +if (var80){ +if (varonce81) { +var82 = varonce81; +} else { +var83 = "type_"; +var84 = 5; +var85 = standard___standard__NativeString___to_s_with_length(var83, var84); +var82 = var85; +varonce81 = var82; +} +{ +var86 = ((val* (*)(val* self))(var_tv->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_tv) /* c_name on */; +} +var87 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var87 = array_instance Array[Object] */ +var88 = 2; +var89 = NEW_standard__NativeArray(var88, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var89)->values[0] = (val*) var82; +((struct instance_standard__NativeArray*)var89)->values[1] = (val*) var86; +{ +((void (*)(val* self, val* p0, long p1))(var87->class->vft[COLOR_standard__array__Array__with_native]))(var87, var89, var88) /* with_native on */; +} +} +{ +var90 = ((val* (*)(val* self))(var87->class->vft[COLOR_standard__string__Object__to_s]))(var87) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var90); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (varonce91) { +var92 = varonce91; +} else { +var93 = "&type_"; +var94 = 6; +var95 = standard___standard__NativeString___to_s_with_length(var93, var94); +var92 = var95; +varonce91 = var92; +} +{ +var96 = ((val* (*)(val* self))(var_tv->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_tv) /* c_name on */; +} +if (varonce97) { +var98 = varonce97; +} else { +var99 = ", /* "; +var100 = 5; +var101 = standard___standard__NativeString___to_s_with_length(var99, var100); +var98 = var101; +varonce97 = var98; +} +if (varonce102) { +var103 = varonce102; +} else { +var104 = ": "; +var105 = 2; +var106 = standard___standard__NativeString___to_s_with_length(var104, var105); +var103 = var106; +varonce102 = var103; +} +if (varonce107) { +var108 = varonce107; +} else { +var109 = " */"; +var110 = 3; +var111 = standard___standard__NativeString___to_s_with_length(var109, var110); +var108 = var111; +varonce107 = var108; +} +var112 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var112 = array_instance Array[Object] */ +var113 = 7; +var114 = NEW_standard__NativeArray(var113, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var114)->values[0] = (val*) var92; +((struct instance_standard__NativeArray*)var114)->values[1] = (val*) var96; +((struct instance_standard__NativeArray*)var114)->values[2] = (val*) var98; +((struct instance_standard__NativeArray*)var114)->values[3] = (val*) var_t; +((struct instance_standard__NativeArray*)var114)->values[4] = (val*) var103; +((struct instance_standard__NativeArray*)var114)->values[5] = (val*) var_tv; +((struct instance_standard__NativeArray*)var114)->values[6] = (val*) var108; +{ +((void (*)(val* self, val* p0, long p1))(var112->class->vft[COLOR_standard__array__Array__with_native]))(var112, var114, var113) /* with_native on */; +} +} +{ +var115 = ((val* (*)(val* self))(var112->class->vft[COLOR_standard__string__Object__to_s]))(var112) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var115); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (varonce116) { +var117 = varonce116; +} else { +var118 = "NULL, /* empty ("; +var119 = 16; +var120 = standard___standard__NativeString___to_s_with_length(var118, var119); +var117 = var120; +varonce116 = var117; +} +if (varonce121) { +var122 = varonce121; +} else { +var123 = ": "; +var124 = 2; +var125 = standard___standard__NativeString___to_s_with_length(var123, var124); +var122 = var125; +varonce121 = var122; +} +if (varonce126) { +var127 = varonce126; +} else { +var128 = " not a live type) */"; +var129 = 20; +var130 = standard___standard__NativeString___to_s_with_length(var128, var129); +var127 = var130; +varonce126 = var127; +} +var131 = NEW_standard__Array(&type_standard__Array__standard__Object); +{ /* var131 = array_instance Array[Object] */ +var132 = 5; +var133 = NEW_standard__NativeArray(var132, &type_standard__NativeArray__standard__Object); +((struct instance_standard__NativeArray*)var133)->values[0] = (val*) var117; +((struct instance_standard__NativeArray*)var133)->values[1] = (val*) var_t; +((struct instance_standard__NativeArray*)var133)->values[2] = (val*) var122; +((struct instance_standard__NativeArray*)var133)->values[3] = (val*) var_tv; +((struct instance_standard__NativeArray*)var133)->values[4] = (val*) var127; +{ +((void (*)(val* self, val* p0, long p1))(var131->class->vft[COLOR_standard__array__Array__with_native]))(var131, var133, var132) /* with_native on */; +} +} +{ +var134 = ((val* (*)(val* self))(var131->class->vft[COLOR_standard__string__Object__to_s]))(var131) /* to_s on */; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var134); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_57); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#Iterator#finish (var_57) on */ +RET_LABEL135:(void)0; +} +} +if (varonce136) { +var137 = varonce136; +} else { +var138 = "}"; +var139 = 1; +var140 = standard___standard__NativeString___to_s_with_length(var138, var139); +var137 = var140; +varonce136 = var137; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var137); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (varonce141) { +var142 = varonce141; +} else { +var143 = "};"; +var144 = 2; +var145 = standard___standard__NativeString___to_s_with_length(var143, var144); +var142 = var145; +varonce141 = var142; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var142); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +RET_LABEL:; +}