X-Git-Url: http://nitlanguage.org diff --git a/c_src/nitc__separate_compiler.sep.2.c b/c_src/nitc__separate_compiler.sep.2.c new file mode 100644 index 0000000..bb15bd7 --- /dev/null +++ b/c_src/nitc__separate_compiler.sep.2.c @@ -0,0 +1,9001 @@ +#include "nitc__separate_compiler.sep.0.h" +/* method separate_compiler#SeparateCompiler#compile_type_resolution_table for (self: SeparateCompiler, MType) */ +void nitc___nitc__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 */; +val* var2 /* : NativeArray[String] */; +static val* varonce; +static val* varonce3; +val* var4 /* : String */; +char* var5 /* : NativeString */; +val* var6 /* : String */; +val* var7 /* : String */; +val* var8 /* : String */; +val* var10 /* : NativeArray[String] */; +static val* varonce9; +static val* varonce11; +val* var12 /* : String */; +char* var13 /* : NativeString */; +val* var14 /* : String */; +static val* varonce15; +val* var16 /* : String */; +char* var17 /* : NativeString */; +val* var18 /* : String */; +val* var19 /* : String */; +val* var20 /* : String */; +val* var21 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var23 /* : NativeArray[String] */; +static val* varonce22; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : String */; +static val* varonce28; +val* var29 /* : String */; +char* var30 /* : NativeString */; +val* var31 /* : String */; +val* var32 /* : String */; +val* var33 /* : String */; +static val* varonce34; +val* var35 /* : String */; +char* var36 /* : NativeString */; +val* var37 /* : String */; +static val* varonce38; +val* var39 /* : String */; +char* var40 /* : NativeString */; +val* var41 /* : String */; +val* var42 /* : Map[MClassType, Array[nullable MType]] */; +val* var44 /* : Map[MClassType, Array[nullable MType]] */; +val* var45 /* : nullable Object */; +val* var_ /* var : Array[nullable MType] */; +val* var46 /* : IndexedIterator[nullable Object] */; +val* var_47 /* var : IndexedIterator[nullable MType] */; +short int var48 /* : Bool */; +val* var49 /* : nullable Object */; +val* var_t /* var t: nullable MType */; +short int var50 /* : Bool */; +short int var51 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var53 /* : Bool */; +short int var55 /* : Bool */; +static val* varonce56; +val* var57 /* : String */; +char* var58 /* : NativeString */; +val* var59 /* : String */; +val* var60 /* : MModule */; +val* var62 /* : MModule */; +val* var63 /* : MType */; +val* var_tv /* var tv: MType */; +val* var64 /* : Map[MType, Int] */; +val* var66 /* : Map[MType, Int] */; +short int var67 /* : Bool */; +val* var69 /* : NativeArray[String] */; +static val* varonce68; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : NativeString */; +val* var73 /* : String */; +val* var74 /* : String */; +val* var75 /* : String */; +val* var77 /* : NativeArray[String] */; +static val* varonce76; +static val* varonce78; +val* var79 /* : String */; +char* var80 /* : NativeString */; +val* var81 /* : String */; +static val* varonce82; +val* var83 /* : String */; +char* var84 /* : NativeString */; +val* var85 /* : String */; +static val* varonce86; +val* var87 /* : String */; +char* var88 /* : NativeString */; +val* var89 /* : String */; +static val* varonce90; +val* var91 /* : String */; +char* var92 /* : NativeString */; +val* var93 /* : String */; +val* var94 /* : String */; +val* var95 /* : String */; +val* var96 /* : String */; +val* var97 /* : String */; +val* var99 /* : NativeArray[String] */; +static val* varonce98; +static val* varonce100; +val* var101 /* : String */; +char* var102 /* : NativeString */; +val* var103 /* : String */; +static val* varonce104; +val* var105 /* : String */; +char* var106 /* : NativeString */; +val* var107 /* : String */; +static val* varonce108; +val* var109 /* : String */; +char* var110 /* : NativeString */; +val* var111 /* : String */; +val* var112 /* : String */; +val* var113 /* : String */; +val* var114 /* : String */; +static val* varonce115; +val* var116 /* : String */; +char* var117 /* : NativeString */; +val* var118 /* : String */; +static val* varonce119; +val* var120 /* : String */; +char* var121 /* : NativeString */; +val* var122 /* : String */; +var_mtype = p0; +{ +var = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__undecorate]))(var_mtype); /* undecorate on */ +} +/* isa MClassType */ +cltype = type_nitc__MClassType.color; +idtype = type_nitc__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_nitc__separate_compiler, 781); +fatal_exit(1); +} +var_mclass_type = var; +if (unlikely(varonce==NULL)) { +var2 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce3!=NULL)) { +var4 = varonce3; +} else { +var5 = "resolution_table_"; +var6 = core__flat___NativeString___to_s_full(var5, 17l, 17l); +var4 = var6; +varonce3 = var4; +} +((struct instance_core__NativeArray*)var2)->values[0]=var4; +} else { +var2 = varonce; +varonce = NULL; +} +{ +var7 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var2)->values[1]=var7; +{ +var8 = ((val*(*)(val* self))(var2->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var2); /* native_to_s on */ +} +varonce = var2; +if (unlikely(varonce9==NULL)) { +var10 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce11!=NULL)) { +var12 = varonce11; +} else { +var13 = "extern const struct types resolution_table_"; +var14 = core__flat___NativeString___to_s_full(var13, 43l, 43l); +var12 = var14; +varonce11 = var12; +} +((struct instance_core__NativeArray*)var10)->values[0]=var12; +if (likely(varonce15!=NULL)) { +var16 = varonce15; +} else { +var17 = ";"; +var18 = core__flat___NativeString___to_s_full(var17, 1l, 1l); +var16 = var18; +varonce15 = var16; +} +((struct instance_core__NativeArray*)var10)->values[2]=var16; +} else { +var10 = varonce9; +varonce9 = NULL; +} +{ +var19 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var10)->values[1]=var19; +{ +var20 = ((val*(*)(val* self))(var10->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var10); /* native_to_s on */ +} +varonce9 = var10; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var8, var20); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +{ +var21 = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var21; +if (unlikely(varonce22==NULL)) { +var23 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce24!=NULL)) { +var25 = varonce24; +} else { +var26 = "const struct types resolution_table_"; +var27 = core__flat___NativeString___to_s_full(var26, 36l, 36l); +var25 = var27; +varonce24 = var25; +} +((struct instance_core__NativeArray*)var23)->values[0]=var25; +if (likely(varonce28!=NULL)) { +var29 = varonce28; +} else { +var30 = " = {"; +var31 = core__flat___NativeString___to_s_full(var30, 4l, 4l); +var29 = var31; +varonce28 = var29; +} +((struct instance_core__NativeArray*)var23)->values[2]=var29; +} else { +var23 = varonce22; +varonce22 = NULL; +} +{ +var32 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var23)->values[1]=var32; +{ +var33 = ((val*(*)(val* self))(var23->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var23); /* native_to_s on */ +} +varonce22 = var23; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var33); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce34!=NULL)) { +var35 = varonce34; +} else { +var36 = "0, /* dummy */"; +var37 = core__flat___NativeString___to_s_full(var36, 14l, 14l); +var35 = var37; +varonce34 = var35; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var35); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce38!=NULL)) { +var39 = varonce38; +} else { +var40 = "{"; +var41 = core__flat___NativeString___to_s_full(var40, 1l, 1l); +var39 = var41; +varonce38 = var39; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var39); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var44 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1066); +fatal_exit(1); +} +var42 = var44; +RET_LABEL43:(void)0; +} +} +{ +var45 = ((val*(*)(val* self, val* p0))((((long)var42&3)?class_info[((long)var42&3)]:var42->class)->vft[COLOR_core__abstract_collection__MapRead___91d_93d]))(var42, var_mclass_type); /* [] on */ +} +var_ = var45; +{ +var46 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_); +} +var_47 = var46; +for(;;) { +{ +var48 = ((short int(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_47); /* is_ok on */ +} +if (var48){ +} else { +goto BREAK_label; +} +{ +var49 = ((val*(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_47); /* item on */ +} +var_t = var49; +if (var_t == NULL) { +var50 = 1; /* is null */ +} else { +var50 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_t,var_other) on */ +var55 = var_t == var_other; +var53 = var55; +goto RET_LABEL54; +RET_LABEL54:(void)0; +} +} +var51 = var53; +goto RET_LABEL52; +RET_LABEL52:(void)0; +} +var50 = var51; +} +if (var50){ +if (likely(varonce56!=NULL)) { +var57 = varonce56; +} else { +var58 = "NULL, /* empty */"; +var59 = core__flat___NativeString___to_s_full(var58, 17l, 17l); +var57 = var59; +varonce56 = var57; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var57); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var62 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var62 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 531); +fatal_exit(1); +} +var60 = var62; +RET_LABEL61:(void)0; +} +} +{ +var63 = ((val*(*)(val* self, val* p0, val* p1, val* p2, short int p3))(var_t->class->vft[COLOR_nitc__model__MType__resolve_for]))(var_t, var_mclass_type, var_mclass_type, var60, 1); /* resolve_for on */ +} +var_tv = var63; +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids (self) on */ +var66 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var66 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 149); +fatal_exit(1); +} +var64 = var66; +RET_LABEL65:(void)0; +} +} +{ +var67 = ((short int(*)(val* self, val* p0))((((long)var64&3)?class_info[((long)var64&3)]:var64->class)->vft[COLOR_core__abstract_collection__MapRead__has_key]))(var64, var_tv); /* has_key on */ +} +if (var67){ +if (unlikely(varonce68==NULL)) { +var69 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce70!=NULL)) { +var71 = varonce70; +} else { +var72 = "type_"; +var73 = core__flat___NativeString___to_s_full(var72, 5l, 5l); +var71 = var73; +varonce70 = var71; +} +((struct instance_core__NativeArray*)var69)->values[0]=var71; +} else { +var69 = varonce68; +varonce68 = NULL; +} +{ +var74 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_tv); /* c_name on */ +} +((struct instance_core__NativeArray*)var69)->values[1]=var74; +{ +var75 = ((val*(*)(val* self))(var69->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var69); /* native_to_s on */ +} +varonce68 = var69; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var75); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce76==NULL)) { +var77 = NEW_core__NativeArray(7l, &type_core__NativeArray__core__String); +if (likely(varonce78!=NULL)) { +var79 = varonce78; +} else { +var80 = "&type_"; +var81 = core__flat___NativeString___to_s_full(var80, 6l, 6l); +var79 = var81; +varonce78 = var79; +} +((struct instance_core__NativeArray*)var77)->values[0]=var79; +if (likely(varonce82!=NULL)) { +var83 = varonce82; +} else { +var84 = ", /* "; +var85 = core__flat___NativeString___to_s_full(var84, 5l, 5l); +var83 = var85; +varonce82 = var83; +} +((struct instance_core__NativeArray*)var77)->values[2]=var83; +if (likely(varonce86!=NULL)) { +var87 = varonce86; +} else { +var88 = ": "; +var89 = core__flat___NativeString___to_s_full(var88, 2l, 2l); +var87 = var89; +varonce86 = var87; +} +((struct instance_core__NativeArray*)var77)->values[4]=var87; +if (likely(varonce90!=NULL)) { +var91 = varonce90; +} else { +var92 = " */"; +var93 = core__flat___NativeString___to_s_full(var92, 3l, 3l); +var91 = var93; +varonce90 = var91; +} +((struct instance_core__NativeArray*)var77)->values[6]=var91; +} else { +var77 = varonce76; +varonce76 = NULL; +} +{ +var94 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_tv); /* c_name on */ +} +((struct instance_core__NativeArray*)var77)->values[1]=var94; +{ +var95 = ((val*(*)(val* self))(var_t->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_t); /* to_s on */ +} +((struct instance_core__NativeArray*)var77)->values[3]=var95; +{ +var96 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_tv); /* to_s on */ +} +((struct instance_core__NativeArray*)var77)->values[5]=var96; +{ +var97 = ((val*(*)(val* self))(var77->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var77); /* native_to_s on */ +} +varonce76 = var77; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var97); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (unlikely(varonce98==NULL)) { +var99 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce100!=NULL)) { +var101 = varonce100; +} else { +var102 = "NULL, /* empty ("; +var103 = core__flat___NativeString___to_s_full(var102, 16l, 16l); +var101 = var103; +varonce100 = var101; +} +((struct instance_core__NativeArray*)var99)->values[0]=var101; +if (likely(varonce104!=NULL)) { +var105 = varonce104; +} else { +var106 = ": "; +var107 = core__flat___NativeString___to_s_full(var106, 2l, 2l); +var105 = var107; +varonce104 = var105; +} +((struct instance_core__NativeArray*)var99)->values[2]=var105; +if (likely(varonce108!=NULL)) { +var109 = varonce108; +} else { +var110 = " not a live type) */"; +var111 = core__flat___NativeString___to_s_full(var110, 20l, 20l); +var109 = var111; +varonce108 = var109; +} +((struct instance_core__NativeArray*)var99)->values[4]=var109; +} else { +var99 = varonce98; +varonce98 = NULL; +} +{ +var112 = ((val*(*)(val* self))(var_t->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_t); /* to_s on */ +} +((struct instance_core__NativeArray*)var99)->values[1]=var112; +{ +var113 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_tv); /* to_s on */ +} +((struct instance_core__NativeArray*)var99)->values[3]=var113; +{ +var114 = ((val*(*)(val* self))(var99->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var99); /* native_to_s on */ +} +varonce98 = var99; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var114); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +} +{ +((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_47); /* next on */ +} +} +BREAK_label: (void)0; +{ +((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_47); /* finish on */ +} +if (likely(varonce115!=NULL)) { +var116 = varonce115; +} else { +var117 = "}"; +var118 = core__flat___NativeString___to_s_full(var117, 1l, 1l); +var116 = var118; +varonce115 = var116; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var116); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce119!=NULL)) { +var120 = varonce119; +} else { +var121 = "};"; +var122 = core__flat___NativeString___to_s_full(var121, 2l, 2l); +var120 = var122; +varonce119 = var120; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var120); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_class_to_c for (self: SeparateCompiler, MClass) */ +void nitc___nitc__SeparateCompiler___compile_class_to_c(val* self, val* p0) { +val* var_mclass /* var mclass: MClass */; +short int var /* : Bool */; +short int var2 /* : Bool */; +val* var3 /* : MClassDef */; +val* var5 /* : MClassDef */; +val* var6 /* : MClassType */; +val* var8 /* : MClassType */; +val* var_mtype /* var mtype: MClassType */; +val* var9 /* : String */; +val* var_c_name /* var c_name: String */; +val* var10 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var11 /* : nullable RapidTypeAnalysis */; +val* var13 /* : nullable RapidTypeAnalysis */; +val* var_rta /* var rta: nullable RapidTypeAnalysis */; +short int var14 /* : Bool */; +short int var15 /* : Bool */; +short int var16 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var18 /* : Bool */; +short int var19 /* : Bool */; +short int var_ /* var : Bool */; +val* var20 /* : HashSet[MClass] */; +val* var22 /* : HashSet[MClass] */; +short int var23 /* : Bool */; +short int var24 /* : Bool */; +short int var_is_dead /* var is_dead: Bool */; +short int var25 /* : Bool */; +short int var26 /* : Bool */; +short int var27 /* : Bool */; +short int var_28 /* var : Bool */; +short int var29 /* : Bool */; +short int var_30 /* var : Bool */; +val* var31 /* : MClassKind */; +val* var33 /* : MClassKind */; +val* var34 /* : Sys */; +val* var35 /* : MClassKind */; +short int var36 /* : Bool */; +val* var_other38 /* var other: nullable Object */; +short int var39 /* : Bool */; +short int var41 /* : Bool */; +short int var_42 /* var : Bool */; +val* var43 /* : MClassKind */; +val* var45 /* : MClassKind */; +val* var46 /* : Sys */; +val* var47 /* : MClassKind */; +short int var48 /* : Bool */; +short int var50 /* : Bool */; +short int var52 /* : Bool */; +short int var_need_corpse /* var need_corpse: Bool */; +val* var53 /* : NativeArray[String] */; +static val* varonce; +static val* varonce54; +val* var55 /* : String */; +char* var56 /* : NativeString */; +val* var57 /* : String */; +static val* varonce58; +val* var59 /* : String */; +char* var60 /* : NativeString */; +val* var61 /* : String */; +static val* varonce62; +val* var63 /* : String */; +char* var64 /* : NativeString */; +val* var65 /* : String */; +static val* varonce66; +val* var67 /* : String */; +char* var68 /* : NativeString */; +val* var69 /* : String */; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : NativeString */; +val* var73 /* : String */; +val* var74 /* : String */; +val* var75 /* : String */; +val* var76 /* : String */; +val* var77 /* : String */; +short int var78 /* : Bool */; +short int var79 /* : Bool */; +short int var_80 /* var : Bool */; +val* var82 /* : NativeArray[String] */; +static val* varonce81; +static val* varonce83; +val* var84 /* : String */; +char* var85 /* : NativeString */; +val* var86 /* : String */; +val* var87 /* : String */; +val* var89 /* : NativeArray[String] */; +static val* varonce88; +static val* varonce90; +val* var91 /* : String */; +char* var92 /* : NativeString */; +val* var93 /* : String */; +static val* varonce94; +val* var95 /* : String */; +char* var96 /* : NativeString */; +val* var97 /* : String */; +val* var98 /* : String */; +val* var100 /* : NativeArray[String] */; +static val* varonce99; +static val* varonce101; +val* var102 /* : String */; +char* var103 /* : NativeString */; +val* var104 /* : String */; +static val* varonce105; +val* var106 /* : String */; +char* var107 /* : NativeString */; +val* var108 /* : String */; +val* var109 /* : String */; +val* var111 /* : NativeArray[String] */; +static val* varonce110; +static val* varonce112; +val* var113 /* : String */; +char* var114 /* : NativeString */; +val* var115 /* : String */; +long var116 /* : Int */; +val* var117 /* : String */; +val* var118 /* : String */; +static val* varonce119; +val* var120 /* : String */; +char* var121 /* : NativeString */; +val* var122 /* : String */; +val* var123 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var125 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var126 /* : nullable Object */; +val* var_vft /* var vft: nullable Array[nullable MPropDef] */; +short int var127 /* : Bool */; +short int var128 /* : Bool */; +short int var130 /* : Bool */; +short int var131 /* : Bool */; +long var_i /* var i: Int */; +long var132 /* : Int */; +long var134 /* : Int */; +long var_135 /* var : Int */; +short int var136 /* : Bool */; +short int var138 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var139 /* : Bool */; +val* var140 /* : nullable Object */; +val* var_mpropdef /* var mpropdef: nullable MPropDef */; +short int var141 /* : Bool */; +short int var142 /* : Bool */; +short int var144 /* : Bool */; +short int var146 /* : Bool */; +static val* varonce147; +val* var148 /* : String */; +char* var149 /* : NativeString */; +val* var150 /* : String */; +short int var151 /* : Bool */; +int cltype152; +int idtype153; +short int var154 /* : Bool */; +short int var155 /* : Bool */; +short int var156 /* : Bool */; +short int var158 /* : Bool */; +short int var159 /* : Bool */; +short int var_160 /* var : Bool */; +val* var161 /* : HashSet[MMethodDef] */; +val* var163 /* : HashSet[MMethodDef] */; +short int var164 /* : Bool */; +short int var165 /* : Bool */; +val* var167 /* : NativeArray[String] */; +static val* varonce166; +static val* varonce168; +val* var169 /* : String */; +char* var170 /* : NativeString */; +val* var171 /* : String */; +static val* varonce172; +val* var173 /* : String */; +char* var174 /* : NativeString */; +val* var175 /* : String */; +static val* varonce176; +val* var177 /* : String */; +char* var178 /* : NativeString */; +val* var179 /* : String */; +static val* varonce180; +val* var181 /* : String */; +char* var182 /* : NativeString */; +val* var183 /* : String */; +val* var184 /* : MModule */; +val* var186 /* : MModule */; +val* var187 /* : String */; +val* var188 /* : String */; +val* var189 /* : String */; +val* var190 /* : String */; +short int var192 /* : Bool */; +short int var193 /* : Bool */; +short int var194 /* : Bool */; +short int var196 /* : Bool */; +short int var_197 /* var : Bool */; +val* var198 /* : nullable MSignature */; +val* var200 /* : nullable MSignature */; +short int var201 /* : Bool */; +short int var202 /* : Bool */; +short int var204 /* : Bool */; +short int var206 /* : Bool */; +short int var_207 /* var : Bool */; +val* var208 /* : MProperty */; +val* var210 /* : MProperty */; +short int var211 /* : Bool */; +short int var213 /* : Bool */; +val* var215 /* : NativeArray[String] */; +static val* varonce214; +static val* varonce216; +val* var217 /* : String */; +char* var218 /* : NativeString */; +val* var219 /* : String */; +static val* varonce220; +val* var221 /* : String */; +char* var222 /* : NativeString */; +val* var223 /* : String */; +static val* varonce224; +val* var225 /* : String */; +char* var226 /* : NativeString */; +val* var227 /* : String */; +static val* varonce228; +val* var229 /* : String */; +char* var230 /* : NativeString */; +val* var231 /* : String */; +val* var232 /* : MModule */; +val* var234 /* : MModule */; +val* var235 /* : String */; +val* var236 /* : String */; +val* var237 /* : String */; +val* var238 /* : String */; +val* var239 /* : SeparateRuntimeFunction */; +val* var_rf /* var rf: SeparateRuntimeFunction */; +val* var240 /* : String */; +val* var242 /* : NativeArray[String] */; +static val* varonce241; +static val* varonce243; +val* var244 /* : String */; +char* var245 /* : NativeString */; +val* var246 /* : String */; +static val* varonce247; +val* var248 /* : String */; +char* var249 /* : NativeString */; +val* var250 /* : String */; +static val* varonce251; +val* var252 /* : String */; +char* var253 /* : NativeString */; +val* var254 /* : String */; +static val* varonce255; +val* var256 /* : String */; +char* var257 /* : NativeString */; +val* var258 /* : String */; +static val* varonce259; +val* var260 /* : String */; +char* var261 /* : NativeString */; +val* var262 /* : String */; +val* var263 /* : String */; +val* var264 /* : MModule */; +val* var266 /* : MModule */; +val* var267 /* : String */; +val* var268 /* : String */; +val* var269 /* : String */; +val* var270 /* : String */; +long var271 /* : Int */; +static val* varonce272; +val* var273 /* : String */; +char* var274 /* : NativeString */; +val* var275 /* : String */; +static val* varonce276; +val* var277 /* : String */; +char* var278 /* : NativeString */; +val* var279 /* : String */; +short int var280 /* : Bool */; +short int var281 /* : Bool */; +short int var_282 /* var : Bool */; +val* var283 /* : MClass */; +val* var285 /* : MClass */; +val* var286 /* : String */; +val* var288 /* : String */; +static val* varonce289; +val* var290 /* : String */; +char* var291 /* : NativeString */; +val* var292 /* : String */; +short int var293 /* : Bool */; +short int var294 /* : Bool */; +short int var296 /* : Bool */; +val* var297 /* : CodeWriter */; +val* var299 /* : CodeWriter */; +val* var301 /* : NativeArray[String] */; +static val* varonce300; +static val* varonce302; +val* var303 /* : String */; +char* var304 /* : NativeString */; +val* var305 /* : String */; +static val* varonce306; +val* var307 /* : String */; +char* var308 /* : NativeString */; +val* var309 /* : String */; +val* var310 /* : String */; +val* var311 /* : CodeWriter */; +val* var313 /* : CodeWriter */; +static val* varonce314; +val* var315 /* : String */; +char* var316 /* : NativeString */; +val* var317 /* : String */; +val* var318 /* : CodeWriter */; +val* var320 /* : CodeWriter */; +static val* varonce321; +val* var322 /* : String */; +char* var323 /* : NativeString */; +val* var324 /* : String */; +val* var325 /* : CodeWriter */; +val* var327 /* : CodeWriter */; +val* var329 /* : NativeArray[String] */; +static val* varonce328; +static val* varonce330; +val* var331 /* : String */; +char* var332 /* : NativeString */; +val* var333 /* : String */; +val* var334 /* : String */; +val* var335 /* : String */; +val* var336 /* : CodeWriter */; +val* var338 /* : CodeWriter */; +static val* varonce339; +val* var340 /* : String */; +char* var341 /* : NativeString */; +val* var342 /* : String */; +short int var343 /* : Bool */; +short int var_344 /* var : Bool */; +val* var345 /* : MClass */; +val* var347 /* : MClass */; +val* var348 /* : String */; +val* var350 /* : String */; +static val* varonce351; +val* var352 /* : String */; +char* var353 /* : NativeString */; +val* var354 /* : String */; +short int var355 /* : Bool */; +short int var357 /* : Bool */; +short int var358 /* : Bool */; +val* var360 /* : NativeArray[String] */; +static val* varonce359; +static val* varonce361; +val* var362 /* : String */; +char* var363 /* : NativeString */; +val* var364 /* : String */; +val* var365 /* : String */; +val* var367 /* : NativeArray[String] */; +static val* varonce366; +static val* varonce368; +val* var369 /* : String */; +char* var370 /* : NativeString */; +val* var371 /* : String */; +static val* varonce372; +val* var373 /* : String */; +char* var374 /* : NativeString */; +val* var375 /* : String */; +static val* varonce376; +val* var377 /* : String */; +char* var378 /* : NativeString */; +val* var379 /* : String */; +val* var380 /* : String */; +val* var381 /* : String */; +val* var383 /* : NativeArray[String] */; +static val* varonce382; +static val* varonce384; +val* var385 /* : String */; +char* var386 /* : NativeString */; +val* var387 /* : String */; +static val* varonce388; +val* var389 /* : String */; +char* var390 /* : NativeString */; +val* var391 /* : String */; +val* var392 /* : String */; +val* var393 /* : String */; +val* var395 /* : NativeArray[String] */; +static val* varonce394; +static val* varonce396; +val* var397 /* : String */; +char* var398 /* : NativeString */; +val* var399 /* : String */; +static val* varonce400; +val* var401 /* : String */; +char* var402 /* : NativeString */; +val* var403 /* : String */; +static val* varonce404; +val* var405 /* : String */; +char* var406 /* : NativeString */; +val* var407 /* : String */; +val* var408 /* : String */; +val* var409 /* : String */; +val* var410 /* : String */; +val* var412 /* : NativeArray[String] */; +static val* varonce411; +static val* varonce413; +val* var414 /* : String */; +char* var415 /* : NativeString */; +val* var416 /* : String */; +static val* varonce417; +val* var418 /* : String */; +char* var419 /* : NativeString */; +val* var420 /* : String */; +static val* varonce421; +val* var422 /* : String */; +char* var423 /* : NativeString */; +val* var424 /* : String */; +val* var425 /* : String */; +val* var426 /* : AbstractCompiler */; +val* var428 /* : AbstractCompiler */; +val* var429 /* : Set[MType] */; +val* var431 /* : Set[MType] */; +val* var433 /* : NativeArray[String] */; +static val* varonce432; +static val* varonce434; +val* var435 /* : String */; +char* var436 /* : NativeString */; +val* var437 /* : String */; +val* var438 /* : String */; +val* var440 /* : NativeArray[String] */; +static val* varonce439; +static val* varonce441; +val* var442 /* : String */; +char* var443 /* : NativeString */; +val* var444 /* : String */; +static val* varonce445; +val* var446 /* : String */; +char* var447 /* : NativeString */; +val* var448 /* : String */; +val* var449 /* : String */; +val* var451 /* : NativeArray[String] */; +static val* varonce450; +static val* varonce452; +val* var453 /* : String */; +char* var454 /* : NativeString */; +val* var455 /* : String */; +val* var456 /* : String */; +val* var458 /* : NativeArray[String] */; +static val* varonce457; +static val* varonce459; +val* var460 /* : String */; +char* var461 /* : NativeString */; +val* var462 /* : String */; +static val* varonce463; +val* var464 /* : String */; +char* var465 /* : NativeString */; +val* var466 /* : String */; +val* var467 /* : String */; +static val* varonce468; +val* var469 /* : String */; +char* var470 /* : NativeString */; +val* var471 /* : String */; +static val* varonce472; +val* var473 /* : String */; +char* var474 /* : NativeString */; +val* var475 /* : String */; +static val* varonce476; +val* var477 /* : String */; +char* var478 /* : NativeString */; +val* var479 /* : String */; +val* var480 /* : MClass */; +val* var482 /* : MClass */; +val* var483 /* : String */; +val* var485 /* : String */; +static val* varonce486; +val* var487 /* : String */; +char* var488 /* : NativeString */; +val* var489 /* : String */; +short int var490 /* : Bool */; +short int var492 /* : Bool */; +short int var493 /* : Bool */; +val* var494 /* : AbstractCompilerVisitor */; +val* var496 /* : NativeArray[String] */; +static val* varonce495; +static val* varonce497; +val* var498 /* : String */; +char* var499 /* : NativeString */; +val* var500 /* : String */; +val* var501 /* : String */; +val* var503 /* : NativeArray[String] */; +static val* varonce502; +static val* varonce504; +val* var505 /* : String */; +char* var506 /* : NativeString */; +val* var507 /* : String */; +static val* varonce508; +val* var509 /* : String */; +char* var510 /* : NativeString */; +val* var511 /* : String */; +val* var512 /* : String */; +val* var513 /* : String */; +val* var515 /* : NativeArray[String] */; +static val* varonce514; +static val* varonce516; +val* var517 /* : String */; +char* var518 /* : NativeString */; +val* var519 /* : String */; +static val* varonce520; +val* var521 /* : String */; +char* var522 /* : NativeString */; +val* var523 /* : String */; +val* var524 /* : String */; +val* var525 /* : String */; +val* var527 /* : NativeArray[String] */; +static val* varonce526; +static val* varonce528; +val* var529 /* : String */; +char* var530 /* : NativeString */; +val* var531 /* : String */; +static val* varonce532; +val* var533 /* : String */; +char* var534 /* : NativeString */; +val* var535 /* : String */; +val* var536 /* : String */; +val* var537 /* : String */; +val* var539 /* : NativeArray[String] */; +static val* varonce538; +static val* varonce540; +val* var541 /* : String */; +char* var542 /* : NativeString */; +val* var543 /* : String */; +val* var544 /* : String */; +val* var545 /* : String */; +static val* varonce546; +val* var547 /* : String */; +char* var548 /* : NativeString */; +val* var549 /* : String */; +val* var550 /* : RuntimeVariable */; +val* var_res /* var res: RuntimeVariable */; +val* var553 /* : NativeArray[String] */; +static val* varonce552; +static val* varonce554; +val* var555 /* : String */; +char* var556 /* : NativeString */; +val* var557 /* : String */; +static val* varonce558; +val* var559 /* : String */; +char* var560 /* : NativeString */; +val* var561 /* : String */; +val* var562 /* : String */; +val* var563 /* : String */; +val* var564 /* : String */; +val* var566 /* : NativeArray[String] */; +static val* varonce565; +static val* varonce567; +val* var568 /* : String */; +char* var569 /* : NativeString */; +val* var570 /* : String */; +val* var571 /* : String */; +val* var572 /* : String */; +static val* varonce573; +val* var574 /* : String */; +char* var575 /* : NativeString */; +val* var576 /* : String */; +val* var578 /* : NativeArray[String] */; +static val* varonce577; +static val* varonce579; +val* var580 /* : String */; +char* var581 /* : NativeString */; +val* var582 /* : String */; +val* var583 /* : String */; +val* var585 /* : NativeArray[String] */; +static val* varonce584; +static val* varonce586; +val* var587 /* : String */; +char* var588 /* : NativeString */; +val* var589 /* : String */; +static val* varonce590; +val* var591 /* : String */; +char* var592 /* : NativeString */; +val* var593 /* : String */; +val* var594 /* : String */; +val* var595 /* : String */; +val* var597 /* : NativeArray[String] */; +static val* varonce596; +static val* varonce598; +val* var599 /* : String */; +char* var600 /* : NativeString */; +val* var601 /* : String */; +static val* varonce602; +val* var603 /* : String */; +char* var604 /* : NativeString */; +val* var605 /* : String */; +static val* varonce606; +val* var607 /* : String */; +char* var608 /* : NativeString */; +val* var609 /* : String */; +val* var610 /* : String */; +val* var611 /* : String */; +val* var612 /* : String */; +val* var614 /* : NativeArray[String] */; +static val* varonce613; +static val* varonce615; +val* var616 /* : String */; +char* var617 /* : NativeString */; +val* var618 /* : String */; +static val* varonce619; +val* var620 /* : String */; +char* var621 /* : NativeString */; +val* var622 /* : String */; +val* var623 /* : String */; +val* var624 /* : String */; +static val* varonce625; +val* var626 /* : String */; +char* var627 /* : NativeString */; +val* var628 /* : String */; +val* var629 /* : String */; +val* var631 /* : String */; +static val* varonce632; +val* var633 /* : String */; +char* var634 /* : NativeString */; +val* var635 /* : String */; +short int var636 /* : Bool */; +val* var637 /* : CodeWriter */; +val* var639 /* : CodeWriter */; +val* var641 /* : NativeArray[String] */; +static val* varonce640; +static val* varonce642; +val* var643 /* : String */; +char* var644 /* : NativeString */; +val* var645 /* : String */; +static val* varonce646; +val* var647 /* : String */; +char* var648 /* : NativeString */; +val* var649 /* : String */; +val* var650 /* : String */; +val* var651 /* : CodeWriter */; +val* var653 /* : CodeWriter */; +static val* varonce654; +val* var655 /* : String */; +char* var656 /* : NativeString */; +val* var657 /* : String */; +val* var658 /* : CodeWriter */; +val* var660 /* : CodeWriter */; +static val* varonce661; +val* var662 /* : String */; +char* var663 /* : NativeString */; +val* var664 /* : String */; +val* var665 /* : CodeWriter */; +val* var667 /* : CodeWriter */; +static val* varonce668; +val* var669 /* : String */; +char* var670 /* : NativeString */; +val* var671 /* : String */; +val* var672 /* : CodeWriter */; +val* var674 /* : CodeWriter */; +static val* varonce675; +val* var676 /* : String */; +char* var677 /* : NativeString */; +val* var678 /* : String */; +val* var679 /* : CodeWriter */; +val* var681 /* : CodeWriter */; +static val* varonce682; +val* var683 /* : String */; +char* var684 /* : NativeString */; +val* var685 /* : String */; +val* var687 /* : NativeArray[String] */; +static val* varonce686; +static val* varonce688; +val* var689 /* : String */; +char* var690 /* : NativeString */; +val* var691 /* : String */; +val* var692 /* : String */; +val* var694 /* : NativeArray[String] */; +static val* varonce693; +static val* varonce695; +val* var696 /* : String */; +char* var697 /* : NativeString */; +val* var698 /* : String */; +static val* varonce699; +val* var700 /* : String */; +char* var701 /* : NativeString */; +val* var702 /* : String */; +val* var703 /* : String */; +val* var704 /* : String */; +val* var706 /* : NativeArray[String] */; +static val* varonce705; +static val* varonce707; +val* var708 /* : String */; +char* var709 /* : NativeString */; +val* var710 /* : String */; +static val* varonce711; +val* var712 /* : String */; +char* var713 /* : NativeString */; +val* var714 /* : String */; +val* var715 /* : String */; +val* var716 /* : String */; +val* var718 /* : NativeArray[String] */; +static val* varonce717; +static val* varonce719; +val* var720 /* : String */; +char* var721 /* : NativeString */; +val* var722 /* : String */; +static val* varonce723; +val* var724 /* : String */; +char* var725 /* : NativeString */; +val* var726 /* : String */; +val* var727 /* : String */; +val* var728 /* : String */; +static val* varonce729; +val* var730 /* : String */; +char* var731 /* : NativeString */; +val* var732 /* : String */; +val* var733 /* : String */; +val* var_res734 /* var res: String */; +val* var736 /* : NativeArray[String] */; +static val* varonce735; +static val* varonce737; +val* var738 /* : String */; +char* var739 /* : NativeString */; +val* var740 /* : String */; +static val* varonce741; +val* var742 /* : String */; +char* var743 /* : NativeString */; +val* var744 /* : String */; +static val* varonce745; +val* var746 /* : String */; +char* var747 /* : NativeString */; +val* var748 /* : String */; +val* var749 /* : String */; +val* var750 /* : Array[MType] */; +val* var751 /* : nullable Object */; +val* var_mtype_elt /* var mtype_elt: MType */; +val* var753 /* : NativeArray[String] */; +static val* varonce752; +static val* varonce754; +val* var755 /* : String */; +char* var756 /* : NativeString */; +val* var757 /* : String */; +static val* varonce758; +val* var759 /* : String */; +char* var760 /* : NativeString */; +val* var761 /* : String */; +static val* varonce762; +val* var763 /* : String */; +char* var764 /* : NativeString */; +val* var765 /* : String */; +val* var766 /* : String */; +val* var767 /* : String */; +val* var769 /* : NativeArray[String] */; +static val* varonce768; +static val* varonce770; +val* var771 /* : String */; +char* var772 /* : NativeString */; +val* var773 /* : String */; +val* var774 /* : String */; +static val* varonce775; +val* var776 /* : String */; +char* var777 /* : NativeString */; +val* var778 /* : String */; +val* var780 /* : NativeArray[String] */; +static val* varonce779; +static val* varonce781; +val* var782 /* : String */; +char* var783 /* : NativeString */; +val* var784 /* : String */; +val* var785 /* : String */; +val* var787 /* : NativeArray[String] */; +static val* varonce786; +static val* varonce788; +val* var789 /* : String */; +char* var790 /* : NativeString */; +val* var791 /* : String */; +static val* varonce792; +val* var793 /* : String */; +char* var794 /* : NativeString */; +val* var795 /* : String */; +val* var796 /* : String */; +val* var798 /* : NativeArray[String] */; +static val* varonce797; +static val* varonce799; +val* var800 /* : String */; +char* var801 /* : NativeString */; +val* var802 /* : String */; +val* var803 /* : String */; +val* var805 /* : NativeArray[String] */; +static val* varonce804; +static val* varonce806; +val* var807 /* : String */; +char* var808 /* : NativeString */; +val* var809 /* : String */; +static val* varonce810; +val* var811 /* : String */; +char* var812 /* : NativeString */; +val* var813 /* : String */; +val* var814 /* : String */; +static val* varonce815; +val* var816 /* : String */; +char* var817 /* : NativeString */; +val* var818 /* : String */; +short int var819 /* : Bool */; +val* var820 /* : MClass */; +val* var822 /* : MClass */; +val* var823 /* : MClassKind */; +val* var825 /* : MClassKind */; +val* var826 /* : Sys */; +val* var827 /* : MClassKind */; +short int var828 /* : Bool */; +short int var830 /* : Bool */; +short int var832 /* : Bool */; +short int var_833 /* var : Bool */; +val* var834 /* : MClass */; +val* var836 /* : MClass */; +val* var837 /* : String */; +val* var839 /* : String */; +static val* varonce840; +val* var841 /* : String */; +char* var842 /* : NativeString */; +val* var843 /* : String */; +short int var844 /* : Bool */; +short int var846 /* : Bool */; +short int var847 /* : Bool */; +val* var848 /* : MModule */; +val* var850 /* : MModule */; +val* var851 /* : MClassType */; +val* var_pointer_type /* var pointer_type: MClassType */; +val* var853 /* : NativeArray[String] */; +static val* varonce852; +static val* varonce854; +val* var855 /* : String */; +char* var856 /* : NativeString */; +val* var857 /* : String */; +val* var858 /* : String */; +val* var860 /* : NativeArray[String] */; +static val* varonce859; +static val* varonce861; +val* var862 /* : String */; +char* var863 /* : NativeString */; +val* var864 /* : String */; +static val* varonce865; +val* var866 /* : String */; +char* var867 /* : NativeString */; +val* var868 /* : String */; +val* var869 /* : String */; +val* var870 /* : String */; +val* var872 /* : NativeArray[String] */; +static val* varonce871; +static val* varonce873; +val* var874 /* : String */; +char* var875 /* : NativeString */; +val* var876 /* : String */; +static val* varonce877; +val* var878 /* : String */; +char* var879 /* : NativeString */; +val* var880 /* : String */; +val* var881 /* : String */; +val* var882 /* : String */; +val* var884 /* : NativeArray[String] */; +static val* varonce883; +static val* varonce885; +val* var886 /* : String */; +char* var887 /* : NativeString */; +val* var888 /* : String */; +static val* varonce889; +val* var890 /* : String */; +char* var891 /* : NativeString */; +val* var892 /* : String */; +val* var893 /* : String */; +val* var894 /* : String */; +val* var896 /* : NativeArray[String] */; +static val* varonce895; +static val* varonce897; +val* var898 /* : String */; +char* var899 /* : NativeString */; +val* var900 /* : String */; +val* var901 /* : String */; +val* var902 /* : String */; +static val* varonce903; +val* var904 /* : String */; +char* var905 /* : NativeString */; +val* var906 /* : String */; +val* var907 /* : RuntimeVariable */; +val* var_res908 /* var res: RuntimeVariable */; +val* var911 /* : NativeArray[String] */; +static val* varonce910; +static val* varonce912; +val* var913 /* : String */; +char* var914 /* : NativeString */; +val* var915 /* : String */; +static val* varonce916; +val* var917 /* : String */; +char* var918 /* : NativeString */; +val* var919 /* : String */; +val* var920 /* : String */; +val* var921 /* : String */; +val* var922 /* : String */; +val* var924 /* : NativeArray[String] */; +static val* varonce923; +static val* varonce925; +val* var926 /* : String */; +char* var927 /* : NativeString */; +val* var928 /* : String */; +val* var929 /* : String */; +val* var930 /* : String */; +static val* varonce931; +val* var932 /* : String */; +char* var933 /* : NativeString */; +val* var934 /* : String */; +val* var936 /* : NativeArray[String] */; +static val* varonce935; +static val* varonce937; +val* var938 /* : String */; +char* var939 /* : NativeString */; +val* var940 /* : String */; +val* var941 /* : String */; +val* var943 /* : NativeArray[String] */; +static val* varonce942; +static val* varonce944; +val* var945 /* : String */; +char* var946 /* : NativeString */; +val* var947 /* : String */; +static val* varonce948; +val* var949 /* : String */; +char* var950 /* : NativeString */; +val* var951 /* : String */; +val* var952 /* : String */; +val* var953 /* : String */; +val* var955 /* : NativeArray[String] */; +static val* varonce954; +static val* varonce956; +val* var957 /* : String */; +char* var958 /* : NativeString */; +val* var959 /* : String */; +static val* varonce960; +val* var961 /* : String */; +char* var962 /* : NativeString */; +val* var963 /* : String */; +static val* varonce964; +val* var965 /* : String */; +char* var966 /* : NativeString */; +val* var967 /* : String */; +val* var968 /* : String */; +val* var969 /* : String */; +val* var970 /* : String */; +val* var972 /* : NativeArray[String] */; +static val* varonce971; +static val* varonce973; +val* var974 /* : String */; +char* var975 /* : NativeString */; +val* var976 /* : String */; +static val* varonce977; +val* var978 /* : String */; +char* var979 /* : NativeString */; +val* var980 /* : String */; +val* var981 /* : String */; +val* var982 /* : String */; +static val* varonce983; +val* var984 /* : String */; +char* var985 /* : NativeString */; +val* var986 /* : String */; +val* var988 /* : NativeArray[String] */; +static val* varonce987; +static val* varonce989; +val* var990 /* : String */; +char* var991 /* : NativeString */; +val* var992 /* : String */; +val* var993 /* : String */; +val* var995 /* : NativeArray[String] */; +static val* varonce994; +static val* varonce996; +val* var997 /* : String */; +char* var998 /* : NativeString */; +val* var999 /* : String */; +static val* varonce1000; +val* var1001 /* : String */; +char* var1002 /* : NativeString */; +val* var1003 /* : String */; +val* var1004 /* : String */; +val* var1005 /* : String */; +val* var1007 /* : NativeArray[String] */; +static val* varonce1006; +static val* varonce1008; +val* var1009 /* : String */; +char* var1010 /* : NativeString */; +val* var1011 /* : String */; +static val* varonce1012; +val* var1013 /* : String */; +char* var1014 /* : NativeString */; +val* var1015 /* : String */; +val* var1016 /* : String */; +val* var1017 /* : String */; +val* var1019 /* : NativeArray[String] */; +static val* varonce1018; +static val* varonce1020; +val* var1021 /* : String */; +char* var1022 /* : NativeString */; +val* var1023 /* : String */; +static val* varonce1024; +val* var1025 /* : String */; +char* var1026 /* : NativeString */; +val* var1027 /* : String */; +val* var1028 /* : String */; +val* var1029 /* : String */; +val* var1031 /* : NativeArray[String] */; +static val* varonce1030; +static val* varonce1032; +val* var1033 /* : String */; +char* var1034 /* : NativeString */; +val* var1035 /* : String */; +val* var1036 /* : String */; +val* var1037 /* : String */; +static val* varonce1038; +val* var1039 /* : String */; +char* var1040 /* : NativeString */; +val* var1041 /* : String */; +val* var1042 /* : RuntimeVariable */; +val* var_res1043 /* var res: RuntimeVariable */; +val* var1045 /* : Map[MClass, Array[nullable MProperty]] */; +val* var1047 /* : Map[MClass, Array[nullable MProperty]] */; +val* var1048 /* : nullable Object */; +val* var_attrs /* var attrs: nullable Array[nullable MProperty] */; +short int var1049 /* : Bool */; +short int var1050 /* : Bool */; +val* var1052 /* : NativeArray[String] */; +static val* varonce1051; +static val* varonce1053; +val* var1054 /* : String */; +char* var1055 /* : NativeString */; +val* var1056 /* : String */; +val* var1057 /* : String */; +val* var1058 /* : String */; +val* var1060 /* : NativeArray[String] */; +static val* varonce1059; +static val* varonce1061; +val* var1062 /* : String */; +char* var1063 /* : NativeString */; +val* var1064 /* : String */; +static val* varonce1065; +val* var1066 /* : String */; +char* var1067 /* : NativeString */; +val* var1068 /* : String */; +val* var1069 /* : String */; +long var1070 /* : Int */; +long var1072 /* : Int */; +val* var1073 /* : String */; +val* var1074 /* : String */; +val* var1076 /* : NativeArray[String] */; +static val* varonce1075; +static val* varonce1077; +val* var1078 /* : String */; +char* var1079 /* : NativeString */; +val* var1080 /* : String */; +val* var1081 /* : String */; +val* var1082 /* : String */; +static val* varonce1083; +val* var1084 /* : String */; +char* var1085 /* : NativeString */; +val* var1086 /* : String */; +val* var1088 /* : NativeArray[String] */; +static val* varonce1087; +static val* varonce1089; +val* var1090 /* : String */; +char* var1091 /* : NativeString */; +val* var1092 /* : String */; +val* var1093 /* : String */; +val* var1095 /* : NativeArray[String] */; +static val* varonce1094; +static val* varonce1096; +val* var1097 /* : String */; +char* var1098 /* : NativeString */; +val* var1099 /* : String */; +static val* varonce1100; +val* var1101 /* : String */; +char* var1102 /* : NativeString */; +val* var1103 /* : String */; +val* var1104 /* : String */; +val* var1105 /* : String */; +short int var1106 /* : Bool */; +short int var1107 /* : Bool */; +short int var1109 /* : Bool */; +short int var1110 /* : Bool */; +val* var1112 /* : NativeArray[String] */; +static val* varonce1111; +static val* varonce1113; +val* var1114 /* : String */; +char* var1115 /* : NativeString */; +val* var1116 /* : String */; +static val* varonce1117; +val* var1118 /* : String */; +char* var1119 /* : NativeString */; +val* var1120 /* : String */; +val* var1121 /* : String */; +val* var1122 /* : String */; +static val* varonce1123; +val* var1124 /* : String */; +char* var1125 /* : NativeString */; +val* var1126 /* : String */; +var_mclass = p0; +{ +{ /* Inline model_base#MEntity#is_broken (var_mclass) on */ +var2 = var_mclass->attrs[COLOR_nitc__model_base__MEntity___is_broken].s; /* _is_broken on */ +var = var2; +RET_LABEL1:(void)0; +} +} +if (var){ +goto RET_LABEL; +} else { +} +{ +{ /* Inline model#MClass#intro (var_mclass) on */ +var5 = var_mclass->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 483); +fatal_exit(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var3) on */ +var8 = var3->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +fatal_exit(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +var_mtype = var6; +{ +var9 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass); +} +var_c_name = var9; +{ +var10 = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var10; +{ +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ +var13 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var11 = var13; +RET_LABEL12:(void)0; +} +} +var_rta = var11; +if (var_rta == NULL) { +var15 = 0; /* is null */ +} else { +var15 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_rta,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var18 = ((short int(*)(val* self, val* p0))(var_rta->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_rta, var_other); /* == on */ +} +var19 = !var18; +var16 = var19; +goto RET_LABEL17; +RET_LABEL17:(void)0; +} +var15 = var16; +} +var_ = var15; +if (var15){ +{ +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (var_rta) on */ +var22 = var_rta->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on */ +if (unlikely(var22 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69); +fatal_exit(1); +} +var20 = var22; +RET_LABEL21:(void)0; +} +} +{ +var23 = core___core__HashSet___core__abstract_collection__Collection__has(var20, var_mclass); +} +var24 = !var23; +var14 = var24; +} else { +var14 = var_; +} +var_is_dead = var14; +var_28 = var_is_dead; +if (var_is_dead){ +{ +var29 = nitc__abstract_compiler___MClassType___MType__is_c_primitive(var_mtype); +} +var27 = var29; +} else { +var27 = var_28; +} +var_30 = var27; +if (var27){ +var26 = var_30; +} else { +{ +{ /* Inline model#MClass#kind (var_mclass) on */ +var33 = var_mclass->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on */ +if (unlikely(var33 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 459); +fatal_exit(1); +} +var31 = var33; +RET_LABEL32:(void)0; +} +} +var34 = glob_sys; +{ +var35 = nitc__model___core__Sys___extern_kind(var34); +} +{ +{ /* Inline kernel#Object#== (var31,var35) on */ +var_other38 = var35; +{ +{ /* Inline kernel#Object#is_same_instance (var31,var_other38) on */ +var41 = var31 == var_other38; +var39 = var41; +goto RET_LABEL40; +RET_LABEL40:(void)0; +} +} +var36 = var39; +goto RET_LABEL37; +RET_LABEL37:(void)0; +} +} +var26 = var36; +} +var_42 = var26; +if (var26){ +var25 = var_42; +} else { +{ +{ /* Inline model#MClass#kind (var_mclass) on */ +var45 = var_mclass->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on */ +if (unlikely(var45 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 459); +fatal_exit(1); +} +var43 = var45; +RET_LABEL44:(void)0; +} +} +var46 = glob_sys; +{ +var47 = nitc__model___core__Sys___enum_kind(var46); +} +{ +{ /* Inline kernel#Object#== (var43,var47) on */ +var_other38 = var47; +{ +{ /* Inline kernel#Object#is_same_instance (var43,var_other38) on */ +var52 = var43 == var_other38; +var50 = var52; +goto RET_LABEL51; +RET_LABEL51:(void)0; +} +} +var48 = var50; +goto RET_LABEL49; +RET_LABEL49:(void)0; +} +} +var25 = var48; +} +var_need_corpse = var25; +if (unlikely(varonce==NULL)) { +var53 = NEW_core__NativeArray(9l, &type_core__NativeArray__core__String); +if (likely(varonce54!=NULL)) { +var55 = varonce54; +} else { +var56 = "/* runtime class "; +var57 = core__flat___NativeString___to_s_full(var56, 17l, 17l); +var55 = var57; +varonce54 = var55; +} +((struct instance_core__NativeArray*)var53)->values[0]=var55; +if (likely(varonce58!=NULL)) { +var59 = varonce58; +} else { +var60 = ": "; +var61 = core__flat___NativeString___to_s_full(var60, 2l, 2l); +var59 = var61; +varonce58 = var59; +} +((struct instance_core__NativeArray*)var53)->values[2]=var59; +if (likely(varonce62!=NULL)) { +var63 = varonce62; +} else { +var64 = " (dead="; +var65 = core__flat___NativeString___to_s_full(var64, 7l, 7l); +var63 = var65; +varonce62 = var63; +} +((struct instance_core__NativeArray*)var53)->values[4]=var63; +if (likely(varonce66!=NULL)) { +var67 = varonce66; +} else { +var68 = "; need_corpse="; +var69 = core__flat___NativeString___to_s_full(var68, 14l, 14l); +var67 = var69; +varonce66 = var67; +} +((struct instance_core__NativeArray*)var53)->values[6]=var67; +if (likely(varonce70!=NULL)) { +var71 = varonce70; +} else { +var72 = ")*/"; +var73 = core__flat___NativeString___to_s_full(var72, 3l, 3l); +var71 = var73; +varonce70 = var71; +} +((struct instance_core__NativeArray*)var53)->values[8]=var71; +} else { +var53 = varonce; +varonce = NULL; +} +((struct instance_core__NativeArray*)var53)->values[1]=var_c_name; +{ +var74 = nitc___nitc__MClass___nitc__model_base__MEntity__full_name(var_mclass); +} +((struct instance_core__NativeArray*)var53)->values[3]=var74; +var75 = core__abstract_text___Bool___Object__to_s(var_is_dead); +((struct instance_core__NativeArray*)var53)->values[5]=var75; +var76 = core__abstract_text___Bool___Object__to_s(var_need_corpse); +((struct instance_core__NativeArray*)var53)->values[7]=var76; +{ +var77 = ((val*(*)(val* self))(var53->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var53); /* native_to_s on */ +} +varonce = var53; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var77); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +var79 = !var_is_dead; +var_80 = var79; +if (var79){ +var78 = var_80; +} else { +var78 = var_need_corpse; +} +if (var78){ +if (unlikely(varonce81==NULL)) { +var82 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce83!=NULL)) { +var84 = varonce83; +} else { +var85 = "class_"; +var86 = core__flat___NativeString___to_s_full(var85, 6l, 6l); +var84 = var86; +varonce83 = var84; +} +((struct instance_core__NativeArray*)var82)->values[0]=var84; +} else { +var82 = varonce81; +varonce81 = NULL; +} +((struct instance_core__NativeArray*)var82)->values[1]=var_c_name; +{ +var87 = ((val*(*)(val* self))(var82->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var82); /* native_to_s on */ +} +varonce81 = var82; +if (unlikely(varonce88==NULL)) { +var89 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce90!=NULL)) { +var91 = varonce90; +} else { +var92 = "extern const struct class class_"; +var93 = core__flat___NativeString___to_s_full(var92, 32l, 32l); +var91 = var93; +varonce90 = var91; +} +((struct instance_core__NativeArray*)var89)->values[0]=var91; +if (likely(varonce94!=NULL)) { +var95 = varonce94; +} else { +var96 = ";"; +var97 = core__flat___NativeString___to_s_full(var96, 1l, 1l); +var95 = var97; +varonce94 = var95; +} +((struct instance_core__NativeArray*)var89)->values[2]=var95; +} else { +var89 = varonce88; +varonce88 = NULL; +} +((struct instance_core__NativeArray*)var89)->values[1]=var_c_name; +{ +var98 = ((val*(*)(val* self))(var89->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var89); /* native_to_s on */ +} +varonce88 = var89; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var87, var98); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce99==NULL)) { +var100 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce101!=NULL)) { +var102 = varonce101; +} else { +var103 = "const struct class class_"; +var104 = core__flat___NativeString___to_s_full(var103, 25l, 25l); +var102 = var104; +varonce101 = var102; +} +((struct instance_core__NativeArray*)var100)->values[0]=var102; +if (likely(varonce105!=NULL)) { +var106 = varonce105; +} else { +var107 = " = {"; +var108 = core__flat___NativeString___to_s_full(var107, 4l, 4l); +var106 = var108; +varonce105 = var106; +} +((struct instance_core__NativeArray*)var100)->values[2]=var106; +} else { +var100 = varonce99; +varonce99 = NULL; +} +((struct instance_core__NativeArray*)var100)->values[1]=var_c_name; +{ +var109 = ((val*(*)(val* self))(var100->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var100); /* native_to_s on */ +} +varonce99 = var100; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var109); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce110==NULL)) { +var111 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce112!=NULL)) { +var113 = varonce112; +} else { +var114 = ", /* box_kind */"; +var115 = core__flat___NativeString___to_s_full(var114, 16l, 16l); +var113 = var115; +varonce112 = var113; +} +((struct instance_core__NativeArray*)var111)->values[1]=var113; +} else { +var111 = varonce110; +varonce110 = NULL; +} +{ +var116 = nitc___nitc__SeparateCompiler___box_kind_of(self, var_mclass); +} +var117 = core__flat___Int___core__abstract_text__Object__to_s(var116); +((struct instance_core__NativeArray*)var111)->values[0]=var117; +{ +var118 = ((val*(*)(val* self))(var111->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var111); /* native_to_s on */ +} +varonce110 = var111; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var118); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce119!=NULL)) { +var120 = varonce119; +} else { +var121 = "{"; +var122 = core__flat___NativeString___to_s_full(var121, 1l, 1l); +var120 = var122; +varonce119 = var120; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var120); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ +var125 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var125 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1067); +fatal_exit(1); +} +var123 = var125; +RET_LABEL124:(void)0; +} +} +{ +var126 = ((val*(*)(val* self, val* p0))((((long)var123&3)?class_info[((long)var123&3)]:var123->class)->vft[COLOR_core__abstract_collection__MapRead__get_or_null]))(var123, var_mclass); /* get_or_null on */ +} +var_vft = var126; +if (var_vft == NULL) { +var127 = 0; /* is null */ +} else { +var127 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_vft,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var130 = ((short int(*)(val* self, val* p0))(var_vft->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_vft, var_other); /* == on */ +} +var131 = !var130; +var128 = var131; +goto RET_LABEL129; +RET_LABEL129:(void)0; +} +var127 = var128; +} +if (var127){ +var_i = 0l; +{ +{ /* Inline array#AbstractArrayRead#length (var_vft) on */ +var134 = var_vft->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var132 = var134; +RET_LABEL133:(void)0; +} +} +var_135 = var132; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_135) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var138 = 1; /* easy isa OTHER*/ +if (unlikely(!var138)) { +var_class_name = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var139 = var_i < var_135; +var136 = var139; +goto RET_LABEL137; +RET_LABEL137:(void)0; +} +} +if (var136){ +} else { +goto BREAK_label; +} +{ +var140 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_vft, var_i); +} +var_mpropdef = var140; +if (var_mpropdef == NULL) { +var141 = 1; /* is null */ +} else { +var141 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_mpropdef,((val*)NULL)) on */ +var_other38 = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_mpropdef,var_other38) on */ +var146 = var_mpropdef == var_other38; +var144 = var146; +goto RET_LABEL145; +RET_LABEL145:(void)0; +} +} +var142 = var144; +goto RET_LABEL143; +RET_LABEL143:(void)0; +} +var141 = var142; +} +if (var141){ +if (likely(varonce147!=NULL)) { +var148 = varonce147; +} else { +var149 = "NULL, /* empty */"; +var150 = core__flat___NativeString___to_s_full(var149, 17l, 17l); +var148 = var150; +varonce147 = var148; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var148); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +/* isa MMethodDef */ +cltype152 = type_nitc__MMethodDef.color; +idtype153 = type_nitc__MMethodDef.id; +if(cltype152 >= var_mpropdef->type->table_size) { +var151 = 0; +} else { +var151 = var_mpropdef->type->type_table[cltype152] == idtype153; +} +if (unlikely(!var151)) { +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 844); +fatal_exit(1); +} +if (var_rta == NULL) { +var155 = 0; /* is null */ +} else { +var155 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_rta,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var158 = ((short int(*)(val* self, val* p0))(var_rta->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_rta, var_other); /* == on */ +} +var159 = !var158; +var156 = var159; +goto RET_LABEL157; +RET_LABEL157:(void)0; +} +var155 = var156; +} +var_160 = var155; +if (var155){ +{ +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (var_rta) on */ +var163 = var_rta->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on */ +if (unlikely(var163 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79); +fatal_exit(1); +} +var161 = var163; +RET_LABEL162:(void)0; +} +} +{ +var164 = core___core__HashSet___core__abstract_collection__Collection__has(var161, var_mpropdef); +} +var165 = !var164; +var154 = var165; +} else { +var154 = var_160; +} +if (var154){ +if (unlikely(varonce166==NULL)) { +var167 = NEW_core__NativeArray(7l, &type_core__NativeArray__core__String); +if (likely(varonce168!=NULL)) { +var169 = varonce168; +} else { +var170 = "NULL, /* DEAD "; +var171 = core__flat___NativeString___to_s_full(var170, 14l, 14l); +var169 = var171; +varonce168 = var169; +} +((struct instance_core__NativeArray*)var167)->values[0]=var169; +if (likely(varonce172!=NULL)) { +var173 = varonce172; +} else { +var174 = ":"; +var175 = core__flat___NativeString___to_s_full(var174, 1l, 1l); +var173 = var175; +varonce172 = var173; +} +((struct instance_core__NativeArray*)var167)->values[2]=var173; +if (likely(varonce176!=NULL)) { +var177 = varonce176; +} else { +var178 = ":"; +var179 = core__flat___NativeString___to_s_full(var178, 1l, 1l); +var177 = var179; +varonce176 = var177; +} +((struct instance_core__NativeArray*)var167)->values[4]=var177; +if (likely(varonce180!=NULL)) { +var181 = varonce180; +} else { +var182 = " */"; +var183 = core__flat___NativeString___to_s_full(var182, 3l, 3l); +var181 = var183; +varonce180 = var181; +} +((struct instance_core__NativeArray*)var167)->values[6]=var181; +} else { +var167 = varonce166; +varonce166 = NULL; +} +{ +{ /* Inline model#MClass#intro_mmodule (var_mclass) on */ +var186 = var_mclass->attrs[COLOR_nitc__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ +if (unlikely(var186 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 380); +fatal_exit(1); +} +var184 = var186; +RET_LABEL185:(void)0; +} +} +{ +var187 = ((val*(*)(val* self))(var184->class->vft[COLOR_core__abstract_text__Object__to_s]))(var184); /* to_s on */ +} +((struct instance_core__NativeArray*)var167)->values[1]=var187; +{ +var188 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var167)->values[3]=var188; +{ +var189 = ((val*(*)(val* self))(var_mpropdef->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mpropdef); /* to_s on */ +} +((struct instance_core__NativeArray*)var167)->values[5]=var189; +{ +var190 = ((val*(*)(val* self))(var167->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var167); /* native_to_s on */ +} +varonce166 = var167; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var190); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +goto BREAK_label191; +} else { +{ +{ /* Inline model_base#MEntity#is_broken (var_mpropdef) on */ +var196 = var_mpropdef->attrs[COLOR_nitc__model_base__MEntity___is_broken].s; /* _is_broken on */ +var194 = var196; +RET_LABEL195:(void)0; +} +} +var_197 = var194; +if (var194){ +var193 = var_197; +} else { +{ +{ /* Inline model#MMethodDef#msignature (var_mpropdef) on */ +var200 = var_mpropdef->attrs[COLOR_nitc__model__MMethodDef___msignature].val; /* _msignature on */ +var198 = var200; +RET_LABEL199:(void)0; +} +} +if (var198 == NULL) { +var201 = 1; /* is null */ +} else { +var201 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var198,((val*)NULL)) on */ +var_other38 = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var198,var_other38) on */ +var206 = var198 == var_other38; +var204 = var206; +goto RET_LABEL205; +RET_LABEL205:(void)0; +} +} +var202 = var204; +goto RET_LABEL203; +RET_LABEL203:(void)0; +} +var201 = var202; +} +var193 = var201; +} +var_207 = var193; +if (var193){ +var192 = var_207; +} else { +{ +{ /* Inline model#MPropDef#mproperty (var_mpropdef) on */ +var210 = var_mpropdef->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on */ +if (unlikely(var210 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2230); +fatal_exit(1); +} +var208 = var210; +RET_LABEL209:(void)0; +} +} +{ +{ /* Inline model_base#MEntity#is_broken (var208) on */ +var213 = var208->attrs[COLOR_nitc__model_base__MEntity___is_broken].s; /* _is_broken on */ +var211 = var213; +RET_LABEL212:(void)0; +} +} +var192 = var211; +} +if (var192){ +if (unlikely(varonce214==NULL)) { +var215 = NEW_core__NativeArray(7l, &type_core__NativeArray__core__String); +if (likely(varonce216!=NULL)) { +var217 = varonce216; +} else { +var218 = "NULL, /* DEAD (BROKEN) "; +var219 = core__flat___NativeString___to_s_full(var218, 23l, 23l); +var217 = var219; +varonce216 = var217; +} +((struct instance_core__NativeArray*)var215)->values[0]=var217; +if (likely(varonce220!=NULL)) { +var221 = varonce220; +} else { +var222 = ":"; +var223 = core__flat___NativeString___to_s_full(var222, 1l, 1l); +var221 = var223; +varonce220 = var221; +} +((struct instance_core__NativeArray*)var215)->values[2]=var221; +if (likely(varonce224!=NULL)) { +var225 = varonce224; +} else { +var226 = ":"; +var227 = core__flat___NativeString___to_s_full(var226, 1l, 1l); +var225 = var227; +varonce224 = var225; +} +((struct instance_core__NativeArray*)var215)->values[4]=var225; +if (likely(varonce228!=NULL)) { +var229 = varonce228; +} else { +var230 = " */"; +var231 = core__flat___NativeString___to_s_full(var230, 3l, 3l); +var229 = var231; +varonce228 = var229; +} +((struct instance_core__NativeArray*)var215)->values[6]=var229; +} else { +var215 = varonce214; +varonce214 = NULL; +} +{ +{ /* Inline model#MClass#intro_mmodule (var_mclass) on */ +var234 = var_mclass->attrs[COLOR_nitc__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ +if (unlikely(var234 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 380); +fatal_exit(1); +} +var232 = var234; +RET_LABEL233:(void)0; +} +} +{ +var235 = ((val*(*)(val* self))(var232->class->vft[COLOR_core__abstract_text__Object__to_s]))(var232); /* to_s on */ +} +((struct instance_core__NativeArray*)var215)->values[1]=var235; +{ +var236 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var215)->values[3]=var236; +{ +var237 = ((val*(*)(val* self))(var_mpropdef->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mpropdef); /* to_s on */ +} +((struct instance_core__NativeArray*)var215)->values[5]=var237; +{ +var238 = ((val*(*)(val* self))(var215->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var215); /* native_to_s on */ +} +varonce214 = var215; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var238); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +goto BREAK_label191; +} else { +} +} +{ +var239 = nitc__separate_compiler___MMethodDef___virtual_runtime_function(var_mpropdef); +} +var_rf = var239; +{ +var240 = nitc___nitc__AbstractRuntimeFunction___c_name(var_rf); +} +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var240); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce241==NULL)) { +var242 = NEW_core__NativeArray(9l, &type_core__NativeArray__core__String); +if (likely(varonce243!=NULL)) { +var244 = varonce243; +} else { +var245 = "(nitmethod_t)"; +var246 = core__flat___NativeString___to_s_full(var245, 13l, 13l); +var244 = var246; +varonce243 = var244; +} +((struct instance_core__NativeArray*)var242)->values[0]=var244; +if (likely(varonce247!=NULL)) { +var248 = varonce247; +} else { +var249 = ", /* pointer to "; +var250 = core__flat___NativeString___to_s_full(var249, 16l, 16l); +var248 = var250; +varonce247 = var248; +} +((struct instance_core__NativeArray*)var242)->values[2]=var248; +if (likely(varonce251!=NULL)) { +var252 = varonce251; +} else { +var253 = ":"; +var254 = core__flat___NativeString___to_s_full(var253, 1l, 1l); +var252 = var254; +varonce251 = var252; +} +((struct instance_core__NativeArray*)var242)->values[4]=var252; +if (likely(varonce255!=NULL)) { +var256 = varonce255; +} else { +var257 = ":"; +var258 = core__flat___NativeString___to_s_full(var257, 1l, 1l); +var256 = var258; +varonce255 = var256; +} +((struct instance_core__NativeArray*)var242)->values[6]=var256; +if (likely(varonce259!=NULL)) { +var260 = varonce259; +} else { +var261 = " */"; +var262 = core__flat___NativeString___to_s_full(var261, 3l, 3l); +var260 = var262; +varonce259 = var260; +} +((struct instance_core__NativeArray*)var242)->values[8]=var260; +} else { +var242 = varonce241; +varonce241 = NULL; +} +{ +var263 = nitc___nitc__AbstractRuntimeFunction___c_name(var_rf); +} +((struct instance_core__NativeArray*)var242)->values[1]=var263; +{ +{ /* Inline model#MClass#intro_mmodule (var_mclass) on */ +var266 = var_mclass->attrs[COLOR_nitc__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ +if (unlikely(var266 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 380); +fatal_exit(1); +} +var264 = var266; +RET_LABEL265:(void)0; +} +} +{ +var267 = ((val*(*)(val* self))(var264->class->vft[COLOR_core__abstract_text__Object__to_s]))(var264); /* to_s on */ +} +((struct instance_core__NativeArray*)var242)->values[3]=var267; +{ +var268 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var242)->values[5]=var268; +{ +var269 = ((val*(*)(val* self))(var_mpropdef->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mpropdef); /* to_s on */ +} +((struct instance_core__NativeArray*)var242)->values[7]=var269; +{ +var270 = ((val*(*)(val* self))(var242->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var242); /* native_to_s on */ +} +varonce241 = var242; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var270); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +BREAK_label191: (void)0; +{ +var271 = core___core__Int___Discrete__successor(var_i, 1l); +} +var_i = var271; +} +BREAK_label: (void)0; +} else { +} +if (likely(varonce272!=NULL)) { +var273 = varonce272; +} else { +var274 = "}"; +var275 = core__flat___NativeString___to_s_full(var274, 1l, 1l); +var273 = var275; +varonce272 = var273; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var273); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce276!=NULL)) { +var277 = varonce276; +} else { +var278 = "};"; +var279 = core__flat___NativeString___to_s_full(var278, 2l, 2l); +var277 = var279; +varonce276 = var277; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var277); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +} +{ +var281 = nitc__abstract_compiler___MClassType___MType__is_c_primitive(var_mtype); +} +var_282 = var281; +if (var281){ +var280 = var_282; +} else { +{ +{ /* Inline model#MClassType#mclass (var_mtype) on */ +var285 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var285 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +fatal_exit(1); +} +var283 = var285; +RET_LABEL284:(void)0; +} +} +{ +{ /* Inline model#MClass#name (var283) on */ +var288 = var283->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var288 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var286 = var288; +RET_LABEL287:(void)0; +} +} +if (likely(varonce289!=NULL)) { +var290 = varonce289; +} else { +var291 = "Pointer"; +var292 = core__flat___NativeString___to_s_full(var291, 7l, 7l); +var290 = var292; +varonce289 = var290; +} +{ +var293 = ((short int(*)(val* self, val* p0))(var286->class->vft[COLOR_core__kernel__Object___61d_61d]))(var286, var290); /* == on */ +} +var280 = var293; +} +if (var280){ +{ +{ /* Inline separate_compiler#MType#is_tagged (var_mtype) on */ +var296 = var_mtype->attrs[COLOR_nitc__separate_compiler__MType___is_tagged].s; /* _is_tagged on */ +var294 = var296; +RET_LABEL295:(void)0; +} +} +if (var294){ +goto RET_LABEL; +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var299 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var299 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var297 = var299; +RET_LABEL298:(void)0; +} +} +if (unlikely(varonce300==NULL)) { +var301 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce302!=NULL)) { +var303 = varonce302; +} else { +var304 = "struct instance_"; +var305 = core__flat___NativeString___to_s_full(var304, 16l, 16l); +var303 = var305; +varonce302 = var303; +} +((struct instance_core__NativeArray*)var301)->values[0]=var303; +if (likely(varonce306!=NULL)) { +var307 = varonce306; +} else { +var308 = " {"; +var309 = core__flat___NativeString___to_s_full(var308, 2l, 2l); +var307 = var309; +varonce306 = var307; +} +((struct instance_core__NativeArray*)var301)->values[2]=var307; +} else { +var301 = varonce300; +varonce300 = NULL; +} +((struct instance_core__NativeArray*)var301)->values[1]=var_c_name; +{ +var310 = ((val*(*)(val* self))(var301->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var301); /* native_to_s on */ +} +varonce300 = var301; +{ +nitc___nitc__CodeWriter___add_decl(var297, var310); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var313 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var313 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var311 = var313; +RET_LABEL312:(void)0; +} +} +if (likely(varonce314!=NULL)) { +var315 = varonce314; +} else { +var316 = "const struct type *type;"; +var317 = core__flat___NativeString___to_s_full(var316, 24l, 24l); +var315 = var317; +varonce314 = var315; +} +{ +nitc___nitc__CodeWriter___add_decl(var311, var315); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var320 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var320 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var318 = var320; +RET_LABEL319:(void)0; +} +} +if (likely(varonce321!=NULL)) { +var322 = varonce321; +} else { +var323 = "const struct class *class;"; +var324 = core__flat___NativeString___to_s_full(var323, 26l, 26l); +var322 = var324; +varonce321 = var322; +} +{ +nitc___nitc__CodeWriter___add_decl(var318, var322); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var327 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var327 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var325 = var327; +RET_LABEL326:(void)0; +} +} +if (unlikely(varonce328==NULL)) { +var329 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce330!=NULL)) { +var331 = varonce330; +} else { +var332 = " value;"; +var333 = core__flat___NativeString___to_s_full(var332, 7l, 7l); +var331 = var333; +varonce330 = var331; +} +((struct instance_core__NativeArray*)var329)->values[1]=var331; +} else { +var329 = varonce328; +varonce328 = NULL; +} +{ +var334 = nitc__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +} +((struct instance_core__NativeArray*)var329)->values[0]=var334; +{ +var335 = ((val*(*)(val* self))(var329->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var329); /* native_to_s on */ +} +varonce328 = var329; +{ +nitc___nitc__CodeWriter___add_decl(var325, var335); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var338 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var338 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var336 = var338; +RET_LABEL337:(void)0; +} +} +if (likely(varonce339!=NULL)) { +var340 = varonce339; +} else { +var341 = "};"; +var342 = core__flat___NativeString___to_s_full(var341, 2l, 2l); +var340 = var342; +varonce339 = var340; +} +{ +nitc___nitc__CodeWriter___add_decl(var336, var340); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +var_344 = var_is_dead; +if (var_is_dead){ +{ +{ /* Inline model#MClassType#mclass (var_mtype) on */ +var347 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var347 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +fatal_exit(1); +} +var345 = var347; +RET_LABEL346:(void)0; +} +} +{ +{ /* Inline model#MClass#name (var345) on */ +var350 = var345->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var350 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var348 = var350; +RET_LABEL349:(void)0; +} +} +if (likely(varonce351!=NULL)) { +var352 = varonce351; +} else { +var353 = "Pointer"; +var354 = core__flat___NativeString___to_s_full(var353, 7l, 7l); +var352 = var354; +varonce351 = var352; +} +{ +{ /* Inline kernel#Object#!= (var348,var352) on */ +var_other = var352; +{ +var357 = ((short int(*)(val* self, val* p0))(var348->class->vft[COLOR_core__kernel__Object___61d_61d]))(var348, var_other); /* == on */ +} +var358 = !var357; +var355 = var358; +goto RET_LABEL356; +RET_LABEL356:(void)0; +} +} +var343 = var355; +} else { +var343 = var_344; +} +if (var343){ +goto RET_LABEL; +} else { +} +if (unlikely(varonce359==NULL)) { +var360 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce361!=NULL)) { +var362 = varonce361; +} else { +var363 = "BOX_"; +var364 = core__flat___NativeString___to_s_full(var363, 4l, 4l); +var362 = var364; +varonce361 = var362; +} +((struct instance_core__NativeArray*)var360)->values[0]=var362; +} else { +var360 = varonce359; +varonce359 = NULL; +} +((struct instance_core__NativeArray*)var360)->values[1]=var_c_name; +{ +var365 = ((val*(*)(val* self))(var360->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var360); /* native_to_s on */ +} +varonce359 = var360; +if (unlikely(varonce366==NULL)) { +var367 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce368!=NULL)) { +var369 = varonce368; +} else { +var370 = "val* BOX_"; +var371 = core__flat___NativeString___to_s_full(var370, 9l, 9l); +var369 = var371; +varonce368 = var369; +} +((struct instance_core__NativeArray*)var367)->values[0]=var369; +if (likely(varonce372!=NULL)) { +var373 = varonce372; +} else { +var374 = "("; +var375 = core__flat___NativeString___to_s_full(var374, 1l, 1l); +var373 = var375; +varonce372 = var373; +} +((struct instance_core__NativeArray*)var367)->values[2]=var373; +if (likely(varonce376!=NULL)) { +var377 = varonce376; +} else { +var378 = ");"; +var379 = core__flat___NativeString___to_s_full(var378, 2l, 2l); +var377 = var379; +varonce376 = var377; +} +((struct instance_core__NativeArray*)var367)->values[4]=var377; +} else { +var367 = varonce366; +varonce366 = NULL; +} +((struct instance_core__NativeArray*)var367)->values[1]=var_c_name; +{ +var380 = nitc__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +} +((struct instance_core__NativeArray*)var367)->values[3]=var380; +{ +var381 = ((val*(*)(val* self))(var367->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var367); /* native_to_s on */ +} +varonce366 = var367; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var365, var381); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce382==NULL)) { +var383 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce384!=NULL)) { +var385 = varonce384; +} else { +var386 = "/* allocate "; +var387 = core__flat___NativeString___to_s_full(var386, 12l, 12l); +var385 = var387; +varonce384 = var385; +} +((struct instance_core__NativeArray*)var383)->values[0]=var385; +if (likely(varonce388!=NULL)) { +var389 = varonce388; +} else { +var390 = " */"; +var391 = core__flat___NativeString___to_s_full(var390, 3l, 3l); +var389 = var391; +varonce388 = var389; +} +((struct instance_core__NativeArray*)var383)->values[2]=var389; +} else { +var383 = varonce382; +varonce382 = NULL; +} +{ +var392 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var383)->values[1]=var392; +{ +var393 = ((val*(*)(val* self))(var383->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var383); /* native_to_s on */ +} +varonce382 = var383; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var393); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce394==NULL)) { +var395 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce396!=NULL)) { +var397 = varonce396; +} else { +var398 = "val* BOX_"; +var399 = core__flat___NativeString___to_s_full(var398, 9l, 9l); +var397 = var399; +varonce396 = var397; +} +((struct instance_core__NativeArray*)var395)->values[0]=var397; +if (likely(varonce400!=NULL)) { +var401 = varonce400; +} else { +var402 = "("; +var403 = core__flat___NativeString___to_s_full(var402, 1l, 1l); +var401 = var403; +varonce400 = var401; +} +((struct instance_core__NativeArray*)var395)->values[2]=var401; +if (likely(varonce404!=NULL)) { +var405 = varonce404; +} else { +var406 = " value) {"; +var407 = core__flat___NativeString___to_s_full(var406, 9l, 9l); +var405 = var407; +varonce404 = var405; +} +((struct instance_core__NativeArray*)var395)->values[4]=var405; +} else { +var395 = varonce394; +varonce394 = NULL; +} +{ +var408 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var395)->values[1]=var408; +{ +var409 = nitc__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +} +((struct instance_core__NativeArray*)var395)->values[3]=var409; +{ +var410 = ((val*(*)(val* self))(var395->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var395); /* native_to_s on */ +} +varonce394 = var395; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var410); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce411==NULL)) { +var412 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce413!=NULL)) { +var414 = varonce413; +} else { +var415 = "struct instance_"; +var416 = core__flat___NativeString___to_s_full(var415, 16l, 16l); +var414 = var416; +varonce413 = var414; +} +((struct instance_core__NativeArray*)var412)->values[0]=var414; +if (likely(varonce417!=NULL)) { +var418 = varonce417; +} else { +var419 = "*res = nit_alloc(sizeof(struct instance_"; +var420 = core__flat___NativeString___to_s_full(var419, 40l, 40l); +var418 = var420; +varonce417 = var418; +} +((struct instance_core__NativeArray*)var412)->values[2]=var418; +if (likely(varonce421!=NULL)) { +var422 = varonce421; +} else { +var423 = "));"; +var424 = core__flat___NativeString___to_s_full(var423, 3l, 3l); +var422 = var424; +varonce421 = var422; +} +((struct instance_core__NativeArray*)var412)->values[4]=var422; +} else { +var412 = varonce411; +varonce411 = NULL; +} +((struct instance_core__NativeArray*)var412)->values[1]=var_c_name; +((struct instance_core__NativeArray*)var412)->values[3]=var_c_name; +{ +var425 = ((val*(*)(val* self))(var412->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var412); /* native_to_s on */ +} +varonce411 = var412; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var425); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ +var428 = var_v->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var428 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +fatal_exit(1); +} +var426 = var428; +RET_LABEL427:(void)0; +} +} +{ +{ /* Inline separate_compiler#SeparateCompiler#undead_types (var426) on */ +var431 = var426->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var431 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 146); +fatal_exit(1); +} +var429 = var431; +RET_LABEL430:(void)0; +} +} +{ +((void(*)(val* self, val* p0))((((long)var429&3)?class_info[((long)var429&3)]:var429->class)->vft[COLOR_core__abstract_collection__SimpleCollection__add]))(var429, var_mtype); /* add on */ +} +if (unlikely(varonce432==NULL)) { +var433 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce434!=NULL)) { +var435 = varonce434; +} else { +var436 = "type_"; +var437 = core__flat___NativeString___to_s_full(var436, 5l, 5l); +var435 = var437; +varonce434 = var435; +} +((struct instance_core__NativeArray*)var433)->values[0]=var435; +} else { +var433 = varonce432; +varonce432 = NULL; +} +((struct instance_core__NativeArray*)var433)->values[1]=var_c_name; +{ +var438 = ((val*(*)(val* self))(var433->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var433); /* native_to_s on */ +} +varonce432 = var433; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var438); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce439==NULL)) { +var440 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce441!=NULL)) { +var442 = varonce441; +} else { +var443 = "res->type = &type_"; +var444 = core__flat___NativeString___to_s_full(var443, 18l, 18l); +var442 = var444; +varonce441 = var442; +} +((struct instance_core__NativeArray*)var440)->values[0]=var442; +if (likely(varonce445!=NULL)) { +var446 = varonce445; +} else { +var447 = ";"; +var448 = core__flat___NativeString___to_s_full(var447, 1l, 1l); +var446 = var448; +varonce445 = var446; +} +((struct instance_core__NativeArray*)var440)->values[2]=var446; +} else { +var440 = varonce439; +varonce439 = NULL; +} +((struct instance_core__NativeArray*)var440)->values[1]=var_c_name; +{ +var449 = ((val*(*)(val* self))(var440->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var440); /* native_to_s on */ +} +varonce439 = var440; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var449); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce450==NULL)) { +var451 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce452!=NULL)) { +var453 = varonce452; +} else { +var454 = "class_"; +var455 = core__flat___NativeString___to_s_full(var454, 6l, 6l); +var453 = var455; +varonce452 = var453; +} +((struct instance_core__NativeArray*)var451)->values[0]=var453; +} else { +var451 = varonce450; +varonce450 = NULL; +} +((struct instance_core__NativeArray*)var451)->values[1]=var_c_name; +{ +var456 = ((val*(*)(val* self))(var451->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var451); /* native_to_s on */ +} +varonce450 = var451; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var456); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce457==NULL)) { +var458 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce459!=NULL)) { +var460 = varonce459; +} else { +var461 = "res->class = &class_"; +var462 = core__flat___NativeString___to_s_full(var461, 20l, 20l); +var460 = var462; +varonce459 = var460; +} +((struct instance_core__NativeArray*)var458)->values[0]=var460; +if (likely(varonce463!=NULL)) { +var464 = varonce463; +} else { +var465 = ";"; +var466 = core__flat___NativeString___to_s_full(var465, 1l, 1l); +var464 = var466; +varonce463 = var464; +} +((struct instance_core__NativeArray*)var458)->values[2]=var464; +} else { +var458 = varonce457; +varonce457 = NULL; +} +((struct instance_core__NativeArray*)var458)->values[1]=var_c_name; +{ +var467 = ((val*(*)(val* self))(var458->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var458); /* native_to_s on */ +} +varonce457 = var458; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var467); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce468!=NULL)) { +var469 = varonce468; +} else { +var470 = "res->value = value;"; +var471 = core__flat___NativeString___to_s_full(var470, 19l, 19l); +var469 = var471; +varonce468 = var469; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var469); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce472!=NULL)) { +var473 = varonce472; +} else { +var474 = "return (val*)res;"; +var475 = core__flat___NativeString___to_s_full(var474, 17l, 17l); +var473 = var475; +varonce472 = var473; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var473); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce476!=NULL)) { +var477 = varonce476; +} else { +var478 = "}"; +var479 = core__flat___NativeString___to_s_full(var478, 1l, 1l); +var477 = var479; +varonce476 = var477; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var477); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +{ +{ /* Inline model#MClassType#mclass (var_mtype) on */ +var482 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var482 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +fatal_exit(1); +} +var480 = var482; +RET_LABEL481:(void)0; +} +} +{ +{ /* Inline model#MClass#name (var480) on */ +var485 = var480->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var485 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var483 = var485; +RET_LABEL484:(void)0; +} +} +if (likely(varonce486!=NULL)) { +var487 = varonce486; +} else { +var488 = "Pointer"; +var489 = core__flat___NativeString___to_s_full(var488, 7l, 7l); +var487 = var489; +varonce486 = var487; +} +{ +{ /* Inline kernel#Object#!= (var483,var487) on */ +var_other = var487; +{ +var492 = ((short int(*)(val* self, val* p0))(var483->class->vft[COLOR_core__kernel__Object___61d_61d]))(var483, var_other); /* == on */ +} +var493 = !var492; +var490 = var493; +goto RET_LABEL491; +RET_LABEL491:(void)0; +} +} +if (var490){ +goto RET_LABEL; +} else { +} +{ +var494 = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var494; +if (unlikely(varonce495==NULL)) { +var496 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce497!=NULL)) { +var498 = varonce497; +} else { +var499 = "NEW_"; +var500 = core__flat___NativeString___to_s_full(var499, 4l, 4l); +var498 = var500; +varonce497 = var498; +} +((struct instance_core__NativeArray*)var496)->values[0]=var498; +} else { +var496 = varonce495; +varonce495 = NULL; +} +((struct instance_core__NativeArray*)var496)->values[1]=var_c_name; +{ +var501 = ((val*(*)(val* self))(var496->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var496); /* native_to_s on */ +} +varonce495 = var496; +if (unlikely(varonce502==NULL)) { +var503 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce504!=NULL)) { +var505 = varonce504; +} else { +var506 = " NEW_"; +var507 = core__flat___NativeString___to_s_full(var506, 5l, 5l); +var505 = var507; +varonce504 = var505; +} +((struct instance_core__NativeArray*)var503)->values[1]=var505; +if (likely(varonce508!=NULL)) { +var509 = varonce508; +} else { +var510 = "(const struct type* type);"; +var511 = core__flat___NativeString___to_s_full(var510, 26l, 26l); +var509 = var511; +varonce508 = var509; +} +((struct instance_core__NativeArray*)var503)->values[3]=var509; +} else { +var503 = varonce502; +varonce502 = NULL; +} +{ +var512 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var503)->values[0]=var512; +((struct instance_core__NativeArray*)var503)->values[2]=var_c_name; +{ +var513 = ((val*(*)(val* self))(var503->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var503); /* native_to_s on */ +} +varonce502 = var503; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var501, var513); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce514==NULL)) { +var515 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce516!=NULL)) { +var517 = varonce516; +} else { +var518 = "/* allocate "; +var519 = core__flat___NativeString___to_s_full(var518, 12l, 12l); +var517 = var519; +varonce516 = var517; +} +((struct instance_core__NativeArray*)var515)->values[0]=var517; +if (likely(varonce520!=NULL)) { +var521 = varonce520; +} else { +var522 = " */"; +var523 = core__flat___NativeString___to_s_full(var522, 3l, 3l); +var521 = var523; +varonce520 = var521; +} +((struct instance_core__NativeArray*)var515)->values[2]=var521; +} else { +var515 = varonce514; +varonce514 = NULL; +} +{ +var524 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var515)->values[1]=var524; +{ +var525 = ((val*(*)(val* self))(var515->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var515); /* native_to_s on */ +} +varonce514 = var515; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var525); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce526==NULL)) { +var527 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce528!=NULL)) { +var529 = varonce528; +} else { +var530 = " NEW_"; +var531 = core__flat___NativeString___to_s_full(var530, 5l, 5l); +var529 = var531; +varonce528 = var529; +} +((struct instance_core__NativeArray*)var527)->values[1]=var529; +if (likely(varonce532!=NULL)) { +var533 = varonce532; +} else { +var534 = "(const struct type* type) {"; +var535 = core__flat___NativeString___to_s_full(var534, 27l, 27l); +var533 = var535; +varonce532 = var533; +} +((struct instance_core__NativeArray*)var527)->values[3]=var533; +} else { +var527 = varonce526; +varonce526 = NULL; +} +{ +var536 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var527)->values[0]=var536; +((struct instance_core__NativeArray*)var527)->values[2]=var_c_name; +{ +var537 = ((val*(*)(val* self))(var527->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var527); /* native_to_s on */ +} +varonce526 = var527; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var537); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (var_is_dead){ +if (unlikely(varonce538==NULL)) { +var539 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce540!=NULL)) { +var541 = varonce540; +} else { +var542 = " is DEAD"; +var543 = core__flat___NativeString___to_s_full(var542, 8l, 8l); +var541 = var543; +varonce540 = var541; +} +((struct instance_core__NativeArray*)var539)->values[1]=var541; +} else { +var539 = varonce538; +varonce538 = NULL; +} +{ +var544 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var539)->values[0]=var544; +{ +var545 = ((val*(*)(val* self))(var539->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var539); /* native_to_s on */ +} +varonce538 = var539; +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(var_v, var545); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +} else { +if (likely(varonce546!=NULL)) { +var547 = varonce546; +} else { +var548 = "self"; +var549 = core__flat___NativeString___to_s_full(var548, 4l, 4l); +var547 = var549; +varonce546 = var547; +} +{ +var550 = nitc___nitc__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var547); +} +var_res = var550; +{ +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,1) on */ +var_res->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL551:(void)0; +} +} +if (unlikely(varonce552==NULL)) { +var553 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce554!=NULL)) { +var555 = varonce554; +} else { +var556 = " = nit_alloc(sizeof(struct instance_"; +var557 = core__flat___NativeString___to_s_full(var556, 36l, 36l); +var555 = var557; +varonce554 = var555; +} +((struct instance_core__NativeArray*)var553)->values[1]=var555; +if (likely(varonce558!=NULL)) { +var559 = varonce558; +} else { +var560 = "));"; +var561 = core__flat___NativeString___to_s_full(var560, 3l, 3l); +var559 = var561; +varonce558 = var559; +} +((struct instance_core__NativeArray*)var553)->values[3]=var559; +} else { +var553 = varonce552; +varonce552 = NULL; +} +{ +var562 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var553)->values[0]=var562; +{ +var563 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var553)->values[2]=var563; +{ +var564 = ((val*(*)(val* self))(var553->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var553); /* native_to_s on */ +} +varonce552 = var553; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var564); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce565==NULL)) { +var566 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce567!=NULL)) { +var568 = varonce567; +} else { +var569 = "->type = type;"; +var570 = core__flat___NativeString___to_s_full(var569, 14l, 14l); +var568 = var570; +varonce567 = var568; +} +((struct instance_core__NativeArray*)var566)->values[1]=var568; +} else { +var566 = varonce565; +varonce565 = NULL; +} +{ +var571 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var566)->values[0]=var571; +{ +var572 = ((val*(*)(val* self))(var566->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var566); /* native_to_s on */ +} +varonce565 = var566; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var572); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce573!=NULL)) { +var574 = varonce573; +} else { +var575 = "type"; +var576 = core__flat___NativeString___to_s_full(var575, 4l, 4l); +var574 = var576; +varonce573 = var574; +} +{ +nitc___nitc__SeparateCompiler___hardening_live_type(self, var_v, var574); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +} +if (unlikely(varonce577==NULL)) { +var578 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce579!=NULL)) { +var580 = varonce579; +} else { +var581 = "class_"; +var582 = core__flat___NativeString___to_s_full(var581, 6l, 6l); +var580 = var582; +varonce579 = var580; +} +((struct instance_core__NativeArray*)var578)->values[0]=var580; +} else { +var578 = varonce577; +varonce577 = NULL; +} +((struct instance_core__NativeArray*)var578)->values[1]=var_c_name; +{ +var583 = ((val*(*)(val* self))(var578->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var578); /* native_to_s on */ +} +varonce577 = var578; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var583); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce584==NULL)) { +var585 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce586!=NULL)) { +var587 = varonce586; +} else { +var588 = "->class = &class_"; +var589 = core__flat___NativeString___to_s_full(var588, 17l, 17l); +var587 = var589; +varonce586 = var587; +} +((struct instance_core__NativeArray*)var585)->values[1]=var587; +if (likely(varonce590!=NULL)) { +var591 = varonce590; +} else { +var592 = ";"; +var593 = core__flat___NativeString___to_s_full(var592, 1l, 1l); +var591 = var593; +varonce590 = var591; +} +((struct instance_core__NativeArray*)var585)->values[3]=var591; +} else { +var585 = varonce584; +varonce584 = NULL; +} +{ +var594 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var585)->values[0]=var594; +((struct instance_core__NativeArray*)var585)->values[2]=var_c_name; +{ +var595 = ((val*(*)(val* self))(var585->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var585); /* native_to_s on */ +} +varonce584 = var585; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var595); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce596==NULL)) { +var597 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce598!=NULL)) { +var599 = varonce598; +} else { +var600 = "((struct instance_"; +var601 = core__flat___NativeString___to_s_full(var600, 18l, 18l); +var599 = var601; +varonce598 = var599; +} +((struct instance_core__NativeArray*)var597)->values[0]=var599; +if (likely(varonce602!=NULL)) { +var603 = varonce602; +} else { +var604 = "*)"; +var605 = core__flat___NativeString___to_s_full(var604, 2l, 2l); +var603 = var605; +varonce602 = var603; +} +((struct instance_core__NativeArray*)var597)->values[2]=var603; +if (likely(varonce606!=NULL)) { +var607 = varonce606; +} else { +var608 = ")->value = NULL;"; +var609 = core__flat___NativeString___to_s_full(var608, 16l, 16l); +var607 = var609; +varonce606 = var607; +} +((struct instance_core__NativeArray*)var597)->values[4]=var607; +} else { +var597 = varonce596; +varonce596 = NULL; +} +{ +var610 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_core__NativeArray*)var597)->values[1]=var610; +{ +var611 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var597)->values[3]=var611; +{ +var612 = ((val*(*)(val* self))(var597->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var597); /* native_to_s on */ +} +varonce596 = var597; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var612); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce613==NULL)) { +var614 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce615!=NULL)) { +var616 = varonce615; +} else { +var617 = "return "; +var618 = core__flat___NativeString___to_s_full(var617, 7l, 7l); +var616 = var618; +varonce615 = var616; +} +((struct instance_core__NativeArray*)var614)->values[0]=var616; +if (likely(varonce619!=NULL)) { +var620 = varonce619; +} else { +var621 = ";"; +var622 = core__flat___NativeString___to_s_full(var621, 1l, 1l); +var620 = var622; +varonce619 = var620; +} +((struct instance_core__NativeArray*)var614)->values[2]=var620; +} else { +var614 = varonce613; +varonce613 = NULL; +} +{ +var623 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var614)->values[1]=var623; +{ +var624 = ((val*(*)(val* self))(var614->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var614); /* native_to_s on */ +} +varonce613 = var614; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var624); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} +if (likely(varonce625!=NULL)) { +var626 = varonce625; +} else { +var627 = "}"; +var628 = core__flat___NativeString___to_s_full(var627, 1l, 1l); +var626 = var628; +varonce625 = var626; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var626); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +goto RET_LABEL; +} else { +{ +{ /* Inline model#MClass#name (var_mclass) on */ +var631 = var_mclass->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var631 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var629 = var631; +RET_LABEL630:(void)0; +} +} +if (likely(varonce632!=NULL)) { +var633 = varonce632; +} else { +var634 = "NativeArray"; +var635 = core__flat___NativeString___to_s_full(var634, 11l, 11l); +var633 = var635; +varonce632 = var633; +} +{ +var636 = ((short int(*)(val* self, val* p0))(var629->class->vft[COLOR_core__kernel__Object___61d_61d]))(var629, var633); /* == on */ +} +if (var636){ +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var639 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var639 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var637 = var639; +RET_LABEL638:(void)0; +} +} +if (unlikely(varonce640==NULL)) { +var641 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce642!=NULL)) { +var643 = varonce642; +} else { +var644 = "struct instance_"; +var645 = core__flat___NativeString___to_s_full(var644, 16l, 16l); +var643 = var645; +varonce642 = var643; +} +((struct instance_core__NativeArray*)var641)->values[0]=var643; +if (likely(varonce646!=NULL)) { +var647 = varonce646; +} else { +var648 = " {"; +var649 = core__flat___NativeString___to_s_full(var648, 2l, 2l); +var647 = var649; +varonce646 = var647; +} +((struct instance_core__NativeArray*)var641)->values[2]=var647; +} else { +var641 = varonce640; +varonce640 = NULL; +} +((struct instance_core__NativeArray*)var641)->values[1]=var_c_name; +{ +var650 = ((val*(*)(val* self))(var641->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var641); /* native_to_s on */ +} +varonce640 = var641; +{ +nitc___nitc__CodeWriter___add_decl(var637, var650); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var653 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var653 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var651 = var653; +RET_LABEL652:(void)0; +} +} +if (likely(varonce654!=NULL)) { +var655 = varonce654; +} else { +var656 = "const struct type *type;"; +var657 = core__flat___NativeString___to_s_full(var656, 24l, 24l); +var655 = var657; +varonce654 = var655; +} +{ +nitc___nitc__CodeWriter___add_decl(var651, var655); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var660 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var660 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var658 = var660; +RET_LABEL659:(void)0; +} +} +if (likely(varonce661!=NULL)) { +var662 = varonce661; +} else { +var663 = "const struct class *class;"; +var664 = core__flat___NativeString___to_s_full(var663, 26l, 26l); +var662 = var664; +varonce661 = var662; +} +{ +nitc___nitc__CodeWriter___add_decl(var658, var662); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var667 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var667 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var665 = var667; +RET_LABEL666:(void)0; +} +} +if (likely(varonce668!=NULL)) { +var669 = varonce668; +} else { +var670 = "int length;"; +var671 = core__flat___NativeString___to_s_full(var670, 11l, 11l); +var669 = var671; +varonce668 = var669; +} +{ +nitc___nitc__CodeWriter___add_decl(var665, var669); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var674 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var674 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var672 = var674; +RET_LABEL673:(void)0; +} +} +if (likely(varonce675!=NULL)) { +var676 = varonce675; +} else { +var677 = "val* values[0];"; +var678 = core__flat___NativeString___to_s_full(var677, 15l, 15l); +var676 = var678; +varonce675 = var676; +} +{ +nitc___nitc__CodeWriter___add_decl(var672, var676); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var681 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var681 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var679 = var681; +RET_LABEL680:(void)0; +} +} +if (likely(varonce682!=NULL)) { +var683 = varonce682; +} else { +var684 = "};"; +var685 = core__flat___NativeString___to_s_full(var684, 2l, 2l); +var683 = var685; +varonce682 = var683; +} +{ +nitc___nitc__CodeWriter___add_decl(var679, var683); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +if (unlikely(varonce686==NULL)) { +var687 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce688!=NULL)) { +var689 = varonce688; +} else { +var690 = "NEW_"; +var691 = core__flat___NativeString___to_s_full(var690, 4l, 4l); +var689 = var691; +varonce688 = var689; +} +((struct instance_core__NativeArray*)var687)->values[0]=var689; +} else { +var687 = varonce686; +varonce686 = NULL; +} +((struct instance_core__NativeArray*)var687)->values[1]=var_c_name; +{ +var692 = ((val*(*)(val* self))(var687->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var687); /* native_to_s on */ +} +varonce686 = var687; +if (unlikely(varonce693==NULL)) { +var694 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce695!=NULL)) { +var696 = varonce695; +} else { +var697 = " NEW_"; +var698 = core__flat___NativeString___to_s_full(var697, 5l, 5l); +var696 = var698; +varonce695 = var696; +} +((struct instance_core__NativeArray*)var694)->values[1]=var696; +if (likely(varonce699!=NULL)) { +var700 = varonce699; +} else { +var701 = "(int length, const struct type* type);"; +var702 = core__flat___NativeString___to_s_full(var701, 38l, 38l); +var700 = var702; +varonce699 = var700; +} +((struct instance_core__NativeArray*)var694)->values[3]=var700; +} else { +var694 = varonce693; +varonce693 = NULL; +} +{ +var703 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var694)->values[0]=var703; +((struct instance_core__NativeArray*)var694)->values[2]=var_c_name; +{ +var704 = ((val*(*)(val* self))(var694->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var694); /* native_to_s on */ +} +varonce693 = var694; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var692, var704); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce705==NULL)) { +var706 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce707!=NULL)) { +var708 = varonce707; +} else { +var709 = "/* allocate "; +var710 = core__flat___NativeString___to_s_full(var709, 12l, 12l); +var708 = var710; +varonce707 = var708; +} +((struct instance_core__NativeArray*)var706)->values[0]=var708; +if (likely(varonce711!=NULL)) { +var712 = varonce711; +} else { +var713 = " */"; +var714 = core__flat___NativeString___to_s_full(var713, 3l, 3l); +var712 = var714; +varonce711 = var712; +} +((struct instance_core__NativeArray*)var706)->values[2]=var712; +} else { +var706 = varonce705; +varonce705 = NULL; +} +{ +var715 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var706)->values[1]=var715; +{ +var716 = ((val*(*)(val* self))(var706->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var706); /* native_to_s on */ +} +varonce705 = var706; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var716); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce717==NULL)) { +var718 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce719!=NULL)) { +var720 = varonce719; +} else { +var721 = " NEW_"; +var722 = core__flat___NativeString___to_s_full(var721, 5l, 5l); +var720 = var722; +varonce719 = var720; +} +((struct instance_core__NativeArray*)var718)->values[1]=var720; +if (likely(varonce723!=NULL)) { +var724 = varonce723; +} else { +var725 = "(int length, const struct type* type) {"; +var726 = core__flat___NativeString___to_s_full(var725, 39l, 39l); +var724 = var726; +varonce723 = var724; +} +((struct instance_core__NativeArray*)var718)->values[3]=var724; +} else { +var718 = varonce717; +varonce717 = NULL; +} +{ +var727 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var718)->values[0]=var727; +((struct instance_core__NativeArray*)var718)->values[2]=var_c_name; +{ +var728 = ((val*(*)(val* self))(var718->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var718); /* native_to_s on */ +} +varonce717 = var718; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var728); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce729!=NULL)) { +var730 = varonce729; +} else { +var731 = "self"; +var732 = core__flat___NativeString___to_s_full(var731, 4l, 4l); +var730 = var732; +varonce729 = var730; +} +{ +var733 = nitc___nitc__AbstractCompilerVisitor___get_name(var_v, var730); +} +var_res734 = var733; +if (unlikely(varonce735==NULL)) { +var736 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce737!=NULL)) { +var738 = varonce737; +} else { +var739 = "struct instance_"; +var740 = core__flat___NativeString___to_s_full(var739, 16l, 16l); +var738 = var740; +varonce737 = var738; +} +((struct instance_core__NativeArray*)var736)->values[0]=var738; +if (likely(varonce741!=NULL)) { +var742 = varonce741; +} else { +var743 = " *"; +var744 = core__flat___NativeString___to_s_full(var743, 2l, 2l); +var742 = var744; +varonce741 = var742; +} +((struct instance_core__NativeArray*)var736)->values[2]=var742; +if (likely(varonce745!=NULL)) { +var746 = varonce745; +} else { +var747 = ";"; +var748 = core__flat___NativeString___to_s_full(var747, 1l, 1l); +var746 = var748; +varonce745 = var746; +} +((struct instance_core__NativeArray*)var736)->values[4]=var746; +} else { +var736 = varonce735; +varonce735 = NULL; +} +((struct instance_core__NativeArray*)var736)->values[1]=var_c_name; +((struct instance_core__NativeArray*)var736)->values[3]=var_res734; +{ +var749 = ((val*(*)(val* self))(var736->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var736); /* native_to_s on */ +} +varonce735 = var736; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var749); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +var750 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MClassType__arguments]))(var_mtype); /* arguments on */ +} +{ +var751 = core___core__SequenceRead___Collection__first(var750); +} +var_mtype_elt = var751; +if (unlikely(varonce752==NULL)) { +var753 = NEW_core__NativeArray(6l, &type_core__NativeArray__core__String); +if (likely(varonce754!=NULL)) { +var755 = varonce754; +} else { +var756 = " = nit_alloc(sizeof(struct instance_"; +var757 = core__flat___NativeString___to_s_full(var756, 36l, 36l); +var755 = var757; +varonce754 = var755; +} +((struct instance_core__NativeArray*)var753)->values[1]=var755; +if (likely(varonce758!=NULL)) { +var759 = varonce758; +} else { +var760 = ") + length*sizeof("; +var761 = core__flat___NativeString___to_s_full(var760, 18l, 18l); +var759 = var761; +varonce758 = var759; +} +((struct instance_core__NativeArray*)var753)->values[3]=var759; +if (likely(varonce762!=NULL)) { +var763 = varonce762; +} else { +var764 = "));"; +var765 = core__flat___NativeString___to_s_full(var764, 3l, 3l); +var763 = var765; +varonce762 = var763; +} +((struct instance_core__NativeArray*)var753)->values[5]=var763; +} else { +var753 = varonce752; +varonce752 = NULL; +} +((struct instance_core__NativeArray*)var753)->values[0]=var_res734; +((struct instance_core__NativeArray*)var753)->values[2]=var_c_name; +{ +var766 = ((val*(*)(val* self))(var_mtype_elt->class->vft[COLOR_nitc__abstract_compiler__MType__ctype]))(var_mtype_elt); /* ctype on */ +} +((struct instance_core__NativeArray*)var753)->values[4]=var766; +{ +var767 = ((val*(*)(val* self))(var753->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var753); /* native_to_s on */ +} +varonce752 = var753; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var767); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce768==NULL)) { +var769 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce770!=NULL)) { +var771 = varonce770; +} else { +var772 = "->type = type;"; +var773 = core__flat___NativeString___to_s_full(var772, 14l, 14l); +var771 = var773; +varonce770 = var771; +} +((struct instance_core__NativeArray*)var769)->values[1]=var771; +} else { +var769 = varonce768; +varonce768 = NULL; +} +((struct instance_core__NativeArray*)var769)->values[0]=var_res734; +{ +var774 = ((val*(*)(val* self))(var769->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var769); /* native_to_s on */ +} +varonce768 = var769; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var774); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce775!=NULL)) { +var776 = varonce775; +} else { +var777 = "type"; +var778 = core__flat___NativeString___to_s_full(var777, 4l, 4l); +var776 = var778; +varonce775 = var776; +} +{ +nitc___nitc__SeparateCompiler___hardening_live_type(self, var_v, var776); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +} +if (unlikely(varonce779==NULL)) { +var780 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce781!=NULL)) { +var782 = varonce781; +} else { +var783 = "class_"; +var784 = core__flat___NativeString___to_s_full(var783, 6l, 6l); +var782 = var784; +varonce781 = var782; +} +((struct instance_core__NativeArray*)var780)->values[0]=var782; +} else { +var780 = varonce779; +varonce779 = NULL; +} +((struct instance_core__NativeArray*)var780)->values[1]=var_c_name; +{ +var785 = ((val*(*)(val* self))(var780->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var780); /* native_to_s on */ +} +varonce779 = var780; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var785); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce786==NULL)) { +var787 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce788!=NULL)) { +var789 = varonce788; +} else { +var790 = "->class = &class_"; +var791 = core__flat___NativeString___to_s_full(var790, 17l, 17l); +var789 = var791; +varonce788 = var789; +} +((struct instance_core__NativeArray*)var787)->values[1]=var789; +if (likely(varonce792!=NULL)) { +var793 = varonce792; +} else { +var794 = ";"; +var795 = core__flat___NativeString___to_s_full(var794, 1l, 1l); +var793 = var795; +varonce792 = var793; +} +((struct instance_core__NativeArray*)var787)->values[3]=var793; +} else { +var787 = varonce786; +varonce786 = NULL; +} +((struct instance_core__NativeArray*)var787)->values[0]=var_res734; +((struct instance_core__NativeArray*)var787)->values[2]=var_c_name; +{ +var796 = ((val*(*)(val* self))(var787->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var787); /* native_to_s on */ +} +varonce786 = var787; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var796); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce797==NULL)) { +var798 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce799!=NULL)) { +var800 = varonce799; +} else { +var801 = "->length = length;"; +var802 = core__flat___NativeString___to_s_full(var801, 18l, 18l); +var800 = var802; +varonce799 = var800; +} +((struct instance_core__NativeArray*)var798)->values[1]=var800; +} else { +var798 = varonce797; +varonce797 = NULL; +} +((struct instance_core__NativeArray*)var798)->values[0]=var_res734; +{ +var803 = ((val*(*)(val* self))(var798->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var798); /* native_to_s on */ +} +varonce797 = var798; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var803); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce804==NULL)) { +var805 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce806!=NULL)) { +var807 = varonce806; +} else { +var808 = "return (val*)"; +var809 = core__flat___NativeString___to_s_full(var808, 13l, 13l); +var807 = var809; +varonce806 = var807; +} +((struct instance_core__NativeArray*)var805)->values[0]=var807; +if (likely(varonce810!=NULL)) { +var811 = varonce810; +} else { +var812 = ";"; +var813 = core__flat___NativeString___to_s_full(var812, 1l, 1l); +var811 = var813; +varonce810 = var811; +} +((struct instance_core__NativeArray*)var805)->values[2]=var811; +} else { +var805 = varonce804; +varonce804 = NULL; +} +((struct instance_core__NativeArray*)var805)->values[1]=var_res734; +{ +var814 = ((val*(*)(val* self))(var805->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var805); /* native_to_s on */ +} +varonce804 = var805; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var814); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce815!=NULL)) { +var816 = varonce815; +} else { +var817 = "}"; +var818 = core__flat___NativeString___to_s_full(var817, 1l, 1l); +var816 = var818; +varonce815 = var816; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var816); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +goto RET_LABEL; +} else { +{ +{ /* Inline model#MClassType#mclass (var_mtype) on */ +var822 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var822 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +fatal_exit(1); +} +var820 = var822; +RET_LABEL821:(void)0; +} +} +{ +{ /* Inline model#MClass#kind (var820) on */ +var825 = var820->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on */ +if (unlikely(var825 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 459); +fatal_exit(1); +} +var823 = var825; +RET_LABEL824:(void)0; +} +} +var826 = glob_sys; +{ +var827 = nitc__model___core__Sys___extern_kind(var826); +} +{ +{ /* Inline kernel#Object#== (var823,var827) on */ +var_other38 = var827; +{ +{ /* Inline kernel#Object#is_same_instance (var823,var_other38) on */ +var832 = var823 == var_other38; +var830 = var832; +goto RET_LABEL831; +RET_LABEL831:(void)0; +} +} +var828 = var830; +goto RET_LABEL829; +RET_LABEL829:(void)0; +} +} +var_833 = var828; +if (var828){ +{ +{ /* Inline model#MClassType#mclass (var_mtype) on */ +var836 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var836 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +fatal_exit(1); +} +var834 = var836; +RET_LABEL835:(void)0; +} +} +{ +{ /* Inline model#MClass#name (var834) on */ +var839 = var834->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var839 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var837 = var839; +RET_LABEL838:(void)0; +} +} +if (likely(varonce840!=NULL)) { +var841 = varonce840; +} else { +var842 = "NativeString"; +var843 = core__flat___NativeString___to_s_full(var842, 12l, 12l); +var841 = var843; +varonce840 = var841; +} +{ +{ /* Inline kernel#Object#!= (var837,var841) on */ +var_other = var841; +{ +var846 = ((short int(*)(val* self, val* p0))(var837->class->vft[COLOR_core__kernel__Object___61d_61d]))(var837, var_other); /* == on */ +} +var847 = !var846; +var844 = var847; +goto RET_LABEL845; +RET_LABEL845:(void)0; +} +} +var819 = var844; +} else { +var819 = var_833; +} +if (var819){ +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var850 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var850 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 531); +fatal_exit(1); +} +var848 = var850; +RET_LABEL849:(void)0; +} +} +{ +var851 = nitc__model___MModule___pointer_type(var848); +} +var_pointer_type = var851; +if (unlikely(varonce852==NULL)) { +var853 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce854!=NULL)) { +var855 = varonce854; +} else { +var856 = "NEW_"; +var857 = core__flat___NativeString___to_s_full(var856, 4l, 4l); +var855 = var857; +varonce854 = var855; +} +((struct instance_core__NativeArray*)var853)->values[0]=var855; +} else { +var853 = varonce852; +varonce852 = NULL; +} +((struct instance_core__NativeArray*)var853)->values[1]=var_c_name; +{ +var858 = ((val*(*)(val* self))(var853->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var853); /* native_to_s on */ +} +varonce852 = var853; +if (unlikely(varonce859==NULL)) { +var860 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce861!=NULL)) { +var862 = varonce861; +} else { +var863 = " NEW_"; +var864 = core__flat___NativeString___to_s_full(var863, 5l, 5l); +var862 = var864; +varonce861 = var862; +} +((struct instance_core__NativeArray*)var860)->values[1]=var862; +if (likely(varonce865!=NULL)) { +var866 = varonce865; +} else { +var867 = "(const struct type* type);"; +var868 = core__flat___NativeString___to_s_full(var867, 26l, 26l); +var866 = var868; +varonce865 = var866; +} +((struct instance_core__NativeArray*)var860)->values[3]=var866; +} else { +var860 = varonce859; +varonce859 = NULL; +} +{ +var869 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var860)->values[0]=var869; +((struct instance_core__NativeArray*)var860)->values[2]=var_c_name; +{ +var870 = ((val*(*)(val* self))(var860->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var860); /* native_to_s on */ +} +varonce859 = var860; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var858, var870); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce871==NULL)) { +var872 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce873!=NULL)) { +var874 = varonce873; +} else { +var875 = "/* allocate extern "; +var876 = core__flat___NativeString___to_s_full(var875, 19l, 19l); +var874 = var876; +varonce873 = var874; +} +((struct instance_core__NativeArray*)var872)->values[0]=var874; +if (likely(varonce877!=NULL)) { +var878 = varonce877; +} else { +var879 = " */"; +var880 = core__flat___NativeString___to_s_full(var879, 3l, 3l); +var878 = var880; +varonce877 = var878; +} +((struct instance_core__NativeArray*)var872)->values[2]=var878; +} else { +var872 = varonce871; +varonce871 = NULL; +} +{ +var881 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var872)->values[1]=var881; +{ +var882 = ((val*(*)(val* self))(var872->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var872); /* native_to_s on */ +} +varonce871 = var872; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var882); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce883==NULL)) { +var884 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce885!=NULL)) { +var886 = varonce885; +} else { +var887 = " NEW_"; +var888 = core__flat___NativeString___to_s_full(var887, 5l, 5l); +var886 = var888; +varonce885 = var886; +} +((struct instance_core__NativeArray*)var884)->values[1]=var886; +if (likely(varonce889!=NULL)) { +var890 = varonce889; +} else { +var891 = "(const struct type* type) {"; +var892 = core__flat___NativeString___to_s_full(var891, 27l, 27l); +var890 = var892; +varonce889 = var890; +} +((struct instance_core__NativeArray*)var884)->values[3]=var890; +} else { +var884 = varonce883; +varonce883 = NULL; +} +{ +var893 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var884)->values[0]=var893; +((struct instance_core__NativeArray*)var884)->values[2]=var_c_name; +{ +var894 = ((val*(*)(val* self))(var884->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var884); /* native_to_s on */ +} +varonce883 = var884; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var894); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (var_is_dead){ +if (unlikely(varonce895==NULL)) { +var896 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce897!=NULL)) { +var898 = varonce897; +} else { +var899 = " is DEAD"; +var900 = core__flat___NativeString___to_s_full(var899, 8l, 8l); +var898 = var900; +varonce897 = var898; +} +((struct instance_core__NativeArray*)var896)->values[1]=var898; +} else { +var896 = varonce895; +varonce895 = NULL; +} +{ +var901 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var896)->values[0]=var901; +{ +var902 = ((val*(*)(val* self))(var896->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var896); /* native_to_s on */ +} +varonce895 = var896; +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(var_v, var902); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +} else { +if (likely(varonce903!=NULL)) { +var904 = varonce903; +} else { +var905 = "self"; +var906 = core__flat___NativeString___to_s_full(var905, 4l, 4l); +var904 = var906; +varonce903 = var904; +} +{ +var907 = nitc___nitc__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var904); +} +var_res908 = var907; +{ +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res908,1) on */ +var_res908->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL909:(void)0; +} +} +if (unlikely(varonce910==NULL)) { +var911 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce912!=NULL)) { +var913 = varonce912; +} else { +var914 = " = nit_alloc(sizeof(struct instance_"; +var915 = core__flat___NativeString___to_s_full(var914, 36l, 36l); +var913 = var915; +varonce912 = var913; +} +((struct instance_core__NativeArray*)var911)->values[1]=var913; +if (likely(varonce916!=NULL)) { +var917 = varonce916; +} else { +var918 = "));"; +var919 = core__flat___NativeString___to_s_full(var918, 3l, 3l); +var917 = var919; +varonce916 = var917; +} +((struct instance_core__NativeArray*)var911)->values[3]=var917; +} else { +var911 = varonce910; +varonce910 = NULL; +} +{ +var920 = ((val*(*)(val* self))(var_res908->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res908); /* to_s on */ +} +((struct instance_core__NativeArray*)var911)->values[0]=var920; +{ +var921 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ +} +((struct instance_core__NativeArray*)var911)->values[2]=var921; +{ +var922 = ((val*(*)(val* self))(var911->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var911); /* native_to_s on */ +} +varonce910 = var911; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var922); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce923==NULL)) { +var924 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce925!=NULL)) { +var926 = varonce925; +} else { +var927 = "->type = type;"; +var928 = core__flat___NativeString___to_s_full(var927, 14l, 14l); +var926 = var928; +varonce925 = var926; +} +((struct instance_core__NativeArray*)var924)->values[1]=var926; +} else { +var924 = varonce923; +varonce923 = NULL; +} +{ +var929 = ((val*(*)(val* self))(var_res908->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res908); /* to_s on */ +} +((struct instance_core__NativeArray*)var924)->values[0]=var929; +{ +var930 = ((val*(*)(val* self))(var924->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var924); /* native_to_s on */ +} +varonce923 = var924; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var930); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce931!=NULL)) { +var932 = varonce931; +} else { +var933 = "type"; +var934 = core__flat___NativeString___to_s_full(var933, 4l, 4l); +var932 = var934; +varonce931 = var932; +} +{ +nitc___nitc__SeparateCompiler___hardening_live_type(self, var_v, var932); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +} +if (unlikely(varonce935==NULL)) { +var936 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce937!=NULL)) { +var938 = varonce937; +} else { +var939 = "class_"; +var940 = core__flat___NativeString___to_s_full(var939, 6l, 6l); +var938 = var940; +varonce937 = var938; +} +((struct instance_core__NativeArray*)var936)->values[0]=var938; +} else { +var936 = varonce935; +varonce935 = NULL; +} +((struct instance_core__NativeArray*)var936)->values[1]=var_c_name; +{ +var941 = ((val*(*)(val* self))(var936->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var936); /* native_to_s on */ +} +varonce935 = var936; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var941); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce942==NULL)) { +var943 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce944!=NULL)) { +var945 = varonce944; +} else { +var946 = "->class = &class_"; +var947 = core__flat___NativeString___to_s_full(var946, 17l, 17l); +var945 = var947; +varonce944 = var945; +} +((struct instance_core__NativeArray*)var943)->values[1]=var945; +if (likely(varonce948!=NULL)) { +var949 = varonce948; +} else { +var950 = ";"; +var951 = core__flat___NativeString___to_s_full(var950, 1l, 1l); +var949 = var951; +varonce948 = var949; +} +((struct instance_core__NativeArray*)var943)->values[3]=var949; +} else { +var943 = varonce942; +varonce942 = NULL; +} +{ +var952 = ((val*(*)(val* self))(var_res908->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res908); /* to_s on */ +} +((struct instance_core__NativeArray*)var943)->values[0]=var952; +((struct instance_core__NativeArray*)var943)->values[2]=var_c_name; +{ +var953 = ((val*(*)(val* self))(var943->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var943); /* native_to_s on */ +} +varonce942 = var943; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var953); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce954==NULL)) { +var955 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce956!=NULL)) { +var957 = varonce956; +} else { +var958 = "((struct instance_"; +var959 = core__flat___NativeString___to_s_full(var958, 18l, 18l); +var957 = var959; +varonce956 = var957; +} +((struct instance_core__NativeArray*)var955)->values[0]=var957; +if (likely(varonce960!=NULL)) { +var961 = varonce960; +} else { +var962 = "*)"; +var963 = core__flat___NativeString___to_s_full(var962, 2l, 2l); +var961 = var963; +varonce960 = var961; +} +((struct instance_core__NativeArray*)var955)->values[2]=var961; +if (likely(varonce964!=NULL)) { +var965 = varonce964; +} else { +var966 = ")->value = NULL;"; +var967 = core__flat___NativeString___to_s_full(var966, 16l, 16l); +var965 = var967; +varonce964 = var965; +} +((struct instance_core__NativeArray*)var955)->values[4]=var965; +} else { +var955 = varonce954; +varonce954 = NULL; +} +{ +var968 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ +} +((struct instance_core__NativeArray*)var955)->values[1]=var968; +{ +var969 = ((val*(*)(val* self))(var_res908->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res908); /* to_s on */ +} +((struct instance_core__NativeArray*)var955)->values[3]=var969; +{ +var970 = ((val*(*)(val* self))(var955->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var955); /* native_to_s on */ +} +varonce954 = var955; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var970); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce971==NULL)) { +var972 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce973!=NULL)) { +var974 = varonce973; +} else { +var975 = "return "; +var976 = core__flat___NativeString___to_s_full(var975, 7l, 7l); +var974 = var976; +varonce973 = var974; +} +((struct instance_core__NativeArray*)var972)->values[0]=var974; +if (likely(varonce977!=NULL)) { +var978 = varonce977; +} else { +var979 = ";"; +var980 = core__flat___NativeString___to_s_full(var979, 1l, 1l); +var978 = var980; +varonce977 = var978; +} +((struct instance_core__NativeArray*)var972)->values[2]=var978; +} else { +var972 = varonce971; +varonce971 = NULL; +} +{ +var981 = ((val*(*)(val* self))(var_res908->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res908); /* to_s on */ +} +((struct instance_core__NativeArray*)var972)->values[1]=var981; +{ +var982 = ((val*(*)(val* self))(var972->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var972); /* native_to_s on */ +} +varonce971 = var972; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var982); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} +if (likely(varonce983!=NULL)) { +var984 = varonce983; +} else { +var985 = "}"; +var986 = core__flat___NativeString___to_s_full(var985, 1l, 1l); +var984 = var986; +varonce983 = var984; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var984); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +goto RET_LABEL; +} else { +} +} +} +if (unlikely(varonce987==NULL)) { +var988 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce989!=NULL)) { +var990 = varonce989; +} else { +var991 = "NEW_"; +var992 = core__flat___NativeString___to_s_full(var991, 4l, 4l); +var990 = var992; +varonce989 = var990; +} +((struct instance_core__NativeArray*)var988)->values[0]=var990; +} else { +var988 = varonce987; +varonce987 = NULL; +} +((struct instance_core__NativeArray*)var988)->values[1]=var_c_name; +{ +var993 = ((val*(*)(val* self))(var988->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var988); /* native_to_s on */ +} +varonce987 = var988; +if (unlikely(varonce994==NULL)) { +var995 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce996!=NULL)) { +var997 = varonce996; +} else { +var998 = " NEW_"; +var999 = core__flat___NativeString___to_s_full(var998, 5l, 5l); +var997 = var999; +varonce996 = var997; +} +((struct instance_core__NativeArray*)var995)->values[1]=var997; +if (likely(varonce1000!=NULL)) { +var1001 = varonce1000; +} else { +var1002 = "(const struct type* type);"; +var1003 = core__flat___NativeString___to_s_full(var1002, 26l, 26l); +var1001 = var1003; +varonce1000 = var1001; +} +((struct instance_core__NativeArray*)var995)->values[3]=var1001; +} else { +var995 = varonce994; +varonce994 = NULL; +} +{ +var1004 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var995)->values[0]=var1004; +((struct instance_core__NativeArray*)var995)->values[2]=var_c_name; +{ +var1005 = ((val*(*)(val* self))(var995->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var995); /* native_to_s on */ +} +varonce994 = var995; +{ +nitc___nitc__AbstractCompiler___provide_declaration(self, var993, var1005); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce1006==NULL)) { +var1007 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce1008!=NULL)) { +var1009 = varonce1008; +} else { +var1010 = "/* allocate "; +var1011 = core__flat___NativeString___to_s_full(var1010, 12l, 12l); +var1009 = var1011; +varonce1008 = var1009; +} +((struct instance_core__NativeArray*)var1007)->values[0]=var1009; +if (likely(varonce1012!=NULL)) { +var1013 = varonce1012; +} else { +var1014 = " */"; +var1015 = core__flat___NativeString___to_s_full(var1014, 3l, 3l); +var1013 = var1015; +varonce1012 = var1013; +} +((struct instance_core__NativeArray*)var1007)->values[2]=var1013; +} else { +var1007 = varonce1006; +varonce1006 = NULL; +} +{ +var1016 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var1007)->values[1]=var1016; +{ +var1017 = ((val*(*)(val* self))(var1007->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1007); /* native_to_s on */ +} +varonce1006 = var1007; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var1017); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (unlikely(varonce1018==NULL)) { +var1019 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce1020!=NULL)) { +var1021 = varonce1020; +} else { +var1022 = " NEW_"; +var1023 = core__flat___NativeString___to_s_full(var1022, 5l, 5l); +var1021 = var1023; +varonce1020 = var1021; +} +((struct instance_core__NativeArray*)var1019)->values[1]=var1021; +if (likely(varonce1024!=NULL)) { +var1025 = varonce1024; +} else { +var1026 = "(const struct type* type) {"; +var1027 = core__flat___NativeString___to_s_full(var1026, 27l, 27l); +var1025 = var1027; +varonce1024 = var1025; +} +((struct instance_core__NativeArray*)var1019)->values[3]=var1025; +} else { +var1019 = varonce1018; +varonce1018 = NULL; +} +{ +var1028 = nitc__abstract_compiler___MClassType___MType__ctype(var_mtype); +} +((struct instance_core__NativeArray*)var1019)->values[0]=var1028; +((struct instance_core__NativeArray*)var1019)->values[2]=var_c_name; +{ +var1029 = ((val*(*)(val* self))(var1019->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1019); /* native_to_s on */ +} +varonce1018 = var1019; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var1029); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (var_is_dead){ +if (unlikely(varonce1030==NULL)) { +var1031 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce1032!=NULL)) { +var1033 = varonce1032; +} else { +var1034 = " is DEAD"; +var1035 = core__flat___NativeString___to_s_full(var1034, 8l, 8l); +var1033 = var1035; +varonce1032 = var1033; +} +((struct instance_core__NativeArray*)var1031)->values[1]=var1033; +} else { +var1031 = varonce1030; +varonce1030 = NULL; +} +{ +var1036 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_core__NativeArray*)var1031)->values[0]=var1036; +{ +var1037 = ((val*(*)(val* self))(var1031->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1031); /* native_to_s on */ +} +varonce1030 = var1031; +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(var_v, var1037); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +} else { +if (likely(varonce1038!=NULL)) { +var1039 = varonce1038; +} else { +var1040 = "self"; +var1041 = core__flat___NativeString___to_s_full(var1040, 4l, 4l); +var1039 = var1041; +varonce1038 = var1039; +} +{ +var1042 = nitc___nitc__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var1039); +} +var_res1043 = var1042; +{ +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res1043,1) on */ +var_res1043->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL1044:(void)0; +} +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ +var1047 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var1047 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1068); +fatal_exit(1); +} +var1045 = var1047; +RET_LABEL1046:(void)0; +} +} +{ +var1048 = ((val*(*)(val* self, val* p0))((((long)var1045&3)?class_info[((long)var1045&3)]:var1045->class)->vft[COLOR_core__abstract_collection__MapRead__get_or_null]))(var1045, var_mclass); /* get_or_null on */ +} +var_attrs = var1048; +if (var_attrs == NULL) { +var1049 = 1; /* is null */ +} else { +var1049 = 0; /* arg is null but recv is not */ +} +if (0) { +var1050 = core___core__Array___core__kernel__Object___61d_61d(var_attrs, ((val*)NULL)); +var1049 = var1050; +} +if (var1049){ +if (unlikely(varonce1051==NULL)) { +var1052 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce1053!=NULL)) { +var1054 = varonce1053; +} else { +var1055 = " = nit_alloc(sizeof(struct instance));"; +var1056 = core__flat___NativeString___to_s_full(var1055, 38l, 38l); +var1054 = var1056; +varonce1053 = var1054; +} +((struct instance_core__NativeArray*)var1052)->values[1]=var1054; +} else { +var1052 = varonce1051; +varonce1051 = NULL; +} +{ +var1057 = ((val*(*)(val* self))(var_res1043->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res1043); /* to_s on */ +} +((struct instance_core__NativeArray*)var1052)->values[0]=var1057; +{ +var1058 = ((val*(*)(val* self))(var1052->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1052); /* native_to_s on */ +} +varonce1051 = var1052; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1058); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} else { +if (unlikely(varonce1059==NULL)) { +var1060 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce1061!=NULL)) { +var1062 = varonce1061; +} else { +var1063 = " = nit_alloc(sizeof(struct instance) + "; +var1064 = core__flat___NativeString___to_s_full(var1063, 39l, 39l); +var1062 = var1064; +varonce1061 = var1062; +} +((struct instance_core__NativeArray*)var1060)->values[1]=var1062; +if (likely(varonce1065!=NULL)) { +var1066 = varonce1065; +} else { +var1067 = "*sizeof(nitattribute_t));"; +var1068 = core__flat___NativeString___to_s_full(var1067, 25l, 25l); +var1066 = var1068; +varonce1065 = var1066; +} +((struct instance_core__NativeArray*)var1060)->values[3]=var1066; +} else { +var1060 = varonce1059; +varonce1059 = NULL; +} +{ +var1069 = ((val*(*)(val* self))(var_res1043->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res1043); /* to_s on */ +} +((struct instance_core__NativeArray*)var1060)->values[0]=var1069; +{ +{ /* Inline array#AbstractArrayRead#length (var_attrs) on */ +var1072 = var_attrs->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var1070 = var1072; +RET_LABEL1071:(void)0; +} +} +var1073 = core__flat___Int___core__abstract_text__Object__to_s(var1070); +((struct instance_core__NativeArray*)var1060)->values[2]=var1073; +{ +var1074 = ((val*(*)(val* self))(var1060->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1060); /* native_to_s on */ +} +varonce1059 = var1060; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1074); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} +if (unlikely(varonce1075==NULL)) { +var1076 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce1077!=NULL)) { +var1078 = varonce1077; +} else { +var1079 = "->type = type;"; +var1080 = core__flat___NativeString___to_s_full(var1079, 14l, 14l); +var1078 = var1080; +varonce1077 = var1078; +} +((struct instance_core__NativeArray*)var1076)->values[1]=var1078; +} else { +var1076 = varonce1075; +varonce1075 = NULL; +} +{ +var1081 = ((val*(*)(val* self))(var_res1043->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res1043); /* to_s on */ +} +((struct instance_core__NativeArray*)var1076)->values[0]=var1081; +{ +var1082 = ((val*(*)(val* self))(var1076->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1076); /* native_to_s on */ +} +varonce1075 = var1076; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1082); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce1083!=NULL)) { +var1084 = varonce1083; +} else { +var1085 = "type"; +var1086 = core__flat___NativeString___to_s_full(var1085, 4l, 4l); +var1084 = var1086; +varonce1083 = var1084; +} +{ +nitc___nitc__SeparateCompiler___hardening_live_type(self, var_v, var1084); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +} +if (unlikely(varonce1087==NULL)) { +var1088 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce1089!=NULL)) { +var1090 = varonce1089; +} else { +var1091 = "class_"; +var1092 = core__flat___NativeString___to_s_full(var1091, 6l, 6l); +var1090 = var1092; +varonce1089 = var1090; +} +((struct instance_core__NativeArray*)var1088)->values[0]=var1090; +} else { +var1088 = varonce1087; +varonce1087 = NULL; +} +((struct instance_core__NativeArray*)var1088)->values[1]=var_c_name; +{ +var1093 = ((val*(*)(val* self))(var1088->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1088); /* native_to_s on */ +} +varonce1087 = var1088; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var1093); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce1094==NULL)) { +var1095 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce1096!=NULL)) { +var1097 = varonce1096; +} else { +var1098 = "->class = &class_"; +var1099 = core__flat___NativeString___to_s_full(var1098, 17l, 17l); +var1097 = var1099; +varonce1096 = var1097; +} +((struct instance_core__NativeArray*)var1095)->values[1]=var1097; +if (likely(varonce1100!=NULL)) { +var1101 = varonce1100; +} else { +var1102 = ";"; +var1103 = core__flat___NativeString___to_s_full(var1102, 1l, 1l); +var1101 = var1103; +varonce1100 = var1101; +} +((struct instance_core__NativeArray*)var1095)->values[3]=var1101; +} else { +var1095 = varonce1094; +varonce1094 = NULL; +} +{ +var1104 = ((val*(*)(val* self))(var_res1043->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res1043); /* to_s on */ +} +((struct instance_core__NativeArray*)var1095)->values[0]=var1104; +((struct instance_core__NativeArray*)var1095)->values[2]=var_c_name; +{ +var1105 = ((val*(*)(val* self))(var1095->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1095); /* native_to_s on */ +} +varonce1094 = var1095; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1105); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (var_attrs == NULL) { +var1106 = 0; /* is null */ +} else { +var1106 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel#Object#!= (var_attrs,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var1109 = ((short int(*)(val* self, val* p0))(var_attrs->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_attrs, var_other); /* == on */ +} +var1110 = !var1109; +var1107 = var1110; +goto RET_LABEL1108; +RET_LABEL1108:(void)0; +} +var1106 = var1107; +} +if (var1106){ +{ +nitc___nitc__AbstractCompiler___generate_init_attr(self, var_v, var_res1043, var_mtype); /* Direct call abstract_compiler#AbstractCompiler#generate_init_attr on */ +} +{ +nitc___nitc__AbstractCompilerVisitor___set_finalizer(var_v, var_res1043); /* Direct call abstract_compiler#AbstractCompilerVisitor#set_finalizer on */ +} +} else { +} +if (unlikely(varonce1111==NULL)) { +var1112 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce1113!=NULL)) { +var1114 = varonce1113; +} else { +var1115 = "return "; +var1116 = core__flat___NativeString___to_s_full(var1115, 7l, 7l); +var1114 = var1116; +varonce1113 = var1114; +} +((struct instance_core__NativeArray*)var1112)->values[0]=var1114; +if (likely(varonce1117!=NULL)) { +var1118 = varonce1117; +} else { +var1119 = ";"; +var1120 = core__flat___NativeString___to_s_full(var1119, 1l, 1l); +var1118 = var1120; +varonce1117 = var1118; +} +((struct instance_core__NativeArray*)var1112)->values[2]=var1118; +} else { +var1112 = varonce1111; +varonce1111 = NULL; +} +{ +var1121 = ((val*(*)(val* self))(var_res1043->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res1043); /* to_s on */ +} +((struct instance_core__NativeArray*)var1112)->values[1]=var1121; +{ +var1122 = ((val*(*)(val* self))(var1112->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1112); /* native_to_s on */ +} +varonce1111 = var1112; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1122); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +} +if (likely(varonce1123!=NULL)) { +var1124 = varonce1123; +} else { +var1125 = "}"; +var1126 = core__flat___NativeString___to_s_full(var1125, 1l, 1l); +var1124 = var1126; +varonce1123 = var1124; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var1124); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_class_infos for (self: SeparateCompiler) */ +void nitc___nitc__SeparateCompiler___compile_class_infos(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 /* : Array[nullable MClass] */; +val* var_class_info /* var class_info: Array[nullable MClass] */; +val* var14 /* : HashMap[MClass, Int] */; +val* var16 /* : HashMap[MClass, Int] */; +val* var17 /* : RemovableCollection[nullable Object] */; +val* var_ /* var : RemovableCollection[MClass] */; +val* var18 /* : Iterator[nullable Object] */; +val* var_19 /* var : Iterator[MClass] */; +short int var20 /* : Bool */; +val* var21 /* : nullable Object */; +val* var_t /* var t: MClass */; +val* var22 /* : String */; +val* var24 /* : String */; +static val* varonce; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : String */; +short int var28 /* : Bool */; +val* var29 /* : MClassType */; +val* var31 /* : MClassType */; +val* var33 /* : String */; +val* var35 /* : String */; +static val* varonce36; +val* var37 /* : String */; +char* var38 /* : NativeString */; +val* var39 /* : String */; +short int var40 /* : Bool */; +val* var41 /* : MClassType */; +val* var43 /* : MClassType */; +val* var45 /* : String */; +val* var47 /* : String */; +static val* varonce48; +val* var49 /* : String */; +char* var50 /* : NativeString */; +val* var51 /* : String */; +short int var52 /* : Bool */; +val* var53 /* : MClassType */; +val* var55 /* : MClassType */; +val* var58 /* : MClassType */; +val* var60 /* : MClassType */; +val* var62 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +static val* varonce63; +val* var64 /* : String */; +char* var65 /* : NativeString */; +val* var66 /* : String */; +val* var_67 /* var : Array[nullable MClass] */; +val* var68 /* : IndexedIterator[nullable Object] */; +val* var_69 /* var : IndexedIterator[nullable MClass] */; +short int var70 /* : Bool */; +val* var72 /* : nullable Object */; +val* var_t73 /* var t: nullable MClass */; +short int var74 /* : Bool */; +short int var75 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var77 /* : Bool */; +short int var79 /* : Bool */; +static val* varonce80; +val* var81 /* : String */; +char* var82 /* : NativeString */; +val* var83 /* : String */; +val* var85 /* : NativeArray[String] */; +static val* varonce84; +static val* varonce86; +val* var87 /* : String */; +char* var88 /* : NativeString */; +val* var89 /* : String */; +val* var90 /* : String */; +val* var91 /* : String */; +val* var_s /* var s: String */; +val* var93 /* : NativeArray[String] */; +static val* varonce92; +static val* varonce94; +val* var95 /* : String */; +char* var96 /* : NativeString */; +val* var97 /* : String */; +static val* varonce98; +val* var99 /* : String */; +char* var100 /* : NativeString */; +val* var101 /* : String */; +val* var102 /* : String */; +static val* varonce103; +val* var104 /* : String */; +char* var105 /* : NativeString */; +val* var106 /* : String */; +static val* varonce107; +val* var108 /* : String */; +char* var109 /* : NativeString */; +val* var110 /* : String */; +val* var_111 /* var : Array[nullable MClass] */; +val* var112 /* : IndexedIterator[nullable Object] */; +val* var_113 /* var : IndexedIterator[nullable MClass] */; +short int var114 /* : Bool */; +val* var116 /* : nullable Object */; +val* var_t117 /* var t: nullable MClass */; +short int var118 /* : Bool */; +short int var119 /* : Bool */; +short int var121 /* : Bool */; +short int var123 /* : Bool */; +static val* varonce124; +val* var125 /* : String */; +char* var126 /* : NativeString */; +val* var127 /* : String */; +val* var129 /* : NativeArray[String] */; +static val* varonce128; +static val* varonce130; +val* var131 /* : String */; +char* var132 /* : NativeString */; +val* var133 /* : String */; +val* var134 /* : String */; +val* var135 /* : String */; +val* var_s136 /* var s: String */; +val* var137 /* : Set[MType] */; +val* var139 /* : Set[MType] */; +val* var140 /* : MClassType */; +val* var142 /* : MClassType */; +val* var144 /* : NativeArray[String] */; +static val* varonce143; +static val* varonce145; +val* var146 /* : String */; +char* var147 /* : NativeString */; +val* var148 /* : String */; +static val* varonce149; +val* var150 /* : String */; +char* var151 /* : NativeString */; +val* var152 /* : String */; +val* var153 /* : String */; +static val* varonce154; +val* var155 /* : String */; +char* var156 /* : NativeString */; +val* var157 /* : String */; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var2 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var) on */ +var5 = var->attrs[COLOR_nitc__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_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_no_tag_primitives (var3) on */ +var8 = var3->attrs[COLOR_nitc__separate_compiler__ToolContext___opt_no_tag_primitives].val; /* _opt_no_tag_primitives on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_tag_primitives"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 32); +fatal_exit(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 = (short int)((long)(var9)>>2); +if (var12){ +goto RET_LABEL; +} else { +} +var13 = NEW_core__Array(&type_core__Array__nullable__nitc__MClass); +{ +core___core__Array___filled_with(var13, ((val*)NULL), 4l); /* Direct call array#Array#filled_with on */ +} +var_class_info = var13; +{ +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var16 = self->attrs[COLOR_nitc__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_nitc__separate_compiler, 264); +fatal_exit(1); +} +var14 = var16; +RET_LABEL15:(void)0; +} +} +{ +var17 = core___core__HashMap___core__abstract_collection__MapRead__keys(var14); +} +var_ = var17; +{ +var18 = ((val*(*)(val* self))((((long)var_&3)?class_info[((long)var_&3)]:var_->class)->vft[COLOR_core__abstract_collection__Collection__iterator]))(var_); /* iterator on */ +} +var_19 = var18; +for(;;) { +{ +var20 = ((short int(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_19); /* is_ok on */ +} +if (var20){ +} else { +goto BREAK_label; +} +{ +var21 = ((val*(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_19); /* item on */ +} +var_t = var21; +{ +{ /* Inline model#MClass#name (var_t) on */ +var24 = var_t->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var24 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var22 = var24; +RET_LABEL23:(void)0; +} +} +if (likely(varonce!=NULL)) { +var25 = varonce; +} else { +var26 = "Int"; +var27 = core__flat___NativeString___to_s_full(var26, 3l, 3l); +var25 = var27; +varonce = var25; +} +{ +var28 = ((short int(*)(val* self, val* p0))(var22->class->vft[COLOR_core__kernel__Object___61d_61d]))(var22, var25); /* == on */ +} +if (var28){ +{ +core___core__Array___core__abstract_collection__Sequence___91d_93d_61d(var_class_info, 1l, var_t); /* Direct call array#Array#[]= on */ +} +{ +{ /* Inline model#MClass#mclass_type (var_t) on */ +var31 = var_t->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +{ +{ /* Inline separate_compiler#MType#tag_value= (var29,1l) on */ +var29->attrs[COLOR_nitc__separate_compiler__MType___tag_value].l = 1l; /* _tag_value on */ +RET_LABEL32:(void)0; +} +} +} else { +{ +{ /* Inline model#MClass#name (var_t) on */ +var35 = var_t->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var35 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var33 = var35; +RET_LABEL34:(void)0; +} +} +if (likely(varonce36!=NULL)) { +var37 = varonce36; +} else { +var38 = "Char"; +var39 = core__flat___NativeString___to_s_full(var38, 4l, 4l); +var37 = var39; +varonce36 = var37; +} +{ +var40 = ((short int(*)(val* self, val* p0))(var33->class->vft[COLOR_core__kernel__Object___61d_61d]))(var33, var37); /* == on */ +} +if (var40){ +{ +core___core__Array___core__abstract_collection__Sequence___91d_93d_61d(var_class_info, 2l, var_t); /* Direct call array#Array#[]= on */ +} +{ +{ /* Inline model#MClass#mclass_type (var_t) on */ +var43 = var_t->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var43 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var41 = var43; +RET_LABEL42:(void)0; +} +} +{ +{ /* Inline separate_compiler#MType#tag_value= (var41,2l) on */ +var41->attrs[COLOR_nitc__separate_compiler__MType___tag_value].l = 2l; /* _tag_value on */ +RET_LABEL44:(void)0; +} +} +} else { +{ +{ /* Inline model#MClass#name (var_t) on */ +var47 = var_t->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +fatal_exit(1); +} +var45 = var47; +RET_LABEL46:(void)0; +} +} +if (likely(varonce48!=NULL)) { +var49 = varonce48; +} else { +var50 = "Bool"; +var51 = core__flat___NativeString___to_s_full(var50, 4l, 4l); +var49 = var51; +varonce48 = var49; +} +{ +var52 = ((short int(*)(val* self, val* p0))(var45->class->vft[COLOR_core__kernel__Object___61d_61d]))(var45, var49); /* == on */ +} +if (var52){ +{ +core___core__Array___core__abstract_collection__Sequence___91d_93d_61d(var_class_info, 3l, var_t); /* Direct call array#Array#[]= on */ +} +{ +{ /* Inline model#MClass#mclass_type (var_t) on */ +var55 = var_t->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var55 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var53 = var55; +RET_LABEL54:(void)0; +} +} +{ +{ /* Inline separate_compiler#MType#tag_value= (var53,3l) on */ +var53->attrs[COLOR_nitc__separate_compiler__MType___tag_value].l = 3l; /* _tag_value on */ +RET_LABEL56:(void)0; +} +} +} else { +goto BREAK_label57; +} +} +} +{ +{ /* Inline model#MClass#mclass_type (var_t) on */ +var60 = var_t->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var60 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var58 = var60; +RET_LABEL59:(void)0; +} +} +{ +{ /* Inline separate_compiler#MType#is_tagged= (var58,1) on */ +var58->attrs[COLOR_nitc__separate_compiler__MType___is_tagged].s = 1; /* _is_tagged on */ +RET_LABEL61:(void)0; +} +} +BREAK_label57: (void)0; +{ +((void(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_19); /* next on */ +} +} +BREAK_label: (void)0; +{ +((void(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_19); /* finish on */ +} +{ +var62 = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var62; +if (likely(varonce63!=NULL)) { +var64 = varonce63; +} else { +var65 = "const struct class *class_info[4] = {"; +var66 = core__flat___NativeString___to_s_full(var65, 37l, 37l); +var64 = var66; +varonce63 = var64; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var64); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +var_67 = var_class_info; +{ +var68 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_67); +} +var_69 = var68; +for(;;) { +{ +var70 = ((short int(*)(val* self))((((long)var_69&3)?class_info[((long)var_69&3)]:var_69->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_69); /* is_ok on */ +} +if (var70){ +} else { +goto BREAK_label71; +} +{ +var72 = ((val*(*)(val* self))((((long)var_69&3)?class_info[((long)var_69&3)]:var_69->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_69); /* item on */ +} +var_t73 = var72; +if (var_t73 == NULL) { +var74 = 1; /* is null */ +} else { +var74 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t73,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_t73,var_other) on */ +var79 = var_t73 == var_other; +var77 = var79; +goto RET_LABEL78; +RET_LABEL78:(void)0; +} +} +var75 = var77; +goto RET_LABEL76; +RET_LABEL76:(void)0; +} +var74 = var75; +} +if (var74){ +if (likely(varonce80!=NULL)) { +var81 = varonce80; +} else { +var82 = "NULL,"; +var83 = core__flat___NativeString___to_s_full(var82, 5l, 5l); +var81 = var83; +varonce80 = var81; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var81); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (unlikely(varonce84==NULL)) { +var85 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce86!=NULL)) { +var87 = varonce86; +} else { +var88 = "class_"; +var89 = core__flat___NativeString___to_s_full(var88, 6l, 6l); +var87 = var89; +varonce86 = var87; +} +((struct instance_core__NativeArray*)var85)->values[0]=var87; +} else { +var85 = varonce84; +varonce84 = NULL; +} +{ +var90 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_t73); +} +((struct instance_core__NativeArray*)var85)->values[1]=var90; +{ +var91 = ((val*(*)(val* self))(var85->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var85); /* native_to_s on */ +} +varonce84 = var85; +var_s = var91; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var_s); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce92==NULL)) { +var93 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce94!=NULL)) { +var95 = varonce94; +} else { +var96 = "&"; +var97 = core__flat___NativeString___to_s_full(var96, 1l, 1l); +var95 = var97; +varonce94 = var95; +} +((struct instance_core__NativeArray*)var93)->values[0]=var95; +if (likely(varonce98!=NULL)) { +var99 = varonce98; +} else { +var100 = ","; +var101 = core__flat___NativeString___to_s_full(var100, 1l, 1l); +var99 = var101; +varonce98 = var99; +} +((struct instance_core__NativeArray*)var93)->values[2]=var99; +} else { +var93 = varonce92; +varonce92 = NULL; +} +((struct instance_core__NativeArray*)var93)->values[1]=var_s; +{ +var102 = ((val*(*)(val* self))(var93->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var93); /* native_to_s on */ +} +varonce92 = var93; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var102); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +{ +((void(*)(val* self))((((long)var_69&3)?class_info[((long)var_69&3)]:var_69->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_69); /* next on */ +} +} +BREAK_label71: (void)0; +{ +((void(*)(val* self))((((long)var_69&3)?class_info[((long)var_69&3)]:var_69->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_69); /* finish on */ +} +if (likely(varonce103!=NULL)) { +var104 = varonce103; +} else { +var105 = "};"; +var106 = core__flat___NativeString___to_s_full(var105, 2l, 2l); +var104 = var106; +varonce103 = var104; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var104); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce107!=NULL)) { +var108 = varonce107; +} else { +var109 = "const struct type *type_info[4] = {"; +var110 = core__flat___NativeString___to_s_full(var109, 35l, 35l); +var108 = var110; +varonce107 = var108; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var108); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +var_111 = var_class_info; +{ +var112 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_111); +} +var_113 = var112; +for(;;) { +{ +var114 = ((short int(*)(val* self))((((long)var_113&3)?class_info[((long)var_113&3)]:var_113->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_113); /* is_ok on */ +} +if (var114){ +} else { +goto BREAK_label115; +} +{ +var116 = ((val*(*)(val* self))((((long)var_113&3)?class_info[((long)var_113&3)]:var_113->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_113); /* item on */ +} +var_t117 = var116; +if (var_t117 == NULL) { +var118 = 1; /* is null */ +} else { +var118 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t117,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_t117,var_other) on */ +var123 = var_t117 == var_other; +var121 = var123; +goto RET_LABEL122; +RET_LABEL122:(void)0; +} +} +var119 = var121; +goto RET_LABEL120; +RET_LABEL120:(void)0; +} +var118 = var119; +} +if (var118){ +if (likely(varonce124!=NULL)) { +var125 = varonce124; +} else { +var126 = "NULL,"; +var127 = core__flat___NativeString___to_s_full(var126, 5l, 5l); +var125 = var127; +varonce124 = var125; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var125); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (unlikely(varonce128==NULL)) { +var129 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce130!=NULL)) { +var131 = varonce130; +} else { +var132 = "type_"; +var133 = core__flat___NativeString___to_s_full(var132, 5l, 5l); +var131 = var133; +varonce130 = var131; +} +((struct instance_core__NativeArray*)var129)->values[0]=var131; +} else { +var129 = varonce128; +varonce128 = NULL; +} +{ +var134 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_t117); +} +((struct instance_core__NativeArray*)var129)->values[1]=var134; +{ +var135 = ((val*(*)(val* self))(var129->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var129); /* native_to_s on */ +} +varonce128 = var129; +var_s136 = var135; +{ +{ /* Inline separate_compiler#SeparateCompiler#undead_types (self) on */ +var139 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var139 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 146); +fatal_exit(1); +} +var137 = var139; +RET_LABEL138:(void)0; +} +} +{ +{ /* Inline model#MClass#mclass_type (var_t117) on */ +var142 = var_t117->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var142 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var140 = var142; +RET_LABEL141:(void)0; +} +} +{ +((void(*)(val* self, val* p0))((((long)var137&3)?class_info[((long)var137&3)]:var137->class)->vft[COLOR_core__abstract_collection__SimpleCollection__add]))(var137, var140); /* add on */ +} +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(var_v, var_s136); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce143==NULL)) { +var144 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce145!=NULL)) { +var146 = varonce145; +} else { +var147 = "&"; +var148 = core__flat___NativeString___to_s_full(var147, 1l, 1l); +var146 = var148; +varonce145 = var146; +} +((struct instance_core__NativeArray*)var144)->values[0]=var146; +if (likely(varonce149!=NULL)) { +var150 = varonce149; +} else { +var151 = ","; +var152 = core__flat___NativeString___to_s_full(var151, 1l, 1l); +var150 = var152; +varonce149 = var150; +} +((struct instance_core__NativeArray*)var144)->values[2]=var150; +} else { +var144 = varonce143; +varonce143 = NULL; +} +((struct instance_core__NativeArray*)var144)->values[1]=var_s136; +{ +var153 = ((val*(*)(val* self))(var144->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var144); /* native_to_s on */ +} +varonce143 = var144; +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var153); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +{ +((void(*)(val* self))((((long)var_113&3)?class_info[((long)var_113&3)]:var_113->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_113); /* next on */ +} +} +BREAK_label115: (void)0; +{ +((void(*)(val* self))((((long)var_113&3)?class_info[((long)var_113&3)]:var_113->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_113); /* finish on */ +} +if (likely(varonce154!=NULL)) { +var155 = varonce154; +} else { +var156 = "};"; +var157 = core__flat___NativeString___to_s_full(var156, 2l, 2l); +var155 = var157; +varonce154 = var155; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_decl(var_v, var155); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#hardening_live_type for (self: SeparateCompiler, SeparateCompilerVisitor, String) */ +void nitc___nitc__SeparateCompiler___hardening_live_type(val* self, val* p0, val* p1) { +short int var /* : Bool */; +int cltype; +int idtype; +const struct type* type_struct; +const char* var_class_name; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var_t /* var t: String */; +val* var1 /* : AbstractCompiler */; +val* var3 /* : AbstractCompiler */; +val* var4 /* : ModelBuilder */; +val* var6 /* : ModelBuilder */; +val* var7 /* : ToolContext */; +val* var9 /* : ToolContext */; +val* var10 /* : OptionBool */; +val* var12 /* : OptionBool */; +val* var13 /* : nullable Object */; +val* var15 /* : nullable Object */; +short int var16 /* : Bool */; +short int var17 /* : Bool */; +val* var18 /* : NativeArray[String] */; +static val* varonce; +static val* varonce19; +val* var20 /* : String */; +char* var21 /* : NativeString */; +val* var22 /* : String */; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +val* var26 /* : String */; +val* var27 /* : String */; +static val* varonce28; +val* var29 /* : String */; +char* var30 /* : NativeString */; +val* var31 /* : String */; +static val* varonce32; +val* var33 /* : String */; +char* var34 /* : NativeString */; +val* var35 /* : String */; +val* var37 /* : NativeArray[String] */; +static val* varonce36; +static val* varonce38; +val* var39 /* : String */; +char* var40 /* : NativeString */; +val* var41 /* : String */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +val* var45 /* : String */; +val* var46 /* : String */; +val* var48 /* : NativeArray[String] */; +static val* varonce47; +static val* varonce49; +val* var50 /* : String */; +char* var51 /* : NativeString */; +val* var52 /* : String */; +static val* varonce53; +val* var54 /* : String */; +char* var55 /* : NativeString */; +val* var56 /* : String */; +val* var57 /* : String */; +static val* varonce58; +val* var59 /* : String */; +char* var60 /* : NativeString */; +val* var61 /* : String */; +static val* varonce62; +val* var63 /* : String */; +char* var64 /* : NativeString */; +val* var65 /* : String */; +/* Covariant cast for argument 0 (v) isa VISITOR */ +/* isa VISITOR */ +type_struct = self->type->resolution_table->types[COLOR_nitc__abstract_compiler__AbstractCompiler__VISITOR]; +cltype = type_struct->color; +idtype = type_struct->id; +if(cltype >= p0->type->table_size) { +var = 0; +} else { +var = p0->type->type_table[cltype] == idtype; +} +if (unlikely(!var)) { +var_class_name = p0 == NULL ? "null" : p0->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1048); +fatal_exit(1); +} +var_v = p0; +var_t = p1; +{ +{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ +var3 = var_v->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var3 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +fatal_exit(1); +} +var1 = var3; +RET_LABEL2:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var1) on */ +var6 = var1->attrs[COLOR_nitc__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_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var4 = var6; +RET_LABEL5:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var4) on */ +var9 = var4->attrs[COLOR_nitc__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_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} +} +{ +{ /* Inline abstract_compiler#ToolContext#opt_hardening (var7) on */ +var12 = var7->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_hardening].val; /* _opt_hardening on */ +if (unlikely(var12 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_hardening"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 46); +fatal_exit(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var10) on */ +var15 = var10->attrs[COLOR_opts__Option___value].val; /* _value on */ +var13 = var15; +RET_LABEL14:(void)0; +} +} +var16 = (short int)((long)(var13)>>2); +var17 = !var16; +if (var17){ +goto RET_LABEL; +} else { +} +if (unlikely(varonce==NULL)) { +var18 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce19!=NULL)) { +var20 = varonce19; +} else { +var21 = "if("; +var22 = core__flat___NativeString___to_s_full(var21, 3l, 3l); +var20 = var22; +varonce19 = var20; +} +((struct instance_core__NativeArray*)var18)->values[0]=var20; +if (likely(varonce23!=NULL)) { +var24 = varonce23; +} else { +var25 = " == NULL) {"; +var26 = core__flat___NativeString___to_s_full(var25, 11l, 11l); +var24 = var26; +varonce23 = var24; +} +((struct instance_core__NativeArray*)var18)->values[2]=var24; +} else { +var18 = varonce; +varonce = NULL; +} +((struct instance_core__NativeArray*)var18)->values[1]=var_t; +{ +var27 = ((val*(*)(val* self))(var18->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var18); /* native_to_s on */ +} +varonce = var18; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var27); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce28!=NULL)) { +var29 = varonce28; +} else { +var30 = "type null"; +var31 = core__flat___NativeString___to_s_full(var30, 9l, 9l); +var29 = var31; +varonce28 = var29; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(var_v, var29); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +if (likely(varonce32!=NULL)) { +var33 = varonce32; +} else { +var34 = "}"; +var35 = core__flat___NativeString___to_s_full(var34, 1l, 1l); +var33 = var35; +varonce32 = var33; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var33); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce36==NULL)) { +var37 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce38!=NULL)) { +var39 = varonce38; +} else { +var40 = "if("; +var41 = core__flat___NativeString___to_s_full(var40, 3l, 3l); +var39 = var41; +varonce38 = var39; +} +((struct instance_core__NativeArray*)var37)->values[0]=var39; +if (likely(varonce42!=NULL)) { +var43 = varonce42; +} else { +var44 = "->table_size < 0) {"; +var45 = core__flat___NativeString___to_s_full(var44, 19l, 19l); +var43 = var45; +varonce42 = var43; +} +((struct instance_core__NativeArray*)var37)->values[2]=var43; +} else { +var37 = varonce36; +varonce36 = NULL; +} +((struct instance_core__NativeArray*)var37)->values[1]=var_t; +{ +var46 = ((val*(*)(val* self))(var37->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var37); /* native_to_s on */ +} +varonce36 = var37; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var46); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce47==NULL)) { +var48 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); +if (likely(varonce49!=NULL)) { +var50 = varonce49; +} else { +var51 = "PRINT_ERROR(\"Instantiation of a dead type: %s\\n\", "; +var52 = core__flat___NativeString___to_s_full(var51, 50l, 50l); +var50 = var52; +varonce49 = var50; +} +((struct instance_core__NativeArray*)var48)->values[0]=var50; +if (likely(varonce53!=NULL)) { +var54 = varonce53; +} else { +var55 = "->name);"; +var56 = core__flat___NativeString___to_s_full(var55, 8l, 8l); +var54 = var56; +varonce53 = var54; +} +((struct instance_core__NativeArray*)var48)->values[2]=var54; +} else { +var48 = varonce47; +varonce47 = NULL; +} +((struct instance_core__NativeArray*)var48)->values[1]=var_t; +{ +var57 = ((val*(*)(val* self))(var48->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var48); /* native_to_s on */ +} +varonce47 = var48; +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var57); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce58!=NULL)) { +var59 = varonce58; +} else { +var60 = "type dead"; +var61 = core__flat___NativeString___to_s_full(var60, 9l, 9l); +var59 = var61; +varonce58 = var59; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(var_v, var59); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +if (likely(varonce62!=NULL)) { +var63 = varonce62; +} else { +var64 = "}"; +var65 = core__flat___NativeString___to_s_full(var64, 1l, 1l); +var63 = var65; +varonce62 = var63; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(var_v, var63); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#new_visitor for (self: SeparateCompiler): SeparateCompilerVisitor */ +val* nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__new_visitor(val* self) { +val* var /* : SeparateCompilerVisitor */; +val* var1 /* : SeparateCompilerVisitor */; +short int var2 /* : Bool */; +int cltype; +int idtype; +const struct type* type_struct; +const char* var_class_name; +var1 = NEW_nitc__SeparateCompilerVisitor(&type_nitc__SeparateCompilerVisitor); +{ +((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor__compiler_61d]))(var1, self); /* compiler= on */ +} +{ +((void(*)(val* self))(var1->class->vft[COLOR_core__kernel__Object__init]))(var1); /* init on */ +} +/* isa VISITOR */ +type_struct = self->type->resolution_table->types[COLOR_nitc__abstract_compiler__AbstractCompiler__VISITOR]; +cltype = type_struct->color; +idtype = type_struct->id; +if(cltype >= var1->type->table_size) { +var2 = 0; +} else { +var2 = var1->type->type_table[cltype] == idtype; +} +if (unlikely(!var2)) { +var_class_name = var1 == NULL ? "null" : var1->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1061); +fatal_exit(1); +} +var = var1; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_tables for (self: SeparateCompiler): Map[MType, Array[nullable MType]] */ +val* nitc___nitc__SeparateCompiler___type_tables(val* self) { +val* var /* : Map[MType, Array[nullable MType]] */; +val* var1 /* : Map[MType, Array[nullable MType]] */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1065); +fatal_exit(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_tables= for (self: SeparateCompiler, Map[MType, Array[nullable MType]]) */ +void nitc___nitc__SeparateCompiler___type_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___type_tables].val = p0; /* _type_tables on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#resolution_tables for (self: SeparateCompiler): Map[MClassType, Array[nullable MType]] */ +val* nitc___nitc__SeparateCompiler___resolution_tables(val* self) { +val* var /* : Map[MClassType, Array[nullable MType]] */; +val* var1 /* : Map[MClassType, Array[nullable MType]] */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1066); +fatal_exit(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#resolution_tables= for (self: SeparateCompiler, Map[MClassType, Array[nullable MType]]) */ +void nitc___nitc__SeparateCompiler___resolution_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___resolution_tables].val = p0; /* _resolution_tables on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#method_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MPropDef]] */ +val* nitc___nitc__SeparateCompiler___method_tables(val* self) { +val* var /* : Map[MClass, Array[nullable MPropDef]] */; +val* var1 /* : Map[MClass, Array[nullable MPropDef]] */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1067); +fatal_exit(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#method_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MPropDef]]) */ +void nitc___nitc__SeparateCompiler___method_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___method_tables].val = p0; /* _method_tables on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#attr_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MProperty]] */ +val* nitc___nitc__SeparateCompiler___attr_tables(val* self) { +val* var /* : Map[MClass, Array[nullable MProperty]] */; +val* var1 /* : Map[MClass, Array[nullable MProperty]] */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1068); +fatal_exit(1); +} +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#attr_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MProperty]]) */ +void nitc___nitc__SeparateCompiler___attr_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_tables].val = p0; /* _attr_tables on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#display_stats for (self: SeparateCompiler) */ +void nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__display_stats(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 /* : ModelBuilder */; +val* var15 /* : ModelBuilder */; +val* var16 /* : ToolContext */; +val* var18 /* : ToolContext */; +val* var19 /* : OptionBool */; +val* var21 /* : OptionBool */; +val* var22 /* : nullable Object */; +val* var24 /* : nullable Object */; +short int var25 /* : Bool */; +val* var26 /* : ModelBuilder */; +val* var28 /* : ModelBuilder */; +val* var29 /* : ToolContext */; +val* var31 /* : ToolContext */; +val* var_tc /* var tc: ToolContext */; +static val* varonce; +val* var32 /* : String */; +char* var33 /* : NativeString */; +val* var34 /* : String */; +val* var35 /* : ModelBuilder */; +val* var37 /* : ModelBuilder */; +long var38 /* : Int */; +long var40 /* : Int */; +val* var41 /* : ModelBuilder */; +val* var43 /* : ModelBuilder */; +long var44 /* : Int */; +long var46 /* : Int */; +long var47 /* : Int */; +short int var49 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var50 /* : Int */; +val* var51 /* : ModelBuilder */; +val* var53 /* : ModelBuilder */; +long var54 /* : Int */; +long var56 /* : Int */; +long var57 /* : Int */; +short int var59 /* : Bool */; +int cltype60; +int idtype61; +const char* var_class_name62; +long var63 /* : Int */; +long var_nb_invok_total /* var nb_invok_total: Int */; +val* var65 /* : NativeArray[String] */; +static val* varonce64; +static val* varonce66; +val* var67 /* : String */; +char* var68 /* : NativeString */; +val* var69 /* : String */; +val* var70 /* : String */; +val* var71 /* : String */; +val* var73 /* : NativeArray[String] */; +static val* varonce72; +static val* varonce74; +val* var75 /* : String */; +char* var76 /* : NativeString */; +val* var77 /* : String */; +static val* varonce78; +val* var79 /* : String */; +char* var80 /* : NativeString */; +val* var81 /* : String */; +static val* varonce82; +val* var83 /* : String */; +char* var84 /* : NativeString */; +val* var85 /* : String */; +val* var86 /* : ModelBuilder */; +val* var88 /* : ModelBuilder */; +long var89 /* : Int */; +long var91 /* : Int */; +val* var92 /* : String */; +val* var93 /* : Sys */; +val* var94 /* : ModelBuilder */; +val* var96 /* : ModelBuilder */; +long var97 /* : Int */; +long var99 /* : Int */; +val* var100 /* : String */; +val* var101 /* : String */; +val* var103 /* : NativeArray[String] */; +static val* varonce102; +static val* varonce104; +val* var105 /* : String */; +char* var106 /* : NativeString */; +val* var107 /* : String */; +static val* varonce108; +val* var109 /* : String */; +char* var110 /* : NativeString */; +val* var111 /* : String */; +static val* varonce112; +val* var113 /* : String */; +char* var114 /* : NativeString */; +val* var115 /* : String */; +val* var116 /* : ModelBuilder */; +val* var118 /* : ModelBuilder */; +long var119 /* : Int */; +long var121 /* : Int */; +val* var122 /* : String */; +val* var123 /* : Sys */; +val* var124 /* : ModelBuilder */; +val* var126 /* : ModelBuilder */; +long var127 /* : Int */; +long var129 /* : Int */; +val* var130 /* : String */; +val* var131 /* : String */; +val* var133 /* : NativeArray[String] */; +static val* varonce132; +static val* varonce134; +val* var135 /* : String */; +char* var136 /* : NativeString */; +val* var137 /* : String */; +static val* varonce138; +val* var139 /* : String */; +char* var140 /* : NativeString */; +val* var141 /* : String */; +static val* varonce142; +val* var143 /* : String */; +char* var144 /* : NativeString */; +val* var145 /* : String */; +val* var146 /* : ModelBuilder */; +val* var148 /* : ModelBuilder */; +long var149 /* : Int */; +long var151 /* : Int */; +val* var152 /* : String */; +val* var153 /* : Sys */; +val* var154 /* : ModelBuilder */; +val* var156 /* : ModelBuilder */; +long var157 /* : Int */; +long var159 /* : Int */; +val* var160 /* : String */; +val* var161 /* : String */; +{ +((void(*)(val* self))(self->class->vft[COLOR_nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__display_stats]))(self); /* display_stats on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var2 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var) on */ +var5 = var->attrs[COLOR_nitc__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_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline separate_compiler#ToolContext#opt_tables_metrics (var3) on */ +var8 = var3->attrs[COLOR_nitc__separate_compiler__ToolContext___opt_tables_metrics].val; /* _opt_tables_metrics on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_tables_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 60); +fatal_exit(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 = (short int)((long)(var9)>>2); +if (var12){ +{ +((void(*)(val* self))(self->class->vft[COLOR_nitc__separate_compiler__SeparateCompiler__display_sizes]))(self); /* display_sizes on */ +} +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var15 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var15 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var13 = var15; +RET_LABEL14:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var13) on */ +var18 = var13->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var18 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var16 = var18; +RET_LABEL17:(void)0; +} +} +{ +{ /* Inline abstract_compiler#ToolContext#opt_isset_checks_metrics (var16) on */ +var21 = var16->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_isset_checks_metrics].val; /* _opt_isset_checks_metrics on */ +if (unlikely(var21 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_isset_checks_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 64); +fatal_exit(1); +} +var19 = var21; +RET_LABEL20:(void)0; +} +} +{ +{ /* Inline opts#Option#value (var19) on */ +var24 = var19->attrs[COLOR_opts__Option___value].val; /* _value on */ +var22 = var24; +RET_LABEL23:(void)0; +} +} +var25 = (short int)((long)(var22)>>2); +if (var25){ +{ +nitc___nitc__SeparateCompiler___display_isset_checks(self); /* Direct call separate_compiler#SeparateCompiler#display_isset_checks on */ +} +} else { +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var28 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var26 = var28; +RET_LABEL27:(void)0; +} +} +{ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var26) on */ +var31 = var26->attrs[COLOR_nitc__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_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +var_tc = var29; +if (likely(varonce!=NULL)) { +var32 = varonce; +} else { +var33 = "# implementation of method invocation"; +var34 = core__flat___NativeString___to_s_full(var33, 37l, 37l); +var32 = var34; +varonce = var32; +} +{ +nitc___nitc__ToolContext___info(var_tc, var32, 2l); /* Direct call toolcontext#ToolContext#info on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var37 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var35 = var37; +RET_LABEL36:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var35) on */ +var40 = var35->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var38 = var40; +RET_LABEL39:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var43 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var43 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var41 = var43; +RET_LABEL42:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var41) on */ +var46 = var41->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var44 = var46; +RET_LABEL45:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var38,var44) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var49 = 1; /* easy isa OTHER*/ +if (unlikely(!var49)) { +var_class_name = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var50 = var38 + var44; +var47 = var50; +goto RET_LABEL48; +RET_LABEL48:(void)0; +} +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var53 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var53 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var51 = var53; +RET_LABEL52:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var51) on */ +var56 = var51->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var54 = var56; +RET_LABEL55:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var47,var54) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var59 = 1; /* easy isa OTHER*/ +if (unlikely(!var59)) { +var_class_name62 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name62); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var63 = var47 + var54; +var57 = var63; +goto RET_LABEL58; +RET_LABEL58:(void)0; +} +} +var_nb_invok_total = var57; +if (unlikely(varonce64==NULL)) { +var65 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce66!=NULL)) { +var67 = varonce66; +} else { +var68 = "total number of invocations: "; +var69 = core__flat___NativeString___to_s_full(var68, 29l, 29l); +var67 = var69; +varonce66 = var67; +} +((struct instance_core__NativeArray*)var65)->values[0]=var67; +} else { +var65 = varonce64; +varonce64 = NULL; +} +var70 = core__flat___Int___core__abstract_text__Object__to_s(var_nb_invok_total); +((struct instance_core__NativeArray*)var65)->values[1]=var70; +{ +var71 = ((val*(*)(val* self))(var65->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var65); /* native_to_s on */ +} +varonce64 = var65; +{ +nitc___nitc__ToolContext___info(var_tc, var71, 2l); /* Direct call toolcontext#ToolContext#info on */ +} +if (unlikely(varonce72==NULL)) { +var73 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce74!=NULL)) { +var75 = varonce74; +} else { +var76 = "invocations by VFT send: "; +var77 = core__flat___NativeString___to_s_full(var76, 29l, 29l); +var75 = var77; +varonce74 = var75; +} +((struct instance_core__NativeArray*)var73)->values[0]=var75; +if (likely(varonce78!=NULL)) { +var79 = varonce78; +} else { +var80 = " ("; +var81 = core__flat___NativeString___to_s_full(var80, 2l, 2l); +var79 = var81; +varonce78 = var79; +} +((struct instance_core__NativeArray*)var73)->values[2]=var79; +if (likely(varonce82!=NULL)) { +var83 = varonce82; +} else { +var84 = "%)"; +var85 = core__flat___NativeString___to_s_full(var84, 2l, 2l); +var83 = var85; +varonce82 = var83; +} +((struct instance_core__NativeArray*)var73)->values[4]=var83; +} else { +var73 = varonce72; +varonce72 = NULL; +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var88 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var88 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var86 = var88; +RET_LABEL87:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var86) on */ +var91 = var86->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var89 = var91; +RET_LABEL90:(void)0; +} +} +var92 = core__flat___Int___core__abstract_text__Object__to_s(var89); +((struct instance_core__NativeArray*)var73)->values[1]=var92; +var93 = glob_sys; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var96 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var96 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var94 = var96; +RET_LABEL95:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var94) on */ +var99 = var94->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var97 = var99; +RET_LABEL98:(void)0; +} +} +{ +var100 = counter___core__Sys___div(var93, var97, var_nb_invok_total); +} +((struct instance_core__NativeArray*)var73)->values[3]=var100; +{ +var101 = ((val*(*)(val* self))(var73->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var73); /* native_to_s on */ +} +varonce72 = var73; +{ +nitc___nitc__ToolContext___info(var_tc, var101, 2l); /* Direct call toolcontext#ToolContext#info on */ +} +if (unlikely(varonce102==NULL)) { +var103 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce104!=NULL)) { +var105 = varonce104; +} else { +var106 = "invocations by direct call: "; +var107 = core__flat___NativeString___to_s_full(var106, 29l, 29l); +var105 = var107; +varonce104 = var105; +} +((struct instance_core__NativeArray*)var103)->values[0]=var105; +if (likely(varonce108!=NULL)) { +var109 = varonce108; +} else { +var110 = " ("; +var111 = core__flat___NativeString___to_s_full(var110, 2l, 2l); +var109 = var111; +varonce108 = var109; +} +((struct instance_core__NativeArray*)var103)->values[2]=var109; +if (likely(varonce112!=NULL)) { +var113 = varonce112; +} else { +var114 = "%)"; +var115 = core__flat___NativeString___to_s_full(var114, 2l, 2l); +var113 = var115; +varonce112 = var113; +} +((struct instance_core__NativeArray*)var103)->values[4]=var113; +} else { +var103 = varonce102; +varonce102 = NULL; +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var118 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var118 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var116 = var118; +RET_LABEL117:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var116) on */ +var121 = var116->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var119 = var121; +RET_LABEL120:(void)0; +} +} +var122 = core__flat___Int___core__abstract_text__Object__to_s(var119); +((struct instance_core__NativeArray*)var103)->values[1]=var122; +var123 = glob_sys; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var126 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var126 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var124 = var126; +RET_LABEL125:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var124) on */ +var129 = var124->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var127 = var129; +RET_LABEL128:(void)0; +} +} +{ +var130 = counter___core__Sys___div(var123, var127, var_nb_invok_total); +} +((struct instance_core__NativeArray*)var103)->values[3]=var130; +{ +var131 = ((val*(*)(val* self))(var103->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var103); /* native_to_s on */ +} +varonce102 = var103; +{ +nitc___nitc__ToolContext___info(var_tc, var131, 2l); /* Direct call toolcontext#ToolContext#info on */ +} +if (unlikely(varonce132==NULL)) { +var133 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +if (likely(varonce134!=NULL)) { +var135 = varonce134; +} else { +var136 = "invocations by inlining: "; +var137 = core__flat___NativeString___to_s_full(var136, 29l, 29l); +var135 = var137; +varonce134 = var135; +} +((struct instance_core__NativeArray*)var133)->values[0]=var135; +if (likely(varonce138!=NULL)) { +var139 = varonce138; +} else { +var140 = " ("; +var141 = core__flat___NativeString___to_s_full(var140, 2l, 2l); +var139 = var141; +varonce138 = var139; +} +((struct instance_core__NativeArray*)var133)->values[2]=var139; +if (likely(varonce142!=NULL)) { +var143 = varonce142; +} else { +var144 = "%)"; +var145 = core__flat___NativeString___to_s_full(var144, 2l, 2l); +var143 = var145; +varonce142 = var143; +} +((struct instance_core__NativeArray*)var133)->values[4]=var143; +} else { +var133 = varonce132; +varonce132 = NULL; +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var148 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var148 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var146 = var148; +RET_LABEL147:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var146) on */ +var151 = var146->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var149 = var151; +RET_LABEL150:(void)0; +} +} +var152 = core__flat___Int___core__abstract_text__Object__to_s(var149); +((struct instance_core__NativeArray*)var133)->values[1]=var152; +var153 = glob_sys; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var156 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var156 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +fatal_exit(1); +} +var154 = var156; +RET_LABEL155:(void)0; +} +} +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var154) on */ +var159 = var154->attrs[COLOR_nitc__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var157 = var159; +RET_LABEL158:(void)0; +} +} +{ +var160 = counter___core__Sys___div(var153, var157, var_nb_invok_total); +} +((struct instance_core__NativeArray*)var133)->values[3]=var160; +{ +var161 = ((val*(*)(val* self))(var133->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var133); /* native_to_s on */ +} +varonce132 = var133; +{ +nitc___nitc__ToolContext___info(var_tc, var161, 2l); /* Direct call toolcontext#ToolContext#info on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#display_sizes for (self: SeparateCompiler) */ +void nitc___nitc__SeparateCompiler___display_sizes(val* self) { +val* var /* : Sys */; +static val* varonce; +val* var1 /* : String */; +char* var2 /* : NativeString */; +val* var3 /* : String */; +val* var4 /* : Sys */; +static val* varonce5; +val* var6 /* : String */; +char* var7 /* : NativeString */; +val* var8 /* : String */; +long var_total /* var total: Int */; +long var_holes /* var holes: Int */; +val* var9 /* : Map[MType, Array[nullable MType]] */; +val* var11 /* : Map[MType, Array[nullable MType]] */; +val* var_ /* var : Map[MType, Array[nullable MType]] */; +val* var12 /* : MapIterator[nullable Object, nullable Object] */; +val* var_13 /* var : MapIterator[MType, Array[nullable MType]] */; +short int var14 /* : Bool */; +val* var15 /* : nullable Object */; +val* var_t /* var t: MType */; +val* var16 /* : nullable Object */; +val* var_table /* var table: Array[nullable MType] */; +long var17 /* : Int */; +long var19 /* : Int */; +long var20 /* : Int */; +short int var22 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var23 /* : Int */; +val* var_24 /* var : Array[nullable MType] */; +val* var25 /* : IndexedIterator[nullable Object] */; +val* var_26 /* var : IndexedIterator[nullable MType] */; +short int var27 /* : Bool */; +val* var29 /* : nullable Object */; +val* var_e /* var e: nullable MType */; +short int var30 /* : Bool */; +short int var31 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var33 /* : Bool */; +short int var35 /* : Bool */; +long var36 /* : Int */; +short int var38 /* : Bool */; +int cltype39; +int idtype40; +const char* var_class_name41; +long var42 /* : Int */; +val* var44 /* : Sys */; +val* var46 /* : NativeArray[String] */; +static val* varonce45; +static val* varonce47; +val* var48 /* : String */; +char* var49 /* : NativeString */; +val* var50 /* : String */; +static val* varonce51; +val* var52 /* : String */; +char* var53 /* : NativeString */; +val* var54 /* : String */; +val* var55 /* : String */; +val* var56 /* : String */; +val* var57 /* : String */; +val* var58 /* : Sys */; +static val* varonce59; +val* var60 /* : String */; +char* var61 /* : NativeString */; +val* var62 /* : String */; +val* var63 /* : Sys */; +static val* varonce64; +val* var65 /* : String */; +char* var66 /* : NativeString */; +val* var67 /* : String */; +val* var68 /* : Map[MClassType, Array[nullable MType]] */; +val* var70 /* : Map[MClassType, Array[nullable MType]] */; +val* var_71 /* var : Map[MClassType, Array[nullable MType]] */; +val* var72 /* : MapIterator[nullable Object, nullable Object] */; +val* var_73 /* var : MapIterator[MClassType, Array[nullable MType]] */; +short int var74 /* : Bool */; +val* var76 /* : nullable Object */; +val* var_t77 /* var t: MClassType */; +val* var78 /* : nullable Object */; +val* var_table79 /* var table: Array[nullable MType] */; +long var80 /* : Int */; +long var82 /* : Int */; +long var83 /* : Int */; +short int var85 /* : Bool */; +int cltype86; +int idtype87; +const char* var_class_name88; +long var89 /* : Int */; +val* var_90 /* var : Array[nullable MType] */; +val* var91 /* : IndexedIterator[nullable Object] */; +val* var_92 /* var : IndexedIterator[nullable MType] */; +short int var93 /* : Bool */; +val* var95 /* : nullable Object */; +val* var_e96 /* var e: nullable MType */; +short int var97 /* : Bool */; +short int var98 /* : Bool */; +short int var100 /* : Bool */; +short int var102 /* : Bool */; +long var103 /* : Int */; +short int var105 /* : Bool */; +int cltype106; +int idtype107; +const char* var_class_name108; +long var109 /* : Int */; +val* var111 /* : Sys */; +val* var113 /* : NativeArray[String] */; +static val* varonce112; +static val* varonce114; +val* var115 /* : String */; +char* var116 /* : NativeString */; +val* var117 /* : String */; +static val* varonce118; +val* var119 /* : String */; +char* var120 /* : NativeString */; +val* var121 /* : String */; +val* var122 /* : String */; +val* var123 /* : String */; +val* var124 /* : String */; +val* var125 /* : Sys */; +static val* varonce126; +val* var127 /* : String */; +char* var128 /* : NativeString */; +val* var129 /* : String */; +val* var130 /* : Sys */; +static val* varonce131; +val* var132 /* : String */; +char* var133 /* : NativeString */; +val* var134 /* : String */; +val* var135 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var137 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_138 /* var : Map[MClass, Array[nullable MPropDef]] */; +val* var139 /* : MapIterator[nullable Object, nullable Object] */; +val* var_140 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; +short int var141 /* : Bool */; +val* var143 /* : nullable Object */; +val* var_t144 /* var t: MClass */; +val* var145 /* : nullable Object */; +val* var_table146 /* var table: Array[nullable MPropDef] */; +long var147 /* : Int */; +long var149 /* : Int */; +long var150 /* : Int */; +short int var152 /* : Bool */; +int cltype153; +int idtype154; +const char* var_class_name155; +long var156 /* : Int */; +val* var_157 /* var : Array[nullable MPropDef] */; +val* var158 /* : IndexedIterator[nullable Object] */; +val* var_159 /* var : IndexedIterator[nullable MPropDef] */; +short int var160 /* : Bool */; +val* var162 /* : nullable Object */; +val* var_e163 /* var e: nullable MPropDef */; +short int var164 /* : Bool */; +short int var165 /* : Bool */; +short int var167 /* : Bool */; +short int var169 /* : Bool */; +long var170 /* : Int */; +short int var172 /* : Bool */; +int cltype173; +int idtype174; +const char* var_class_name175; +long var176 /* : Int */; +val* var178 /* : Sys */; +val* var180 /* : NativeArray[String] */; +static val* varonce179; +static val* varonce181; +val* var182 /* : String */; +char* var183 /* : NativeString */; +val* var184 /* : String */; +static val* varonce185; +val* var186 /* : String */; +char* var187 /* : NativeString */; +val* var188 /* : String */; +val* var189 /* : String */; +val* var190 /* : String */; +val* var191 /* : String */; +val* var192 /* : Sys */; +static val* varonce193; +val* var194 /* : String */; +char* var195 /* : NativeString */; +val* var196 /* : String */; +val* var197 /* : Sys */; +static val* varonce198; +val* var199 /* : String */; +char* var200 /* : NativeString */; +val* var201 /* : String */; +val* var202 /* : Map[MClass, Array[nullable MProperty]] */; +val* var204 /* : Map[MClass, Array[nullable MProperty]] */; +val* var_205 /* var : Map[MClass, Array[nullable MProperty]] */; +val* var206 /* : MapIterator[nullable Object, nullable Object] */; +val* var_207 /* var : MapIterator[MClass, Array[nullable MProperty]] */; +short int var208 /* : Bool */; +val* var210 /* : nullable Object */; +val* var_t211 /* var t: MClass */; +val* var212 /* : nullable Object */; +val* var_table213 /* var table: Array[nullable MProperty] */; +long var214 /* : Int */; +long var216 /* : Int */; +long var217 /* : Int */; +short int var219 /* : Bool */; +int cltype220; +int idtype221; +const char* var_class_name222; +long var223 /* : Int */; +val* var_224 /* var : Array[nullable MProperty] */; +val* var225 /* : IndexedIterator[nullable Object] */; +val* var_226 /* var : IndexedIterator[nullable MProperty] */; +short int var227 /* : Bool */; +val* var229 /* : nullable Object */; +val* var_e230 /* var e: nullable MProperty */; +short int var231 /* : Bool */; +short int var232 /* : Bool */; +short int var234 /* : Bool */; +short int var236 /* : Bool */; +long var237 /* : Int */; +short int var239 /* : Bool */; +int cltype240; +int idtype241; +const char* var_class_name242; +long var243 /* : Int */; +val* var245 /* : Sys */; +val* var247 /* : NativeArray[String] */; +static val* varonce246; +static val* varonce248; +val* var249 /* : String */; +char* var250 /* : NativeString */; +val* var251 /* : String */; +static val* varonce252; +val* var253 /* : String */; +char* var254 /* : NativeString */; +val* var255 /* : String */; +val* var256 /* : String */; +val* var257 /* : String */; +val* var258 /* : String */; +var = glob_sys; +if (likely(varonce!=NULL)) { +var1 = varonce; +} else { +var2 = "# size of subtyping tables"; +var3 = core__flat___NativeString___to_s_full(var2, 26l, 26l); +var1 = var3; +varonce = var1; +} +{ +core__file___Sys___print(var, var1); /* Direct call file#Sys#print on */ +} +var4 = glob_sys; +if (likely(varonce5!=NULL)) { +var6 = varonce5; +} else { +var7 = "\ttotal \tholes"; +var8 = core__flat___NativeString___to_s_full(var7, 13l, 13l); +var6 = var8; +varonce5 = var6; +} +{ +core__file___Sys___print(var4, var6); /* Direct call file#Sys#print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler#SeparateCompiler#type_tables (self) on */ +var11 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1065); +fatal_exit(1); +} +var9 = var11; +RET_LABEL10:(void)0; +} +} +var_ = var9; +{ +var12 = ((val*(*)(val* self))((((long)var_&3)?class_info[((long)var_&3)]:var_->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_); /* iterator on */ +} +var_13 = var12; +for(;;) { +{ +var14 = ((short int(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_13); /* is_ok on */ +} +if (var14){ +} else { +goto BREAK_label; +} +{ +var15 = ((val*(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_13); /* key on */ +} +var_t = var15; +{ +var16 = ((val*(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_13); /* item on */ +} +var_table = var16; +{ +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var19 = var_table->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var17 = var19; +RET_LABEL18:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_total,var17) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var22 = 1; /* easy isa OTHER*/ +if (unlikely(!var22)) { +var_class_name = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var23 = var_total + var17; +var20 = var23; +goto RET_LABEL21; +RET_LABEL21:(void)0; +} +} +var_total = var20; +var_24 = var_table; +{ +var25 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_24); +} +var_26 = var25; +for(;;) { +{ +var27 = ((short int(*)(val* self))((((long)var_26&3)?class_info[((long)var_26&3)]:var_26->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_26); /* is_ok on */ +} +if (var27){ +} else { +goto BREAK_label28; +} +{ +var29 = ((val*(*)(val* self))((((long)var_26&3)?class_info[((long)var_26&3)]:var_26->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_26); /* item on */ +} +var_e = var29; +if (var_e == NULL) { +var30 = 1; /* is null */ +} else { +var30 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_e,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_e,var_other) on */ +var35 = var_e == var_other; +var33 = var35; +goto RET_LABEL34; +RET_LABEL34:(void)0; +} +} +var31 = var33; +goto RET_LABEL32; +RET_LABEL32:(void)0; +} +var30 = var31; +} +if (var30){ +{ +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var38 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var38)) { +var_class_name41 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name41); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var42 = var_holes + 1l; +var36 = var42; +goto RET_LABEL37; +RET_LABEL37:(void)0; +} +} +var_holes = var36; +} else { +} +{ +((void(*)(val* self))((((long)var_26&3)?class_info[((long)var_26&3)]:var_26->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_26); /* next on */ +} +} +BREAK_label28: (void)0; +{ +((void(*)(val* self))((((long)var_26&3)?class_info[((long)var_26&3)]:var_26->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_26); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_13); /* next on */ +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_13) on */ +RET_LABEL43:(void)0; +} +} +var44 = glob_sys; +if (unlikely(varonce45==NULL)) { +var46 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce47!=NULL)) { +var48 = varonce47; +} else { +var49 = "\t"; +var50 = core__flat___NativeString___to_s_full(var49, 1l, 1l); +var48 = var50; +varonce47 = var48; +} +((struct instance_core__NativeArray*)var46)->values[0]=var48; +if (likely(varonce51!=NULL)) { +var52 = varonce51; +} else { +var53 = "\t"; +var54 = core__flat___NativeString___to_s_full(var53, 1l, 1l); +var52 = var54; +varonce51 = var52; +} +((struct instance_core__NativeArray*)var46)->values[2]=var52; +} else { +var46 = varonce45; +varonce45 = NULL; +} +var55 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var46)->values[1]=var55; +var56 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var46)->values[3]=var56; +{ +var57 = ((val*(*)(val* self))(var46->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var46); /* native_to_s on */ +} +varonce45 = var46; +{ +core__file___Sys___print(var44, var57); /* Direct call file#Sys#print on */ +} +var58 = glob_sys; +if (likely(varonce59!=NULL)) { +var60 = varonce59; +} else { +var61 = "# size of resolution tables"; +var62 = core__flat___NativeString___to_s_full(var61, 27l, 27l); +var60 = var62; +varonce59 = var60; +} +{ +core__file___Sys___print(var58, var60); /* Direct call file#Sys#print on */ +} +var63 = glob_sys; +if (likely(varonce64!=NULL)) { +var65 = varonce64; +} else { +var66 = "\ttotal \tholes"; +var67 = core__flat___NativeString___to_s_full(var66, 13l, 13l); +var65 = var67; +varonce64 = var65; +} +{ +core__file___Sys___print(var63, var65); /* Direct call file#Sys#print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var70 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var70 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1066); +fatal_exit(1); +} +var68 = var70; +RET_LABEL69:(void)0; +} +} +var_71 = var68; +{ +var72 = ((val*(*)(val* self))((((long)var_71&3)?class_info[((long)var_71&3)]:var_71->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_71); /* iterator on */ +} +var_73 = var72; +for(;;) { +{ +var74 = ((short int(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_73); /* is_ok on */ +} +if (var74){ +} else { +goto BREAK_label75; +} +{ +var76 = ((val*(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_73); /* key on */ +} +var_t77 = var76; +{ +var78 = ((val*(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_73); /* item on */ +} +var_table79 = var78; +{ +{ /* Inline array#AbstractArrayRead#length (var_table79) on */ +var82 = var_table79->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var80 = var82; +RET_LABEL81:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_total,var80) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var85 = 1; /* easy isa OTHER*/ +if (unlikely(!var85)) { +var_class_name88 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name88); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var89 = var_total + var80; +var83 = var89; +goto RET_LABEL84; +RET_LABEL84:(void)0; +} +} +var_total = var83; +var_90 = var_table79; +{ +var91 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_90); +} +var_92 = var91; +for(;;) { +{ +var93 = ((short int(*)(val* self))((((long)var_92&3)?class_info[((long)var_92&3)]:var_92->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_92); /* is_ok on */ +} +if (var93){ +} else { +goto BREAK_label94; +} +{ +var95 = ((val*(*)(val* self))((((long)var_92&3)?class_info[((long)var_92&3)]:var_92->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_92); /* item on */ +} +var_e96 = var95; +if (var_e96 == NULL) { +var97 = 1; /* is null */ +} else { +var97 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_e96,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_e96,var_other) on */ +var102 = var_e96 == var_other; +var100 = var102; +goto RET_LABEL101; +RET_LABEL101:(void)0; +} +} +var98 = var100; +goto RET_LABEL99; +RET_LABEL99:(void)0; +} +var97 = var98; +} +if (var97){ +{ +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var105 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var105)) { +var_class_name108 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name108); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var109 = var_holes + 1l; +var103 = var109; +goto RET_LABEL104; +RET_LABEL104:(void)0; +} +} +var_holes = var103; +} else { +} +{ +((void(*)(val* self))((((long)var_92&3)?class_info[((long)var_92&3)]:var_92->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_92); /* next on */ +} +} +BREAK_label94: (void)0; +{ +((void(*)(val* self))((((long)var_92&3)?class_info[((long)var_92&3)]:var_92->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_92); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_73); /* next on */ +} +} +BREAK_label75: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_73) on */ +RET_LABEL110:(void)0; +} +} +var111 = glob_sys; +if (unlikely(varonce112==NULL)) { +var113 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce114!=NULL)) { +var115 = varonce114; +} else { +var116 = "\t"; +var117 = core__flat___NativeString___to_s_full(var116, 1l, 1l); +var115 = var117; +varonce114 = var115; +} +((struct instance_core__NativeArray*)var113)->values[0]=var115; +if (likely(varonce118!=NULL)) { +var119 = varonce118; +} else { +var120 = "\t"; +var121 = core__flat___NativeString___to_s_full(var120, 1l, 1l); +var119 = var121; +varonce118 = var119; +} +((struct instance_core__NativeArray*)var113)->values[2]=var119; +} else { +var113 = varonce112; +varonce112 = NULL; +} +var122 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var113)->values[1]=var122; +var123 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var113)->values[3]=var123; +{ +var124 = ((val*(*)(val* self))(var113->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var113); /* native_to_s on */ +} +varonce112 = var113; +{ +core__file___Sys___print(var111, var124); /* Direct call file#Sys#print on */ +} +var125 = glob_sys; +if (likely(varonce126!=NULL)) { +var127 = varonce126; +} else { +var128 = "# size of methods tables"; +var129 = core__flat___NativeString___to_s_full(var128, 24l, 24l); +var127 = var129; +varonce126 = var127; +} +{ +core__file___Sys___print(var125, var127); /* Direct call file#Sys#print on */ +} +var130 = glob_sys; +if (likely(varonce131!=NULL)) { +var132 = varonce131; +} else { +var133 = "\ttotal \tholes"; +var134 = core__flat___NativeString___to_s_full(var133, 13l, 13l); +var132 = var134; +varonce131 = var132; +} +{ +core__file___Sys___print(var130, var132); /* Direct call file#Sys#print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ +var137 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var137 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1067); +fatal_exit(1); +} +var135 = var137; +RET_LABEL136:(void)0; +} +} +var_138 = var135; +{ +var139 = ((val*(*)(val* self))((((long)var_138&3)?class_info[((long)var_138&3)]:var_138->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_138); /* iterator on */ +} +var_140 = var139; +for(;;) { +{ +var141 = ((short int(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_140); /* is_ok on */ +} +if (var141){ +} else { +goto BREAK_label142; +} +{ +var143 = ((val*(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_140); /* key on */ +} +var_t144 = var143; +{ +var145 = ((val*(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_140); /* item on */ +} +var_table146 = var145; +{ +{ /* Inline array#AbstractArrayRead#length (var_table146) on */ +var149 = var_table146->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var147 = var149; +RET_LABEL148:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_total,var147) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var152 = 1; /* easy isa OTHER*/ +if (unlikely(!var152)) { +var_class_name155 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name155); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var156 = var_total + var147; +var150 = var156; +goto RET_LABEL151; +RET_LABEL151:(void)0; +} +} +var_total = var150; +var_157 = var_table146; +{ +var158 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_157); +} +var_159 = var158; +for(;;) { +{ +var160 = ((short int(*)(val* self))((((long)var_159&3)?class_info[((long)var_159&3)]:var_159->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_159); /* is_ok on */ +} +if (var160){ +} else { +goto BREAK_label161; +} +{ +var162 = ((val*(*)(val* self))((((long)var_159&3)?class_info[((long)var_159&3)]:var_159->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_159); /* item on */ +} +var_e163 = var162; +if (var_e163 == NULL) { +var164 = 1; /* is null */ +} else { +var164 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_e163,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_e163,var_other) on */ +var169 = var_e163 == var_other; +var167 = var169; +goto RET_LABEL168; +RET_LABEL168:(void)0; +} +} +var165 = var167; +goto RET_LABEL166; +RET_LABEL166:(void)0; +} +var164 = var165; +} +if (var164){ +{ +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var172 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var172)) { +var_class_name175 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name175); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var176 = var_holes + 1l; +var170 = var176; +goto RET_LABEL171; +RET_LABEL171:(void)0; +} +} +var_holes = var170; +} else { +} +{ +((void(*)(val* self))((((long)var_159&3)?class_info[((long)var_159&3)]:var_159->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_159); /* next on */ +} +} +BREAK_label161: (void)0; +{ +((void(*)(val* self))((((long)var_159&3)?class_info[((long)var_159&3)]:var_159->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_159); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_140); /* next on */ +} +} +BREAK_label142: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_140) on */ +RET_LABEL177:(void)0; +} +} +var178 = glob_sys; +if (unlikely(varonce179==NULL)) { +var180 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce181!=NULL)) { +var182 = varonce181; +} else { +var183 = "\t"; +var184 = core__flat___NativeString___to_s_full(var183, 1l, 1l); +var182 = var184; +varonce181 = var182; +} +((struct instance_core__NativeArray*)var180)->values[0]=var182; +if (likely(varonce185!=NULL)) { +var186 = varonce185; +} else { +var187 = "\t"; +var188 = core__flat___NativeString___to_s_full(var187, 1l, 1l); +var186 = var188; +varonce185 = var186; +} +((struct instance_core__NativeArray*)var180)->values[2]=var186; +} else { +var180 = varonce179; +varonce179 = NULL; +} +var189 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var180)->values[1]=var189; +var190 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var180)->values[3]=var190; +{ +var191 = ((val*(*)(val* self))(var180->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var180); /* native_to_s on */ +} +varonce179 = var180; +{ +core__file___Sys___print(var178, var191); /* Direct call file#Sys#print on */ +} +var192 = glob_sys; +if (likely(varonce193!=NULL)) { +var194 = varonce193; +} else { +var195 = "# size of attributes tables"; +var196 = core__flat___NativeString___to_s_full(var195, 27l, 27l); +var194 = var196; +varonce193 = var194; +} +{ +core__file___Sys___print(var192, var194); /* Direct call file#Sys#print on */ +} +var197 = glob_sys; +if (likely(varonce198!=NULL)) { +var199 = varonce198; +} else { +var200 = "\ttotal \tholes"; +var201 = core__flat___NativeString___to_s_full(var200, 13l, 13l); +var199 = var201; +varonce198 = var199; +} +{ +core__file___Sys___print(var197, var199); /* Direct call file#Sys#print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ +var204 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var204 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1068); +fatal_exit(1); +} +var202 = var204; +RET_LABEL203:(void)0; +} +} +var_205 = var202; +{ +var206 = ((val*(*)(val* self))((((long)var_205&3)?class_info[((long)var_205&3)]:var_205->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_205); /* iterator on */ +} +var_207 = var206; +for(;;) { +{ +var208 = ((short int(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_207); /* is_ok on */ +} +if (var208){ +} else { +goto BREAK_label209; +} +{ +var210 = ((val*(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_207); /* key on */ +} +var_t211 = var210; +{ +var212 = ((val*(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_207); /* item on */ +} +var_table213 = var212; +{ +{ /* Inline array#AbstractArrayRead#length (var_table213) on */ +var216 = var_table213->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var214 = var216; +RET_LABEL215:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_total,var214) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var219 = 1; /* easy isa OTHER*/ +if (unlikely(!var219)) { +var_class_name222 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name222); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var223 = var_total + var214; +var217 = var223; +goto RET_LABEL218; +RET_LABEL218:(void)0; +} +} +var_total = var217; +var_224 = var_table213; +{ +var225 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_224); +} +var_226 = var225; +for(;;) { +{ +var227 = ((short int(*)(val* self))((((long)var_226&3)?class_info[((long)var_226&3)]:var_226->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_226); /* is_ok on */ +} +if (var227){ +} else { +goto BREAK_label228; +} +{ +var229 = ((val*(*)(val* self))((((long)var_226&3)?class_info[((long)var_226&3)]:var_226->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_226); /* item on */ +} +var_e230 = var229; +if (var_e230 == NULL) { +var231 = 1; /* is null */ +} else { +var231 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_e230,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_e230,var_other) on */ +var236 = var_e230 == var_other; +var234 = var236; +goto RET_LABEL235; +RET_LABEL235:(void)0; +} +} +var232 = var234; +goto RET_LABEL233; +RET_LABEL233:(void)0; +} +var231 = var232; +} +if (var231){ +{ +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var239 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var239)) { +var_class_name242 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name242); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var243 = var_holes + 1l; +var237 = var243; +goto RET_LABEL238; +RET_LABEL238:(void)0; +} +} +var_holes = var237; +} else { +} +{ +((void(*)(val* self))((((long)var_226&3)?class_info[((long)var_226&3)]:var_226->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_226); /* next on */ +} +} +BREAK_label228: (void)0; +{ +((void(*)(val* self))((((long)var_226&3)?class_info[((long)var_226&3)]:var_226->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_226); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_207); /* next on */ +} +} +BREAK_label209: (void)0; +{ +{ /* Inline abstract_collection#MapIterator#finish (var_207) on */ +RET_LABEL244:(void)0; +} +} +var245 = glob_sys; +if (unlikely(varonce246==NULL)) { +var247 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); +if (likely(varonce248!=NULL)) { +var249 = varonce248; +} else { +var250 = "\t"; +var251 = core__flat___NativeString___to_s_full(var250, 1l, 1l); +var249 = var251; +varonce248 = var249; +} +((struct instance_core__NativeArray*)var247)->values[0]=var249; +if (likely(varonce252!=NULL)) { +var253 = varonce252; +} else { +var254 = "\t"; +var255 = core__flat___NativeString___to_s_full(var254, 1l, 1l); +var253 = var255; +varonce252 = var253; +} +((struct instance_core__NativeArray*)var247)->values[2]=var253; +} else { +var247 = varonce246; +varonce246 = NULL; +} +var256 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var247)->values[1]=var256; +var257 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var247)->values[3]=var257; +{ +var258 = ((val*(*)(val* self))(var247->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var247); /* native_to_s on */ +} +varonce246 = var247; +{ +core__file___Sys___print(var245, var258); /* Direct call file#Sys#print on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#isset_checks_count for (self: SeparateCompiler): Int */ +long nitc___nitc__SeparateCompiler___isset_checks_count(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#isset_checks_count= for (self: SeparateCompiler, Int) */ +void nitc___nitc__SeparateCompiler___isset_checks_count_61d(val* self, long p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___isset_checks_count].l = p0; /* _isset_checks_count on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#attr_read_count for (self: SeparateCompiler): Int */ +long nitc___nitc__SeparateCompiler___attr_read_count(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#attr_read_count= for (self: SeparateCompiler, Int) */ +void nitc___nitc__SeparateCompiler___attr_read_count_61d(val* self, long p0) { +self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_read_count].l = p0; /* _attr_read_count on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#display_isset_checks for (self: SeparateCompiler) */ +void nitc___nitc__SeparateCompiler___display_isset_checks(val* self) { +val* var /* : Sys */; +static val* varonce; +val* var1 /* : String */; +char* var2 /* : NativeString */; +val* var3 /* : String */; +val* var4 /* : Sys */; +val* var6 /* : NativeArray[String] */; +static val* varonce5; +static val* varonce7; +val* var8 /* : String */; +char* var9 /* : NativeString */; +val* var10 /* : String */; +long var11 /* : Int */; +long var13 /* : Int */; +val* var14 /* : String */; +val* var15 /* : String */; +val* var16 /* : Sys */; +static val* varonce17; +val* var18 /* : String */; +char* var19 /* : NativeString */; +val* var20 /* : String */; +val* var21 /* : Sys */; +val* var23 /* : NativeArray[String] */; +static val* varonce22; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : String */; +long var28 /* : Int */; +long var30 /* : Int */; +val* var31 /* : String */; +val* var32 /* : String */; +var = glob_sys; +if (likely(varonce!=NULL)) { +var1 = varonce; +} else { +var2 = "# total number of compiled attribute reads"; +var3 = core__flat___NativeString___to_s_full(var2, 42l, 42l); +var1 = var3; +varonce = var1; +} +{ +core__file___Sys___print(var, var1); /* Direct call file#Sys#print on */ +} +var4 = glob_sys; +if (unlikely(varonce5==NULL)) { +var6 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce7!=NULL)) { +var8 = varonce7; +} else { +var9 = "\t"; +var10 = core__flat___NativeString___to_s_full(var9, 1l, 1l); +var8 = var10; +varonce7 = var8; +} +((struct instance_core__NativeArray*)var6)->values[0]=var8; +} else { +var6 = varonce5; +varonce5 = NULL; +} +{ +{ /* Inline separate_compiler#SeparateCompiler#attr_read_count (self) on */ +var13 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ +var11 = var13; +RET_LABEL12:(void)0; +} +} +var14 = core__flat___Int___core__abstract_text__Object__to_s(var11); +((struct instance_core__NativeArray*)var6)->values[1]=var14; +{ +var15 = ((val*(*)(val* self))(var6->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var6); /* native_to_s on */ +} +varonce5 = var6; +{ +core__file___Sys___print(var4, var15); /* Direct call file#Sys#print on */ +} +var16 = glob_sys; +if (likely(varonce17!=NULL)) { +var18 = varonce17; +} else { +var19 = "# total number of compiled isset-checks"; +var20 = core__flat___NativeString___to_s_full(var19, 39l, 39l); +var18 = var20; +varonce17 = var18; +} +{ +core__file___Sys___print(var16, var18); /* Direct call file#Sys#print on */ +} +var21 = glob_sys; +if (unlikely(varonce22==NULL)) { +var23 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +if (likely(varonce24!=NULL)) { +var25 = varonce24; +} else { +var26 = "\t"; +var27 = core__flat___NativeString___to_s_full(var26, 1l, 1l); +var25 = var27; +varonce24 = var25; +} +((struct instance_core__NativeArray*)var23)->values[0]=var25; +} else { +var23 = varonce22; +varonce22 = NULL; +} +{ +{ /* Inline separate_compiler#SeparateCompiler#isset_checks_count (self) on */ +var30 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ +var28 = var30; +RET_LABEL29:(void)0; +} +} +var31 = core__flat___Int___core__abstract_text__Object__to_s(var28); +((struct instance_core__NativeArray*)var23)->values[1]=var31; +{ +var32 = ((val*(*)(val* self))(var23->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var23); /* native_to_s on */ +} +varonce22 = var23; +{ +core__file___Sys___print(var21, var32); /* Direct call file#Sys#print on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#compile_nitni_structs for (self: SeparateCompiler) */ +void nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__compile_nitni_structs(val* self) { +val* var /* : CodeWriter */; +val* var2 /* : CodeWriter */; +static val* varonce; +val* var3 /* : String */; +char* var4 /* : NativeString */; +val* var5 /* : String */; +{ +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var2 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 585); +fatal_exit(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +if (likely(varonce!=NULL)) { +var3 = varonce; +} else { +var4 = "struct nitni_instance {\n\tstruct nitni_instance *next,\n\t\t*prev; /* adjacent global references in global list */\n\tint count; /* number of time this global reference has been marked */\n\tstruct instance *value;\n};\n"; +var5 = core__flat___NativeString___to_s_full(var4, 210l, 210l); +var3 = var5; +varonce = var3; +} +{ +nitc___nitc__CodeWriter___add_decl(var, var3); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +} +{ +((void(*)(val* self))(self->class->vft[COLOR_nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__compile_nitni_structs]))(self); /* compile_nitni_structs on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#finalize_ffi_for_module for (self: SeparateCompiler, MModule) */ +void nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__finalize_ffi_for_module(val* self, val* p0) { +val* var_mmodule /* var mmodule: MModule */; +val* var /* : MModule */; +val* var2 /* : MModule */; +val* var_old_module /* var old_module: MModule */; +var_mmodule = p0; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var2 = self->attrs[COLOR_nitc__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_nitc__abstract_compiler, 531); +fatal_exit(1); +} +var = var2; +RET_LABEL1:(void)0; +} +} +var_old_module = var; +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_mmodule) on */ +self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val = var_mmodule; /* _mainmodule on */ +RET_LABEL3:(void)0; +} +} +{ +((void(*)(val* self, val* p0))(self->class->vft[COLOR_nitc___nitc__SeparateCompiler___nitc__abstract_compiler__AbstractCompiler__finalize_ffi_for_module]))(self, p0); /* finalize_ffi_for_module on */ +} +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_old_module) on */ +self->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val = var_old_module; /* _mainmodule on */ +RET_LABEL4:(void)0; +} +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompilerVisitor#adapt_signature for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ +void nitc___nitc__SeparateCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__adapt_signature(val* self, val* p0, val* p1) { +val* var_m /* var m: MMethodDef */; +val* var_args /* var args: Array[RuntimeVariable] */; +val* var /* : nullable MSignature */; +val* var2 /* : nullable MSignature */; +val* var3 /* : MClassDef */; +val* var5 /* : MClassDef */; +val* var6 /* : MClassType */; +val* var8 /* : MClassType */; +val* var9 /* : MClassDef */; +val* var11 /* : MClassDef */; +val* var12 /* : MClassType */; +val* var14 /* : MClassType */; +val* var15 /* : MClassDef */; +val* var17 /* : MClassDef */; +val* var18 /* : MModule */; +val* var20 /* : MModule */; +val* var21 /* : MSignature */; +val* var_msignature /* var msignature: MSignature */; +val* var22 /* : nullable Object */; +val* var_recv /* var recv: RuntimeVariable */; +val* var23 /* : MType */; +val* var25 /* : MType */; +val* var26 /* : String */; +val* var27 /* : MClassDef */; +val* var29 /* : MClassDef */; +val* var30 /* : MClass */; +val* var32 /* : MClass */; +val* var33 /* : MClassType */; +val* var35 /* : MClassType */; +val* var36 /* : String */; +short int var37 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var39 /* : Bool */; +short int var40 /* : Bool */; +val* var41 /* : nullable Object */; +val* var42 /* : MClassDef */; +val* var44 /* : MClassDef */; +val* var45 /* : MClass */; +val* var47 /* : MClass */; +val* var48 /* : MClassType */; +val* var50 /* : MClassType */; +val* var51 /* : RuntimeVariable */; +long var_i /* var i: Int */; +long var52 /* : Int */; +long var_ /* var : Int */; +short int var53 /* : Bool */; +short int var55 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var56 /* : Bool */; +val* var57 /* : Array[MParameter] */; +val* var59 /* : Array[MParameter] */; +val* var60 /* : nullable Object */; +val* var_mp /* var mp: MParameter */; +val* var61 /* : MType */; +val* var63 /* : MType */; +val* var_t /* var t: MType */; +short int var64 /* : Bool */; +short int var66 /* : Bool */; +long var67 /* : Int */; +short int var69 /* : Bool */; +int cltype70; +int idtype71; +const char* var_class_name72; +long var73 /* : Int */; +val* var74 /* : nullable Object */; +val* var75 /* : MType */; +val* var77 /* : MType */; +long var78 /* : Int */; +short int var80 /* : Bool */; +int cltype81; +int idtype82; +const char* var_class_name83; +long var84 /* : Int */; +long var85 /* : Int */; +short int var87 /* : Bool */; +int cltype88; +int idtype89; +const char* var_class_name90; +long var91 /* : Int */; +val* var92 /* : nullable Object */; +val* var93 /* : RuntimeVariable */; +long var94 /* : Int */; +var_m = p0; +var_args = p1; +{ +{ /* Inline model#MMethodDef#msignature (var_m) on */ +var2 = var_m->attrs[COLOR_nitc__model__MMethodDef___msignature].val; /* _msignature on */ +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var5 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var3) on */ +var8 = var3->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +fatal_exit(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var11 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var9) on */ +var14 = var9->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +fatal_exit(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var17 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mmodule (var15) on */ +var20 = var15->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 573); +fatal_exit(1); +} +var18 = var20; +RET_LABEL19:(void)0; +} +} +if (var == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1171); +fatal_exit(1); +} else { +var21 = nitc___nitc__MSignature___MType__resolve_for(var, var6, var12, var18, 1); +} +var_msignature = var21; +{ +var22 = core___core__SequenceRead___Collection__first(var_args); +} +var_recv = var22; +{ +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ +var25 = var_recv->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var25 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +fatal_exit(1); +} +var23 = var25; +RET_LABEL24:(void)0; +} +} +{ +var26 = ((val*(*)(val* self))(var23->class->vft[COLOR_nitc__abstract_compiler__MType__ctype]))(var23); /* ctype on */ +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var29 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var29 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var27 = var29; +RET_LABEL28:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mclass (var27) on */ +var32 = var27->attrs[COLOR_nitc__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var32 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 576); +fatal_exit(1); +} +var30 = var32; +RET_LABEL31:(void)0; +} +} +{ +{ /* Inline model#MClass#mclass_type (var30) on */ +var35 = var30->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var35 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var33 = var35; +RET_LABEL34:(void)0; +} +} +{ +var36 = nitc__abstract_compiler___MClassType___MType__ctype(var33); +} +{ +{ /* Inline kernel#Object#!= (var26,var36) on */ +var_other = var36; +{ +var39 = ((short int(*)(val* self, val* p0))(var26->class->vft[COLOR_core__kernel__Object___61d_61d]))(var26, var_other); /* == on */ +} +var40 = !var39; +var37 = var40; +goto RET_LABEL38; +RET_LABEL38:(void)0; +} +} +if (var37){ +{ +var41 = core___core__SequenceRead___Collection__first(var_args); +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var44 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var42 = var44; +RET_LABEL43:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mclass (var42) on */ +var47 = var42->attrs[COLOR_nitc__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 576); +fatal_exit(1); +} +var45 = var47; +RET_LABEL46:(void)0; +} +} +{ +{ /* Inline model#MClass#mclass_type (var45) on */ +var50 = var45->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var50 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var48 = var50; +RET_LABEL49:(void)0; +} +} +{ +var51 = nitc___nitc__SeparateCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__autobox(self, var41, var48); +} +{ +core___core__Sequence___first_61d(var_args, var51); /* Direct call abstract_collection#Sequence#first= on */ +} +} else { +} +var_i = 0l; +{ +var52 = nitc___nitc__MSignature___arity(var_msignature); +} +var_ = var52; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var55 = 1; /* easy isa OTHER*/ +if (unlikely(!var55)) { +var_class_name = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var56 = var_i < var_; +var53 = var56; +goto RET_LABEL54; +RET_LABEL54:(void)0; +} +} +if (var53){ +} else { +goto BREAK_label; +} +{ +{ /* Inline model#MSignature#mparameters (var_msignature) on */ +var59 = var_msignature->attrs[COLOR_nitc__model__MSignature___mparameters].val; /* _mparameters on */ +if (unlikely(var59 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1783); +fatal_exit(1); +} +var57 = var59; +RET_LABEL58:(void)0; +} +} +{ +var60 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var57, var_i); +} +var_mp = var60; +{ +{ /* Inline model#MParameter#mtype (var_mp) on */ +var63 = var_mp->attrs[COLOR_nitc__model__MParameter___mtype].val; /* _mtype on */ +if (unlikely(var63 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1900); +fatal_exit(1); +} +var61 = var63; +RET_LABEL62:(void)0; +} +} +var_t = var61; +{ +{ /* Inline model#MParameter#is_vararg (var_mp) on */ +var66 = var_mp->attrs[COLOR_nitc__model__MParameter___is_vararg].s; /* _is_vararg on */ +var64 = var66; +RET_LABEL65:(void)0; +} +} +if (var64){ +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var69 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var69)) { +var_class_name72 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name72); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var73 = var_i + 1l; +var67 = var73; +goto RET_LABEL68; +RET_LABEL68:(void)0; +} +} +{ +var74 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_args, var67); +} +{ +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var74) on */ +var77 = var74->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var77 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +fatal_exit(1); +} +var75 = var77; +RET_LABEL76:(void)0; +} +} +var_t = var75; +} else { +} +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var80 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var80)) { +var_class_name83 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name83); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var84 = var_i + 1l; +var78 = var84; +goto RET_LABEL79; +RET_LABEL79:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var87 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var87)) { +var_class_name90 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name90); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var91 = var_i + 1l; +var85 = var91; +goto RET_LABEL86; +RET_LABEL86:(void)0; +} +} +{ +var92 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_args, var85); +} +{ +var93 = nitc___nitc__SeparateCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__autobox(self, var92, var_t); +} +{ +core___core__Array___core__abstract_collection__Sequence___91d_93d_61d(var_args, var78, var93); /* Direct call array#Array#[]= on */ +} +{ +var94 = core___core__Int___Discrete__successor(var_i, 1l); +} +var_i = var94; +} +BREAK_label: (void)0; +RET_LABEL:; +} +/* method separate_compiler#SeparateCompilerVisitor#unbox_signature_extern for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ +void nitc___nitc__SeparateCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__unbox_signature_extern(val* self, val* p0, val* p1) { +val* var_m /* var m: MMethodDef */; +val* var_args /* var args: Array[RuntimeVariable] */; +val* var /* : nullable MSignature */; +val* var2 /* : nullable MSignature */; +val* var3 /* : MClassDef */; +val* var5 /* : MClassDef */; +val* var6 /* : MClassType */; +val* var8 /* : MClassType */; +val* var9 /* : MClassDef */; +val* var11 /* : MClassDef */; +val* var12 /* : MClassType */; +val* var14 /* : MClassType */; +val* var15 /* : MClassDef */; +val* var17 /* : MClassDef */; +val* var18 /* : MModule */; +val* var20 /* : MModule */; +val* var21 /* : MSignature */; +val* var_msignature /* var msignature: MSignature */; +short int var22 /* : Bool */; +val* var23 /* : MProperty */; +val* var25 /* : MProperty */; +short int var26 /* : Bool */; +short int var28 /* : Bool */; +short int var29 /* : Bool */; +short int var_ /* var : Bool */; +short int var30 /* : Bool */; +short int var32 /* : Bool */; +val* var33 /* : nullable Object */; +val* var34 /* : MClassDef */; +val* var36 /* : MClassDef */; +val* var37 /* : MClass */; +val* var39 /* : MClass */; +val* var40 /* : MClassType */; +val* var42 /* : MClassType */; +val* var43 /* : RuntimeVariable */; +long var_i /* var i: Int */; +long var44 /* : Int */; +long var_45 /* var : Int */; +short int var46 /* : Bool */; +short int var48 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var49 /* : Bool */; +val* var50 /* : Array[MParameter] */; +val* var52 /* : Array[MParameter] */; +val* var53 /* : nullable Object */; +val* var_mp /* var mp: MParameter */; +val* var54 /* : MType */; +val* var56 /* : MType */; +val* var_t /* var t: MType */; +short int var57 /* : Bool */; +short int var59 /* : Bool */; +long var60 /* : Int */; +short int var62 /* : Bool */; +int cltype63; +int idtype64; +const char* var_class_name65; +long var66 /* : Int */; +val* var67 /* : nullable Object */; +val* var68 /* : MType */; +val* var70 /* : MType */; +short int var71 /* : Bool */; +short int var73 /* : Bool */; +long var74 /* : Int */; +short int var76 /* : Bool */; +int cltype77; +int idtype78; +const char* var_class_name79; +long var80 /* : Int */; +long var81 /* : Int */; +short int var83 /* : Bool */; +int cltype84; +int idtype85; +const char* var_class_name86; +long var87 /* : Int */; +val* var88 /* : nullable Object */; +val* var89 /* : RuntimeVariable */; +long var90 /* : Int */; +var_m = p0; +var_args = p1; +{ +{ /* Inline model#MMethodDef#msignature (var_m) on */ +var2 = var_m->attrs[COLOR_nitc__model__MMethodDef___msignature].val; /* _msignature on */ +var = var2; +RET_LABEL1:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var5 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var3 = var5; +RET_LABEL4:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var3) on */ +var8 = var3->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +fatal_exit(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var11 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var9 = var11; +RET_LABEL10:(void)0; +} +} +{ +{ /* Inline model#MClassDef#bound_mtype (var9) on */ +var14 = var9->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +fatal_exit(1); +} +var12 = var14; +RET_LABEL13:(void)0; +} +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var17 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var15 = var17; +RET_LABEL16:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mmodule (var15) on */ +var20 = var15->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 573); +fatal_exit(1); +} +var18 = var20; +RET_LABEL19:(void)0; +} +} +if (var == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1188); +fatal_exit(1); +} else { +var21 = nitc___nitc__MSignature___MType__resolve_for(var, var6, var12, var18, 1); +} +var_msignature = var21; +{ +{ /* Inline model#MPropDef#mproperty (var_m) on */ +var25 = var_m->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on */ +if (unlikely(var25 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2230); +fatal_exit(1); +} +var23 = var25; +RET_LABEL24:(void)0; +} +} +{ +{ /* Inline model#MMethod#is_init (var23) on */ +var28 = var23->attrs[COLOR_nitc__model__MMethod___is_init].s; /* _is_init on */ +var26 = var28; +RET_LABEL27:(void)0; +} +} +var29 = !var26; +var_ = var29; +if (var29){ +{ +{ /* Inline model#MMethodDef#is_extern (var_m) on */ +var32 = var_m->attrs[COLOR_nitc__model__MMethodDef___is_extern].s; /* _is_extern on */ +var30 = var32; +RET_LABEL31:(void)0; +} +} +var22 = var30; +} else { +var22 = var_; +} +if (var22){ +{ +var33 = core___core__SequenceRead___Collection__first(var_args); +} +{ +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var36 = var_m->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var36 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +fatal_exit(1); +} +var34 = var36; +RET_LABEL35:(void)0; +} +} +{ +{ /* Inline model#MClassDef#mclass (var34) on */ +var39 = var34->attrs[COLOR_nitc__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var39 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 576); +fatal_exit(1); +} +var37 = var39; +RET_LABEL38:(void)0; +} +} +{ +{ /* Inline model#MClass#mclass_type (var37) on */ +var42 = var37->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var42 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 507); +fatal_exit(1); +} +var40 = var42; +RET_LABEL41:(void)0; +} +} +{ +var43 = ((val*(*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var33, var40); /* unbox_extern on */ +} +{ +core___core__Sequence___first_61d(var_args, var43); /* Direct call abstract_collection#Sequence#first= on */ +} +} else { +} +var_i = 0l; +{ +var44 = nitc___nitc__MSignature___arity(var_msignature); +} +var_45 = var44; +for(;;) { +{ +{ /* Inline kernel#Int#< (var_i,var_45) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var48 = 1; /* easy isa OTHER*/ +if (unlikely(!var48)) { +var_class_name = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var49 = var_i < var_45; +var46 = var49; +goto RET_LABEL47; +RET_LABEL47:(void)0; +} +} +if (var46){ +} else { +goto BREAK_label; +} +{ +{ /* Inline model#MSignature#mparameters (var_msignature) on */ +var52 = var_msignature->attrs[COLOR_nitc__model__MSignature___mparameters].val; /* _mparameters on */ +if (unlikely(var52 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1783); +fatal_exit(1); +} +var50 = var52; +RET_LABEL51:(void)0; +} +} +{ +var53 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var50, var_i); +} +var_mp = var53; +{ +{ /* Inline model#MParameter#mtype (var_mp) on */ +var56 = var_mp->attrs[COLOR_nitc__model__MParameter___mtype].val; /* _mtype on */ +if (unlikely(var56 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1900); +fatal_exit(1); +} +var54 = var56; +RET_LABEL55:(void)0; +} +} +var_t = var54; +{ +{ /* Inline model#MParameter#is_vararg (var_mp) on */ +var59 = var_mp->attrs[COLOR_nitc__model__MParameter___is_vararg].s; /* _is_vararg on */ +var57 = var59; +RET_LABEL58:(void)0; +} +} +if (var57){ +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var62 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var62)) { +var_class_name65 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name65); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var66 = var_i + 1l; +var60 = var66; +goto RET_LABEL61; +RET_LABEL61:(void)0; +} +} +{ +var67 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_args, var60); +} +{ +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var67) on */ +var70 = var67->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var70 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +fatal_exit(1); +} +var68 = var70; +RET_LABEL69:(void)0; +} +} +var_t = var68; +} else { +} +{ +{ /* Inline model#MMethodDef#is_extern (var_m) on */ +var73 = var_m->attrs[COLOR_nitc__model__MMethodDef___is_extern].s; /* _is_extern on */ +var71 = var73; +RET_LABEL72:(void)0; +} +} +if (var71){ +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var76 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var76)) { +var_class_name79 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name79); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var80 = var_i + 1l; +var74 = var80; +goto RET_LABEL75; +RET_LABEL75:(void)0; +} +} +{ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var83 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var83)) { +var_class_name86 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name86); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +fatal_exit(1); +} +var87 = var_i + 1l; +var81 = var87; +goto RET_LABEL82; +RET_LABEL82:(void)0; +} +} +{ +var88 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_args, var81); +} +{ +var89 = ((val*(*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var88, var_t); /* unbox_extern on */ +} +{ +core___core__Array___core__abstract_collection__Sequence___91d_93d_61d(var_args, var74, var89); /* Direct call array#Array#[]= on */ +} +} else { +} +{ +var90 = core___core__Int___Discrete__successor(var_i, 1l); +} +var_i = var90; +} +BREAK_label: (void)0; +RET_LABEL:; +}