X-Git-Url: http://nitlanguage.org diff --git a/c_src/nitc__separate_erasure_compiler.sep.2.c b/c_src/nitc__separate_erasure_compiler.sep.2.c index 3d45580..2daf80f 100644 --- a/c_src/nitc__separate_erasure_compiler.sep.2.c +++ b/c_src/nitc__separate_erasure_compiler.sep.2.c @@ -1,5 +1,1776 @@ #include "nitc__separate_erasure_compiler.sep.0.h" -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#type_test for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType, String): RuntimeVariable */ +/* method separate_erasure_compiler$SeparateErasureCompiler$display_sizes for (self: SeparateErasureCompiler) */ +void nitc___nitc__SeparateErasureCompiler___nitc__separate_compiler__SeparateCompiler__display_sizes(val* self) { +val* var /* : Sys */; +static val* varonce; +val* var1 /* : String */; +char* var2 /* : CString */; +val* var3 /* : String */; +val* var4 /* : nullable Int */; +val* var5 /* : nullable Int */; +val* var6 /* : nullable Bool */; +val* var7 /* : nullable Bool */; +val* var8 /* : Sys */; +static val* varonce9; +val* var10 /* : String */; +char* var11 /* : CString */; +val* var12 /* : String */; +val* var13 /* : nullable Int */; +val* var14 /* : nullable Int */; +val* var15 /* : nullable Bool */; +val* var16 /* : nullable Bool */; +long var_total /* var total: Int */; +long var_holes /* var holes: Int */; +val* var17 /* : Map[MClass, Array[nullable MClass]] */; +val* var19 /* : Map[MClass, Array[nullable MClass]] */; +val* var_ /* var : Map[MClass, Array[nullable MClass]] */; +val* var20 /* : MapIterator[nullable Object, nullable Object] */; +val* var_21 /* var : MapIterator[MClass, Array[nullable MClass]] */; +short int var22 /* : Bool */; +val* var23 /* : nullable Object */; +val* var_t /* var t: MClass */; +val* var24 /* : nullable Object */; +val* var_table /* var table: Array[nullable MClass] */; +long var25 /* : Int */; +long var27 /* : Int */; +long var28 /* : Int */; +short int var30 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var31 /* : Int */; +val* var_32 /* var : Array[nullable MClass] */; +val* var33 /* : IndexedIterator[nullable Object] */; +val* var_34 /* var : IndexedIterator[nullable MClass] */; +short int var35 /* : Bool */; +val* var37 /* : nullable Object */; +val* var_e /* var e: nullable MClass */; +short int var38 /* : Bool */; +short int var39 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var41 /* : Bool */; +short int var43 /* : Bool */; +long var44 /* : Int */; +short int var46 /* : Bool */; +int cltype47; +int idtype48; +const char* var_class_name49; +long var50 /* : Int */; +val* var52 /* : Sys */; +val* var54 /* : NativeArray[String] */; +static val* varonce53; +static val* varonce55; +val* var56 /* : String */; +char* var57 /* : CString */; +val* var58 /* : String */; +val* var59 /* : nullable Int */; +val* var60 /* : nullable Int */; +val* var61 /* : nullable Bool */; +val* var62 /* : nullable Bool */; +static val* varonce63; +val* var64 /* : String */; +char* var65 /* : CString */; +val* var66 /* : String */; +val* var67 /* : nullable Int */; +val* var68 /* : nullable Int */; +val* var69 /* : nullable Bool */; +val* var70 /* : nullable Bool */; +val* var71 /* : String */; +val* var72 /* : String */; +val* var73 /* : String */; +val* var74 /* : Sys */; +static val* varonce75; +val* var76 /* : String */; +char* var77 /* : CString */; +val* var78 /* : String */; +val* var79 /* : nullable Int */; +val* var80 /* : nullable Int */; +val* var81 /* : nullable Bool */; +val* var82 /* : nullable Bool */; +val* var83 /* : Sys */; +static val* varonce84; +val* var85 /* : String */; +char* var86 /* : CString */; +val* var87 /* : String */; +val* var88 /* : nullable Int */; +val* var89 /* : nullable Int */; +val* var90 /* : nullable Bool */; +val* var91 /* : nullable Bool */; +val* var92 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var94 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_95 /* var : Map[MClass, Array[nullable MPropDef]] */; +val* var96 /* : MapIterator[nullable Object, nullable Object] */; +val* var_97 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; +short int var98 /* : Bool */; +val* var100 /* : nullable Object */; +val* var_t101 /* var t: MClass */; +val* var102 /* : nullable Object */; +val* var_table103 /* var table: Array[nullable MPropDef] */; +long var104 /* : Int */; +long var106 /* : Int */; +long var107 /* : Int */; +short int var109 /* : Bool */; +int cltype110; +int idtype111; +const char* var_class_name112; +long var113 /* : Int */; +val* var_114 /* var : Array[nullable MPropDef] */; +val* var115 /* : IndexedIterator[nullable Object] */; +val* var_116 /* var : IndexedIterator[nullable MPropDef] */; +short int var117 /* : Bool */; +val* var119 /* : nullable Object */; +val* var_e120 /* var e: nullable MPropDef */; +short int var121 /* : Bool */; +short int var122 /* : Bool */; +short int var124 /* : Bool */; +short int var126 /* : Bool */; +long var127 /* : Int */; +short int var129 /* : Bool */; +int cltype130; +int idtype131; +const char* var_class_name132; +long var133 /* : Int */; +val* var135 /* : Sys */; +val* var137 /* : NativeArray[String] */; +static val* varonce136; +static val* varonce138; +val* var139 /* : String */; +char* var140 /* : CString */; +val* var141 /* : String */; +val* var142 /* : nullable Int */; +val* var143 /* : nullable Int */; +val* var144 /* : nullable Bool */; +val* var145 /* : nullable Bool */; +static val* varonce146; +val* var147 /* : String */; +char* var148 /* : CString */; +val* var149 /* : String */; +val* var150 /* : nullable Int */; +val* var151 /* : nullable Int */; +val* var152 /* : nullable Bool */; +val* var153 /* : nullable Bool */; +val* var154 /* : String */; +val* var155 /* : String */; +val* var156 /* : String */; +val* var157 /* : Sys */; +static val* varonce158; +val* var159 /* : String */; +char* var160 /* : CString */; +val* var161 /* : String */; +val* var162 /* : nullable Int */; +val* var163 /* : nullable Int */; +val* var164 /* : nullable Bool */; +val* var165 /* : nullable Bool */; +val* var166 /* : Sys */; +static val* varonce167; +val* var168 /* : String */; +char* var169 /* : CString */; +val* var170 /* : String */; +val* var171 /* : nullable Int */; +val* var172 /* : nullable Int */; +val* var173 /* : nullable Bool */; +val* var174 /* : nullable Bool */; +val* var175 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var177 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_178 /* var : Map[MClass, Array[nullable MPropDef]] */; +val* var179 /* : MapIterator[nullable Object, nullable Object] */; +val* var_180 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; +short int var181 /* : Bool */; +val* var183 /* : nullable Object */; +val* var_t184 /* var t: MClass */; +val* var185 /* : nullable Object */; +val* var_table186 /* var table: Array[nullable MPropDef] */; +long var187 /* : Int */; +long var189 /* : Int */; +long var190 /* : Int */; +short int var192 /* : Bool */; +int cltype193; +int idtype194; +const char* var_class_name195; +long var196 /* : Int */; +val* var_197 /* var : Array[nullable MPropDef] */; +val* var198 /* : IndexedIterator[nullable Object] */; +val* var_199 /* var : IndexedIterator[nullable MPropDef] */; +short int var200 /* : Bool */; +val* var202 /* : nullable Object */; +val* var_e203 /* var e: nullable MPropDef */; +short int var204 /* : Bool */; +short int var205 /* : Bool */; +short int var207 /* : Bool */; +short int var209 /* : Bool */; +long var210 /* : Int */; +short int var212 /* : Bool */; +int cltype213; +int idtype214; +const char* var_class_name215; +long var216 /* : Int */; +val* var218 /* : Sys */; +val* var220 /* : NativeArray[String] */; +static val* varonce219; +static val* varonce221; +val* var222 /* : String */; +char* var223 /* : CString */; +val* var224 /* : String */; +val* var225 /* : nullable Int */; +val* var226 /* : nullable Int */; +val* var227 /* : nullable Bool */; +val* var228 /* : nullable Bool */; +static val* varonce229; +val* var230 /* : String */; +char* var231 /* : CString */; +val* var232 /* : String */; +val* var233 /* : nullable Int */; +val* var234 /* : nullable Int */; +val* var235 /* : nullable Bool */; +val* var236 /* : nullable Bool */; +val* var237 /* : String */; +val* var238 /* : String */; +val* var239 /* : String */; +val* var240 /* : Sys */; +static val* varonce241; +val* var242 /* : String */; +char* var243 /* : CString */; +val* var244 /* : String */; +val* var245 /* : nullable Int */; +val* var246 /* : nullable Int */; +val* var247 /* : nullable Bool */; +val* var248 /* : nullable Bool */; +val* var249 /* : Sys */; +static val* varonce250; +val* var251 /* : String */; +char* var252 /* : CString */; +val* var253 /* : String */; +val* var254 /* : nullable Int */; +val* var255 /* : nullable Int */; +val* var256 /* : nullable Bool */; +val* var257 /* : nullable Bool */; +val* var258 /* : Map[MClass, Array[nullable MProperty]] */; +val* var260 /* : Map[MClass, Array[nullable MProperty]] */; +val* var_261 /* var : Map[MClass, Array[nullable MProperty]] */; +val* var262 /* : MapIterator[nullable Object, nullable Object] */; +val* var_263 /* var : MapIterator[MClass, Array[nullable MProperty]] */; +short int var264 /* : Bool */; +val* var266 /* : nullable Object */; +val* var_t267 /* var t: MClass */; +val* var268 /* : nullable Object */; +val* var_table269 /* var table: Array[nullable MProperty] */; +long var270 /* : Int */; +long var272 /* : Int */; +long var273 /* : Int */; +short int var275 /* : Bool */; +int cltype276; +int idtype277; +const char* var_class_name278; +long var279 /* : Int */; +val* var_280 /* var : Array[nullable MProperty] */; +val* var281 /* : IndexedIterator[nullable Object] */; +val* var_282 /* var : IndexedIterator[nullable MProperty] */; +short int var283 /* : Bool */; +val* var285 /* : nullable Object */; +val* var_e286 /* var e: nullable MProperty */; +short int var287 /* : Bool */; +short int var288 /* : Bool */; +short int var290 /* : Bool */; +short int var292 /* : Bool */; +long var293 /* : Int */; +short int var295 /* : Bool */; +int cltype296; +int idtype297; +const char* var_class_name298; +long var299 /* : Int */; +val* var301 /* : Sys */; +val* var303 /* : NativeArray[String] */; +static val* varonce302; +static val* varonce304; +val* var305 /* : String */; +char* var306 /* : CString */; +val* var307 /* : String */; +val* var308 /* : nullable Int */; +val* var309 /* : nullable Int */; +val* var310 /* : nullable Bool */; +val* var311 /* : nullable Bool */; +static val* varonce312; +val* var313 /* : String */; +char* var314 /* : CString */; +val* var315 /* : String */; +val* var316 /* : nullable Int */; +val* var317 /* : nullable Int */; +val* var318 /* : nullable Bool */; +val* var319 /* : nullable Bool */; +val* var320 /* : String */; +val* var321 /* : String */; +val* var322 /* : String */; +var = glob_sys; +if (likely(varonce!=NULL)) { +var1 = varonce; +} else { +var2 = "# size of subtyping tables"; +var4 = (val*)(26l<<2|1); +var5 = (val*)(26l<<2|1); +var6 = (val*)((long)(0)<<2|3); +var7 = (val*)((long)(0)<<2|3); +var3 = core__flat___CString___to_s_unsafe(var2, var4, var5, var6, var7); +var1 = var3; +varonce = var1; +} +{ +core__file___Sys___print(var, var1); /* Direct call file$Sys$print on */ +} +var8 = glob_sys; +if (likely(varonce9!=NULL)) { +var10 = varonce9; +} else { +var11 = "\ttotal \tholes"; +var13 = (val*)(13l<<2|1); +var14 = (val*)(13l<<2|1); +var15 = (val*)((long)(0)<<2|3); +var16 = (val*)((long)(0)<<2|3); +var12 = core__flat___CString___to_s_unsafe(var11, var13, var14, var15, var16); +var10 = var12; +varonce9 = var10; +} +{ +core__file___Sys___print(var8, var10); /* Direct call file$Sys$print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_erasure_compiler$SeparateErasureCompiler$class_tables (self) on */ +var19 = self->attrs[COLOR_nitc__separate_erasure_compiler__SeparateErasureCompiler___class_tables].val; /* _class_tables on */ +if (unlikely(var19 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _class_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 427); +fatal_exit(1); +} +var17 = var19; +RET_LABEL18:(void)0; +} +} +var_ = var17; +{ +var20 = ((val*(*)(val* self))((((long)var_&3)?class_info[((long)var_&3)]:var_->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_); /* iterator on */ +} +var_21 = var20; +for(;;) { +{ +var22 = ((short int(*)(val* self))((((long)var_21&3)?class_info[((long)var_21&3)]:var_21->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_21); /* is_ok on */ +} +if (var22){ +} else { +goto BREAK_label; +} +{ +var23 = ((val*(*)(val* self))((((long)var_21&3)?class_info[((long)var_21&3)]:var_21->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_21); /* key on */ +} +var_t = var23; +{ +var24 = ((val*(*)(val* self))((((long)var_21&3)?class_info[((long)var_21&3)]:var_21->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_21); /* item on */ +} +var_table = var24; +{ +{ /* Inline array$AbstractArrayRead$length (var_table) on */ +var27 = var_table->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var25 = var27; +RET_LABEL26:(void)0; +} +} +{ +{ /* Inline kernel$Int$+ (var_total,var25) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var30 = 1; /* easy isa OTHER*/ +if (unlikely(!var30)) { +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); +} +var31 = var_total + var25; +var28 = var31; +goto RET_LABEL29; +RET_LABEL29:(void)0; +} +} +var_total = var28; +var_32 = var_table; +{ +var33 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_32); +} +var_34 = var33; +for(;;) { +{ +var35 = ((short int(*)(val* self))((((long)var_34&3)?class_info[((long)var_34&3)]:var_34->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_34); /* is_ok on */ +} +if (var35){ +} else { +goto BREAK_label36; +} +{ +var37 = ((val*(*)(val* self))((((long)var_34&3)?class_info[((long)var_34&3)]:var_34->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_34); /* item on */ +} +var_e = var37; +if (var_e == NULL) { +var38 = 1; /* is null */ +} else { +var38 = 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 */ +var43 = var_e == var_other; +var41 = var43; +goto RET_LABEL42; +RET_LABEL42:(void)0; +} +} +var39 = var41; +goto RET_LABEL40; +RET_LABEL40:(void)0; +} +var38 = var39; +} +if (var38){ +{ +{ /* Inline kernel$Int$+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var46 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var46)) { +var_class_name49 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name49); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var50 = var_holes + 1l; +var44 = var50; +goto RET_LABEL45; +RET_LABEL45:(void)0; +} +} +var_holes = var44; +} else { +} +{ +((void(*)(val* self))((((long)var_34&3)?class_info[((long)var_34&3)]:var_34->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_34); /* next on */ +} +} +BREAK_label36: (void)0; +{ +((void(*)(val* self))((((long)var_34&3)?class_info[((long)var_34&3)]:var_34->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_34); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_21&3)?class_info[((long)var_21&3)]:var_21->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_21); /* next on */ +} +} +BREAK_label: (void)0; +{ +{ /* Inline abstract_collection$MapIterator$finish (var_21) on */ +RET_LABEL51:(void)0; +} +} +var52 = glob_sys; +if (unlikely(varonce53==NULL)) { +var54 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce55!=NULL)) { +var56 = varonce55; +} else { +var57 = "\t"; +var59 = (val*)(1l<<2|1); +var60 = (val*)(1l<<2|1); +var61 = (val*)((long)(0)<<2|3); +var62 = (val*)((long)(0)<<2|3); +var58 = core__flat___CString___to_s_unsafe(var57, var59, var60, var61, var62); +var56 = var58; +varonce55 = var56; +} +((struct instance_core__NativeArray*)var54)->values[0]=var56; +if (likely(varonce63!=NULL)) { +var64 = varonce63; +} else { +var65 = "\t"; +var67 = (val*)(1l<<2|1); +var68 = (val*)(1l<<2|1); +var69 = (val*)((long)(0)<<2|3); +var70 = (val*)((long)(0)<<2|3); +var66 = core__flat___CString___to_s_unsafe(var65, var67, var68, var69, var70); +var64 = var66; +varonce63 = var64; +} +((struct instance_core__NativeArray*)var54)->values[2]=var64; +} else { +var54 = varonce53; +varonce53 = NULL; +} +var71 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var54)->values[1]=var71; +var72 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var54)->values[3]=var72; +{ +var73 = ((val*(*)(val* self))(var54->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var54); /* native_to_s on */ +} +varonce53 = var54; +{ +core__file___Sys___print(var52, var73); /* Direct call file$Sys$print on */ +} +var74 = glob_sys; +if (likely(varonce75!=NULL)) { +var76 = varonce75; +} else { +var77 = "# size of resolution tables"; +var79 = (val*)(27l<<2|1); +var80 = (val*)(27l<<2|1); +var81 = (val*)((long)(0)<<2|3); +var82 = (val*)((long)(0)<<2|3); +var78 = core__flat___CString___to_s_unsafe(var77, var79, var80, var81, var82); +var76 = var78; +varonce75 = var76; +} +{ +core__file___Sys___print(var74, var76); /* Direct call file$Sys$print on */ +} +var83 = glob_sys; +if (likely(varonce84!=NULL)) { +var85 = varonce84; +} else { +var86 = "\ttotal \tholes"; +var88 = (val*)(13l<<2|1); +var89 = (val*)(13l<<2|1); +var90 = (val*)((long)(0)<<2|3); +var91 = (val*)((long)(0)<<2|3); +var87 = core__flat___CString___to_s_unsafe(var86, var88, var89, var90, var91); +var85 = var87; +varonce84 = var85; +} +{ +core__file___Sys___print(var83, var85); /* Direct call file$Sys$print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_erasure_compiler$SeparateErasureCompiler$vt_tables (self) on */ +var94 = self->attrs[COLOR_nitc__separate_erasure_compiler__SeparateErasureCompiler___vt_tables].val; /* _vt_tables on */ +if (unlikely(var94 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _vt_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 428); +fatal_exit(1); +} +var92 = var94; +RET_LABEL93:(void)0; +} +} +var_95 = var92; +{ +var96 = ((val*(*)(val* self))((((long)var_95&3)?class_info[((long)var_95&3)]:var_95->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_95); /* iterator on */ +} +var_97 = var96; +for(;;) { +{ +var98 = ((short int(*)(val* self))((((long)var_97&3)?class_info[((long)var_97&3)]:var_97->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_97); /* is_ok on */ +} +if (var98){ +} else { +goto BREAK_label99; +} +{ +var100 = ((val*(*)(val* self))((((long)var_97&3)?class_info[((long)var_97&3)]:var_97->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_97); /* key on */ +} +var_t101 = var100; +{ +var102 = ((val*(*)(val* self))((((long)var_97&3)?class_info[((long)var_97&3)]:var_97->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_97); /* item on */ +} +var_table103 = var102; +{ +{ /* Inline array$AbstractArrayRead$length (var_table103) on */ +var106 = var_table103->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var104 = var106; +RET_LABEL105:(void)0; +} +} +{ +{ /* Inline kernel$Int$+ (var_total,var104) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var109 = 1; /* easy isa OTHER*/ +if (unlikely(!var109)) { +var_class_name112 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name112); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var113 = var_total + var104; +var107 = var113; +goto RET_LABEL108; +RET_LABEL108:(void)0; +} +} +var_total = var107; +var_114 = var_table103; +{ +var115 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_114); +} +var_116 = var115; +for(;;) { +{ +var117 = ((short int(*)(val* self))((((long)var_116&3)?class_info[((long)var_116&3)]:var_116->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_116); /* is_ok on */ +} +if (var117){ +} else { +goto BREAK_label118; +} +{ +var119 = ((val*(*)(val* self))((((long)var_116&3)?class_info[((long)var_116&3)]:var_116->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_116); /* item on */ +} +var_e120 = var119; +if (var_e120 == NULL) { +var121 = 1; /* is null */ +} else { +var121 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel$Object$== (var_e120,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel$Object$is_same_instance (var_e120,var_other) on */ +var126 = var_e120 == var_other; +var124 = var126; +goto RET_LABEL125; +RET_LABEL125:(void)0; +} +} +var122 = var124; +goto RET_LABEL123; +RET_LABEL123:(void)0; +} +var121 = var122; +} +if (var121){ +{ +{ /* Inline kernel$Int$+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var129 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var129)) { +var_class_name132 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name132); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var133 = var_holes + 1l; +var127 = var133; +goto RET_LABEL128; +RET_LABEL128:(void)0; +} +} +var_holes = var127; +} else { +} +{ +((void(*)(val* self))((((long)var_116&3)?class_info[((long)var_116&3)]:var_116->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_116); /* next on */ +} +} +BREAK_label118: (void)0; +{ +((void(*)(val* self))((((long)var_116&3)?class_info[((long)var_116&3)]:var_116->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_116); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_97&3)?class_info[((long)var_97&3)]:var_97->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_97); /* next on */ +} +} +BREAK_label99: (void)0; +{ +{ /* Inline abstract_collection$MapIterator$finish (var_97) on */ +RET_LABEL134:(void)0; +} +} +var135 = glob_sys; +if (unlikely(varonce136==NULL)) { +var137 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce138!=NULL)) { +var139 = varonce138; +} else { +var140 = "\t"; +var142 = (val*)(1l<<2|1); +var143 = (val*)(1l<<2|1); +var144 = (val*)((long)(0)<<2|3); +var145 = (val*)((long)(0)<<2|3); +var141 = core__flat___CString___to_s_unsafe(var140, var142, var143, var144, var145); +var139 = var141; +varonce138 = var139; +} +((struct instance_core__NativeArray*)var137)->values[0]=var139; +if (likely(varonce146!=NULL)) { +var147 = varonce146; +} else { +var148 = "\t"; +var150 = (val*)(1l<<2|1); +var151 = (val*)(1l<<2|1); +var152 = (val*)((long)(0)<<2|3); +var153 = (val*)((long)(0)<<2|3); +var149 = core__flat___CString___to_s_unsafe(var148, var150, var151, var152, var153); +var147 = var149; +varonce146 = var147; +} +((struct instance_core__NativeArray*)var137)->values[2]=var147; +} else { +var137 = varonce136; +varonce136 = NULL; +} +var154 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var137)->values[1]=var154; +var155 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var137)->values[3]=var155; +{ +var156 = ((val*(*)(val* self))(var137->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var137); /* native_to_s on */ +} +varonce136 = var137; +{ +core__file___Sys___print(var135, var156); /* Direct call file$Sys$print on */ +} +var157 = glob_sys; +if (likely(varonce158!=NULL)) { +var159 = varonce158; +} else { +var160 = "# size of methods tables"; +var162 = (val*)(24l<<2|1); +var163 = (val*)(24l<<2|1); +var164 = (val*)((long)(0)<<2|3); +var165 = (val*)((long)(0)<<2|3); +var161 = core__flat___CString___to_s_unsafe(var160, var162, var163, var164, var165); +var159 = var161; +varonce158 = var159; +} +{ +core__file___Sys___print(var157, var159); /* Direct call file$Sys$print on */ +} +var166 = glob_sys; +if (likely(varonce167!=NULL)) { +var168 = varonce167; +} else { +var169 = "\ttotal \tholes"; +var171 = (val*)(13l<<2|1); +var172 = (val*)(13l<<2|1); +var173 = (val*)((long)(0)<<2|3); +var174 = (val*)((long)(0)<<2|3); +var170 = core__flat___CString___to_s_unsafe(var169, var171, var172, var173, var174); +var168 = var170; +varonce167 = var168; +} +{ +core__file___Sys___print(var166, var168); /* Direct call file$Sys$print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler$SeparateCompiler$method_tables (self) on */ +var177 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var177 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1073); +fatal_exit(1); +} +var175 = var177; +RET_LABEL176:(void)0; +} +} +var_178 = var175; +{ +var179 = ((val*(*)(val* self))((((long)var_178&3)?class_info[((long)var_178&3)]:var_178->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_178); /* iterator on */ +} +var_180 = var179; +for(;;) { +{ +var181 = ((short int(*)(val* self))((((long)var_180&3)?class_info[((long)var_180&3)]:var_180->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_180); /* is_ok on */ +} +if (var181){ +} else { +goto BREAK_label182; +} +{ +var183 = ((val*(*)(val* self))((((long)var_180&3)?class_info[((long)var_180&3)]:var_180->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_180); /* key on */ +} +var_t184 = var183; +{ +var185 = ((val*(*)(val* self))((((long)var_180&3)?class_info[((long)var_180&3)]:var_180->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_180); /* item on */ +} +var_table186 = var185; +{ +{ /* Inline array$AbstractArrayRead$length (var_table186) on */ +var189 = var_table186->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var187 = var189; +RET_LABEL188:(void)0; +} +} +{ +{ /* Inline kernel$Int$+ (var_total,var187) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var192 = 1; /* easy isa OTHER*/ +if (unlikely(!var192)) { +var_class_name195 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name195); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var196 = var_total + var187; +var190 = var196; +goto RET_LABEL191; +RET_LABEL191:(void)0; +} +} +var_total = var190; +var_197 = var_table186; +{ +var198 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_197); +} +var_199 = var198; +for(;;) { +{ +var200 = ((short int(*)(val* self))((((long)var_199&3)?class_info[((long)var_199&3)]:var_199->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_199); /* is_ok on */ +} +if (var200){ +} else { +goto BREAK_label201; +} +{ +var202 = ((val*(*)(val* self))((((long)var_199&3)?class_info[((long)var_199&3)]:var_199->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_199); /* item on */ +} +var_e203 = var202; +if (var_e203 == NULL) { +var204 = 1; /* is null */ +} else { +var204 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel$Object$== (var_e203,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel$Object$is_same_instance (var_e203,var_other) on */ +var209 = var_e203 == var_other; +var207 = var209; +goto RET_LABEL208; +RET_LABEL208:(void)0; +} +} +var205 = var207; +goto RET_LABEL206; +RET_LABEL206:(void)0; +} +var204 = var205; +} +if (var204){ +{ +{ /* Inline kernel$Int$+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var212 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var212)) { +var_class_name215 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name215); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var216 = var_holes + 1l; +var210 = var216; +goto RET_LABEL211; +RET_LABEL211:(void)0; +} +} +var_holes = var210; +} else { +} +{ +((void(*)(val* self))((((long)var_199&3)?class_info[((long)var_199&3)]:var_199->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_199); /* next on */ +} +} +BREAK_label201: (void)0; +{ +((void(*)(val* self))((((long)var_199&3)?class_info[((long)var_199&3)]:var_199->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_199); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_180&3)?class_info[((long)var_180&3)]:var_180->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_180); /* next on */ +} +} +BREAK_label182: (void)0; +{ +{ /* Inline abstract_collection$MapIterator$finish (var_180) on */ +RET_LABEL217:(void)0; +} +} +var218 = glob_sys; +if (unlikely(varonce219==NULL)) { +var220 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce221!=NULL)) { +var222 = varonce221; +} else { +var223 = "\t"; +var225 = (val*)(1l<<2|1); +var226 = (val*)(1l<<2|1); +var227 = (val*)((long)(0)<<2|3); +var228 = (val*)((long)(0)<<2|3); +var224 = core__flat___CString___to_s_unsafe(var223, var225, var226, var227, var228); +var222 = var224; +varonce221 = var222; +} +((struct instance_core__NativeArray*)var220)->values[0]=var222; +if (likely(varonce229!=NULL)) { +var230 = varonce229; +} else { +var231 = "\t"; +var233 = (val*)(1l<<2|1); +var234 = (val*)(1l<<2|1); +var235 = (val*)((long)(0)<<2|3); +var236 = (val*)((long)(0)<<2|3); +var232 = core__flat___CString___to_s_unsafe(var231, var233, var234, var235, var236); +var230 = var232; +varonce229 = var230; +} +((struct instance_core__NativeArray*)var220)->values[2]=var230; +} else { +var220 = varonce219; +varonce219 = NULL; +} +var237 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var220)->values[1]=var237; +var238 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var220)->values[3]=var238; +{ +var239 = ((val*(*)(val* self))(var220->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var220); /* native_to_s on */ +} +varonce219 = var220; +{ +core__file___Sys___print(var218, var239); /* Direct call file$Sys$print on */ +} +var240 = glob_sys; +if (likely(varonce241!=NULL)) { +var242 = varonce241; +} else { +var243 = "# size of attributes tables"; +var245 = (val*)(27l<<2|1); +var246 = (val*)(27l<<2|1); +var247 = (val*)((long)(0)<<2|3); +var248 = (val*)((long)(0)<<2|3); +var244 = core__flat___CString___to_s_unsafe(var243, var245, var246, var247, var248); +var242 = var244; +varonce241 = var242; +} +{ +core__file___Sys___print(var240, var242); /* Direct call file$Sys$print on */ +} +var249 = glob_sys; +if (likely(varonce250!=NULL)) { +var251 = varonce250; +} else { +var252 = "\ttotal \tholes"; +var254 = (val*)(13l<<2|1); +var255 = (val*)(13l<<2|1); +var256 = (val*)((long)(0)<<2|3); +var257 = (val*)((long)(0)<<2|3); +var253 = core__flat___CString___to_s_unsafe(var252, var254, var255, var256, var257); +var251 = var253; +varonce250 = var251; +} +{ +core__file___Sys___print(var249, var251); /* Direct call file$Sys$print on */ +} +var_total = 0l; +var_holes = 0l; +{ +{ /* Inline separate_compiler$SeparateCompiler$attr_tables (self) on */ +var260 = self->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var260 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_compiler, 1074); +fatal_exit(1); +} +var258 = var260; +RET_LABEL259:(void)0; +} +} +var_261 = var258; +{ +var262 = ((val*(*)(val* self))((((long)var_261&3)?class_info[((long)var_261&3)]:var_261->class)->vft[COLOR_core__abstract_collection__MapRead__iterator]))(var_261); /* iterator on */ +} +var_263 = var262; +for(;;) { +{ +var264 = ((short int(*)(val* self))((((long)var_263&3)?class_info[((long)var_263&3)]:var_263->class)->vft[COLOR_core__abstract_collection__MapIterator__is_ok]))(var_263); /* is_ok on */ +} +if (var264){ +} else { +goto BREAK_label265; +} +{ +var266 = ((val*(*)(val* self))((((long)var_263&3)?class_info[((long)var_263&3)]:var_263->class)->vft[COLOR_core__abstract_collection__MapIterator__key]))(var_263); /* key on */ +} +var_t267 = var266; +{ +var268 = ((val*(*)(val* self))((((long)var_263&3)?class_info[((long)var_263&3)]:var_263->class)->vft[COLOR_core__abstract_collection__MapIterator__item]))(var_263); /* item on */ +} +var_table269 = var268; +{ +{ /* Inline array$AbstractArrayRead$length (var_table269) on */ +var272 = var_table269->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on */ +var270 = var272; +RET_LABEL271:(void)0; +} +} +{ +{ /* Inline kernel$Int$+ (var_total,var270) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var275 = 1; /* easy isa OTHER*/ +if (unlikely(!var275)) { +var_class_name278 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name278); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var279 = var_total + var270; +var273 = var279; +goto RET_LABEL274; +RET_LABEL274:(void)0; +} +} +var_total = var273; +var_280 = var_table269; +{ +var281 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_280); +} +var_282 = var281; +for(;;) { +{ +var283 = ((short int(*)(val* self))((((long)var_282&3)?class_info[((long)var_282&3)]:var_282->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_282); /* is_ok on */ +} +if (var283){ +} else { +goto BREAK_label284; +} +{ +var285 = ((val*(*)(val* self))((((long)var_282&3)?class_info[((long)var_282&3)]:var_282->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_282); /* item on */ +} +var_e286 = var285; +if (var_e286 == NULL) { +var287 = 1; /* is null */ +} else { +var287 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel$Object$== (var_e286,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel$Object$is_same_instance (var_e286,var_other) on */ +var292 = var_e286 == var_other; +var290 = var292; +goto RET_LABEL291; +RET_LABEL291:(void)0; +} +} +var288 = var290; +goto RET_LABEL289; +RET_LABEL289:(void)0; +} +var287 = var288; +} +if (var287){ +{ +{ /* Inline kernel$Int$+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var295 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var295)) { +var_class_name298 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name298); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); +fatal_exit(1); +} +var299 = var_holes + 1l; +var293 = var299; +goto RET_LABEL294; +RET_LABEL294:(void)0; +} +} +var_holes = var293; +} else { +} +{ +((void(*)(val* self))((((long)var_282&3)?class_info[((long)var_282&3)]:var_282->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_282); /* next on */ +} +} +BREAK_label284: (void)0; +{ +((void(*)(val* self))((((long)var_282&3)?class_info[((long)var_282&3)]:var_282->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_282); /* finish on */ +} +{ +((void(*)(val* self))((((long)var_263&3)?class_info[((long)var_263&3)]:var_263->class)->vft[COLOR_core__abstract_collection__MapIterator__next]))(var_263); /* next on */ +} +} +BREAK_label265: (void)0; +{ +{ /* Inline abstract_collection$MapIterator$finish (var_263) on */ +RET_LABEL300:(void)0; +} +} +var301 = glob_sys; +if (unlikely(varonce302==NULL)) { +var303 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce304!=NULL)) { +var305 = varonce304; +} else { +var306 = "\t"; +var308 = (val*)(1l<<2|1); +var309 = (val*)(1l<<2|1); +var310 = (val*)((long)(0)<<2|3); +var311 = (val*)((long)(0)<<2|3); +var307 = core__flat___CString___to_s_unsafe(var306, var308, var309, var310, var311); +var305 = var307; +varonce304 = var305; +} +((struct instance_core__NativeArray*)var303)->values[0]=var305; +if (likely(varonce312!=NULL)) { +var313 = varonce312; +} else { +var314 = "\t"; +var316 = (val*)(1l<<2|1); +var317 = (val*)(1l<<2|1); +var318 = (val*)((long)(0)<<2|3); +var319 = (val*)((long)(0)<<2|3); +var315 = core__flat___CString___to_s_unsafe(var314, var316, var317, var318, var319); +var313 = var315; +varonce312 = var313; +} +((struct instance_core__NativeArray*)var303)->values[2]=var313; +} else { +var303 = varonce302; +varonce302 = NULL; +} +var320 = core__flat___Int___core__abstract_text__Object__to_s(var_total); +((struct instance_core__NativeArray*)var303)->values[1]=var320; +var321 = core__flat___Int___core__abstract_text__Object__to_s(var_holes); +((struct instance_core__NativeArray*)var303)->values[3]=var321; +{ +var322 = ((val*(*)(val* self))(var303->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var303); /* native_to_s on */ +} +varonce302 = var303; +{ +core__file___Sys___print(var301, var322); /* Direct call file$Sys$print on */ +} +RET_LABEL:; +} +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$compile_callsite for (self: SeparateErasureCompilerVisitor, CallSite, Array[RuntimeVariable]): nullable RuntimeVariable */ +val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__compile_callsite(val* self, val* p0, val* p1) { +val* var /* : nullable RuntimeVariable */; +val* var_callsite /* var callsite: CallSite */; +val* var_arguments /* var arguments: Array[RuntimeVariable] */; +val* var1 /* : nullable RuntimeVariable */; +val* var_res /* var res: nullable RuntimeVariable */; +short int var2 /* : Bool */; +short int var3 /* : Bool */; +short int var5 /* : Bool */; +short int var_ /* var : Bool */; +val* var6 /* : AbstractCompiler */; +val* var8 /* : AbstractCompiler */; +short int var9 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +val* var10 /* : ModelBuilder */; +val* var12 /* : ModelBuilder */; +val* var13 /* : ToolContext */; +val* var15 /* : ToolContext */; +val* var16 /* : OptionBool */; +val* var18 /* : OptionBool */; +val* var19 /* : nullable Object */; +val* var21 /* : nullable Object */; +short int var22 /* : Bool */; +short int var23 /* : Bool */; +short int var24 /* : Bool */; +short int var25 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var27 /* : Bool */; +short int var28 /* : Bool */; +val* var29 /* : MSignature */; +val* var31 /* : MSignature */; +val* var32 /* : nullable MType */; +val* var34 /* : nullable MType */; +val* var_mtype /* var mtype: nullable MType */; +short int var35 /* : Bool */; +short int var36 /* : Bool */; +short int var38 /* : Bool */; +short int var39 /* : Bool */; +val* var40 /* : NativeArray[String] */; +static val* varonce; +static val* varonce41; +val* var42 /* : String */; +char* var43 /* : CString */; +val* var44 /* : String */; +val* var45 /* : nullable Int */; +val* var46 /* : nullable Int */; +val* var47 /* : nullable Bool */; +val* var48 /* : nullable Bool */; +static val* varonce49; +val* var50 /* : String */; +char* var51 /* : CString */; +val* var52 /* : String */; +val* var53 /* : nullable Int */; +val* var54 /* : nullable Int */; +val* var55 /* : nullable Bool */; +val* var56 /* : nullable Bool */; +static val* varonce57; +val* var58 /* : String */; +char* var59 /* : CString */; +val* var60 /* : String */; +val* var61 /* : nullable Int */; +val* var62 /* : nullable Int */; +val* var63 /* : nullable Bool */; +val* var64 /* : nullable Bool */; +val* var65 /* : String */; +val* var66 /* : String */; +val* var67 /* : String */; +static val* varonce68; +val* var69 /* : String */; +char* var70 /* : CString */; +val* var71 /* : String */; +val* var72 /* : nullable Int */; +val* var73 /* : nullable Int */; +val* var74 /* : nullable Bool */; +val* var75 /* : nullable Bool */; +val* var76 /* : RuntimeVariable */; +val* var_cond /* var cond: RuntimeVariable */; +val* var78 /* : NativeArray[String] */; +static val* varonce77; +static val* varonce79; +val* var80 /* : String */; +char* var81 /* : CString */; +val* var82 /* : String */; +val* var83 /* : nullable Int */; +val* var84 /* : nullable Int */; +val* var85 /* : nullable Bool */; +val* var86 /* : nullable Bool */; +static val* varonce87; +val* var88 /* : String */; +char* var89 /* : CString */; +val* var90 /* : String */; +val* var91 /* : nullable Int */; +val* var92 /* : nullable Int */; +val* var93 /* : nullable Bool */; +val* var94 /* : nullable Bool */; +val* var95 /* : String */; +val* var96 /* : String */; +static val* varonce97; +val* var98 /* : String */; +char* var99 /* : CString */; +val* var100 /* : String */; +val* var101 /* : nullable Int */; +val* var102 /* : nullable Int */; +val* var103 /* : nullable Bool */; +val* var104 /* : nullable Bool */; +static val* varonce105; +val* var106 /* : String */; +char* var107 /* : CString */; +val* var108 /* : String */; +val* var109 /* : nullable Int */; +val* var110 /* : nullable Int */; +val* var111 /* : nullable Bool */; +val* var112 /* : nullable Bool */; +var_callsite = p0; +var_arguments = p1; +{ +var1 = ((val*(*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__compile_callsite]))(self, p0, p1); /* compile_callsite on */ +} +var_res = var1; +{ +{ /* Inline typing$CallSite$erasure_cast (var_callsite) on */ +var5 = var_callsite->attrs[COLOR_nitc__typing__CallSite___erasure_cast].s; /* _erasure_cast on */ +var3 = var5; +RET_LABEL4:(void)0; +} +} +var_ = var3; +if (var3){ +{ +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var8 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var8 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); +fatal_exit(1); +} +var6 = var8; +RET_LABEL7:(void)0; +} +} +/* isa SeparateErasureCompiler */ +cltype = type_nitc__SeparateErasureCompiler.color; +idtype = type_nitc__SeparateErasureCompiler.id; +if(cltype >= var6->type->table_size) { +var9 = 0; +} else { +var9 = var6->type->type_table[cltype] == idtype; +} +if (unlikely(!var9)) { +var_class_name = var6 == NULL ? "null" : var6->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "SeparateErasureCompiler", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 480); +fatal_exit(1); +} +{ +{ /* Inline abstract_compiler$AbstractCompiler$modelbuilder (var6) on */ +var12 = var6->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var12 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 552); +fatal_exit(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +{ /* Inline modelbuilder_base$ModelBuilder$toolcontext (var10) on */ +var15 = var10->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var15 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47); +fatal_exit(1); +} +var13 = var15; +RET_LABEL14:(void)0; +} +} +{ +{ /* Inline separate_erasure_compiler$ToolContext$opt_no_check_erasure_cast (var13) on */ +var18 = var13->attrs[COLOR_nitc__separate_erasure_compiler__ToolContext___opt_no_check_erasure_cast].val; /* _opt_no_check_erasure_cast on */ +if (unlikely(var18 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_check_erasure_cast"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 26); +fatal_exit(1); +} +var16 = var18; +RET_LABEL17:(void)0; +} +} +{ +{ /* Inline opts$Option$value (var16) on */ +var21 = var16->attrs[COLOR_opts__Option___value].val; /* _value on */ +var19 = var21; +RET_LABEL20:(void)0; +} +} +var22 = (short int)((long)(var19)>>2); +var23 = !var22; +var2 = var23; +} else { +var2 = var_; +} +if (var2){ +if (var_res == NULL) { +var24 = 0; /* is null */ +} else { +var24 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel$Object$!= (var_res,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var27 = ((short int(*)(val* self, val* p0))(var_res->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_res, var_other); /* == on */ +} +var28 = !var27; +var25 = var28; +goto RET_LABEL26; +RET_LABEL26:(void)0; +} +var24 = var25; +} +if (unlikely(!var24)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 481); +fatal_exit(1); +} +{ +{ /* Inline typing$CallSite$msignature (var_callsite) on */ +var31 = var_callsite->attrs[COLOR_nitc__typing__CallSite___msignature].val; /* _msignature on */ +if (unlikely(var31 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _msignature"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 663); +fatal_exit(1); +} +var29 = var31; +RET_LABEL30:(void)0; +} +} +{ +{ /* Inline model$MSignature$return_mtype (var29) on */ +var34 = var29->attrs[COLOR_nitc__model__MSignature___return_mtype].val; /* _return_mtype on */ +var32 = var34; +RET_LABEL33:(void)0; +} +} +var_mtype = var32; +if (var_mtype == NULL) { +var35 = 0; /* is null */ +} else { +var35 = 1; /* arg is null and recv is not */ +} +if (0) { +{ /* Inline kernel$Object$!= (var_mtype,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +var38 = ((short int(*)(val* self, val* p0))(var_mtype->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_mtype, var_other); /* == on */ +} +var39 = !var38; +var36 = var39; +goto RET_LABEL37; +RET_LABEL37:(void)0; +} +var35 = var36; +} +if (unlikely(!var35)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Assert failed"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 483); +fatal_exit(1); +} +if (unlikely(varonce==NULL)) { +var40 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String); +if (likely(varonce41!=NULL)) { +var42 = varonce41; +} else { +var43 = "/* Erasure cast for return "; +var45 = (val*)(27l<<2|1); +var46 = (val*)(27l<<2|1); +var47 = (val*)((long)(0)<<2|3); +var48 = (val*)((long)(0)<<2|3); +var44 = core__flat___CString___to_s_unsafe(var43, var45, var46, var47, var48); +var42 = var44; +varonce41 = var42; +} +((struct instance_core__NativeArray*)var40)->values[0]=var42; +if (likely(varonce49!=NULL)) { +var50 = varonce49; +} else { +var51 = " isa "; +var53 = (val*)(5l<<2|1); +var54 = (val*)(5l<<2|1); +var55 = (val*)((long)(0)<<2|3); +var56 = (val*)((long)(0)<<2|3); +var52 = core__flat___CString___to_s_unsafe(var51, var53, var54, var55, var56); +var50 = var52; +varonce49 = var50; +} +((struct instance_core__NativeArray*)var40)->values[2]=var50; +if (likely(varonce57!=NULL)) { +var58 = varonce57; +} else { +var59 = " */"; +var61 = (val*)(3l<<2|1); +var62 = (val*)(3l<<2|1); +var63 = (val*)((long)(0)<<2|3); +var64 = (val*)((long)(0)<<2|3); +var60 = core__flat___CString___to_s_unsafe(var59, var61, var62, var63, var64); +var58 = var60; +varonce57 = var58; +} +((struct instance_core__NativeArray*)var40)->values[4]=var58; +} else { +var40 = varonce; +varonce = NULL; +} +{ +var65 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_core__NativeArray*)var40)->values[1]=var65; +{ +var66 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +} +((struct instance_core__NativeArray*)var40)->values[3]=var66; +{ +var67 = ((val*(*)(val* self))(var40->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var40); /* native_to_s on */ +} +varonce = var40; +{ +nitc___nitc__AbstractCompilerVisitor___add(self, var67); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ +} +if (likely(varonce68!=NULL)) { +var69 = varonce68; +} else { +var70 = "erasure"; +var72 = (val*)(7l<<2|1); +var73 = (val*)(7l<<2|1); +var74 = (val*)((long)(0)<<2|3); +var75 = (val*)((long)(0)<<2|3); +var71 = core__flat___CString___to_s_unsafe(var70, var72, var73, var74, var75); +var69 = var71; +varonce68 = var69; +} +{ +var76 = nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__type_test(self, var_res, var_mtype, var69); +} +var_cond = var76; +if (unlikely(varonce77==NULL)) { +var78 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce79!=NULL)) { +var80 = varonce79; +} else { +var81 = "if (!"; +var83 = (val*)(5l<<2|1); +var84 = (val*)(5l<<2|1); +var85 = (val*)((long)(0)<<2|3); +var86 = (val*)((long)(0)<<2|3); +var82 = core__flat___CString___to_s_unsafe(var81, var83, var84, var85, var86); +var80 = var82; +varonce79 = var80; +} +((struct instance_core__NativeArray*)var78)->values[0]=var80; +if (likely(varonce87!=NULL)) { +var88 = varonce87; +} else { +var89 = ") {"; +var91 = (val*)(3l<<2|1); +var92 = (val*)(3l<<2|1); +var93 = (val*)((long)(0)<<2|3); +var94 = (val*)((long)(0)<<2|3); +var90 = core__flat___CString___to_s_unsafe(var89, var91, var92, var93, var94); +var88 = var90; +varonce87 = var88; +} +((struct instance_core__NativeArray*)var78)->values[2]=var88; +} else { +var78 = varonce77; +varonce77 = NULL; +} +{ +var95 = ((val*(*)(val* self))(var_cond->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_cond); /* to_s on */ +} +((struct instance_core__NativeArray*)var78)->values[1]=var95; +{ +var96 = ((val*(*)(val* self))(var78->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var78); /* native_to_s on */ +} +varonce77 = var78; +{ +nitc___nitc__AbstractCompilerVisitor___add(self, var96); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ +} +if (likely(varonce97!=NULL)) { +var98 = varonce97; +} else { +var99 = "Cast failed"; +var101 = (val*)(11l<<2|1); +var102 = (val*)(11l<<2|1); +var103 = (val*)((long)(0)<<2|3); +var104 = (val*)((long)(0)<<2|3); +var100 = core__flat___CString___to_s_unsafe(var99, var101, var102, var103, var104); +var98 = var100; +varonce97 = var98; +} +{ +nitc___nitc__AbstractCompilerVisitor___add_abort(self, var98); /* Direct call abstract_compiler$AbstractCompilerVisitor$add_abort on */ +} +if (likely(varonce105!=NULL)) { +var106 = varonce105; +} else { +var107 = "}"; +var109 = (val*)(1l<<2|1); +var110 = (val*)(1l<<2|1); +var111 = (val*)((long)(0)<<2|3); +var112 = (val*)((long)(0)<<2|3); +var108 = core__flat___CString___to_s_unsafe(var107, var109, var110, var111, var112); +var106 = var108; +varonce105 = var106; +} +{ +nitc___nitc__AbstractCompilerVisitor___add(self, var106); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ +} +} else { +} +var = var_res; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$init_instance for (self: SeparateErasureCompilerVisitor, MClassType): RuntimeVariable */ +val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__init_instance(val* self, val* p0) { +val* var /* : RuntimeVariable */; +val* var_mtype /* var mtype: MClassType */; +val* var1 /* : NativeArray[String] */; +static val* varonce; +static val* varonce2; +val* var3 /* : String */; +char* var4 /* : CString */; +val* var5 /* : String */; +val* var6 /* : nullable Int */; +val* var7 /* : nullable Int */; +val* var8 /* : nullable Bool */; +val* var9 /* : nullable Bool */; +val* var10 /* : MClass */; +val* var12 /* : MClass */; +val* var13 /* : String */; +val* var14 /* : String */; +val* var16 /* : NativeArray[String] */; +static val* varonce15; +static val* varonce17; +val* var18 /* : String */; +char* var19 /* : CString */; +val* var20 /* : String */; +val* var21 /* : nullable Int */; +val* var22 /* : nullable Int */; +val* var23 /* : nullable Bool */; +val* var24 /* : nullable Bool */; +static val* varonce25; +val* var26 /* : String */; +char* var27 /* : CString */; +val* var28 /* : String */; +val* var29 /* : nullable Int */; +val* var30 /* : nullable Int */; +val* var31 /* : nullable Bool */; +val* var32 /* : nullable Bool */; +val* var33 /* : MClass */; +val* var35 /* : MClass */; +val* var36 /* : String */; +val* var37 /* : String */; +val* var38 /* : RuntimeVariable */; +var_mtype = p0; +if (unlikely(varonce==NULL)) { +var1 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce2!=NULL)) { +var3 = varonce2; +} else { +var4 = "NEW_"; +var6 = (val*)(4l<<2|1); +var7 = (val*)(4l<<2|1); +var8 = (val*)((long)(0)<<2|3); +var9 = (val*)((long)(0)<<2|3); +var5 = core__flat___CString___to_s_unsafe(var4, var6, var7, var8, var9); +var3 = var5; +varonce2 = var3; +} +((struct instance_core__NativeArray*)var1)->values[0]=var3; +} else { +var1 = varonce; +varonce = NULL; +} +{ +{ /* Inline model$MClassType$mclass (var_mtype) on */ +var12 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var12 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); +fatal_exit(1); +} +var10 = var12; +RET_LABEL11:(void)0; +} +} +{ +var13 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var10); +} +((struct instance_core__NativeArray*)var1)->values[1]=var13; +{ +var14 = ((val*(*)(val* self))(var1->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1); /* native_to_s on */ +} +varonce = var1; +{ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var14); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ +} +if (unlikely(varonce15==NULL)) { +var16 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce17!=NULL)) { +var18 = varonce17; +} else { +var19 = "NEW_"; +var21 = (val*)(4l<<2|1); +var22 = (val*)(4l<<2|1); +var23 = (val*)((long)(0)<<2|3); +var24 = (val*)((long)(0)<<2|3); +var20 = core__flat___CString___to_s_unsafe(var19, var21, var22, var23, var24); +var18 = var20; +varonce17 = var18; +} +((struct instance_core__NativeArray*)var16)->values[0]=var18; +if (likely(varonce25!=NULL)) { +var26 = varonce25; +} else { +var27 = "()"; +var29 = (val*)(2l<<2|1); +var30 = (val*)(2l<<2|1); +var31 = (val*)((long)(0)<<2|3); +var32 = (val*)((long)(0)<<2|3); +var28 = core__flat___CString___to_s_unsafe(var27, var29, var30, var31, var32); +var26 = var28; +varonce25 = var26; +} +((struct instance_core__NativeArray*)var16)->values[2]=var26; +} else { +var16 = varonce15; +varonce15 = NULL; +} +{ +{ /* Inline model$MClassType$mclass (var_mtype) on */ +var35 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var35 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); +fatal_exit(1); +} +var33 = var35; +RET_LABEL34:(void)0; +} +} +{ +var36 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var33); +} +((struct instance_core__NativeArray*)var16)->values[1]=var36; +{ +var37 = ((val*(*)(val* self))(var16->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var16); /* native_to_s on */ +} +varonce15 = var16; +{ +var38 = nitc___nitc__AbstractCompilerVisitor___new_expr(self, var37, var_mtype); +} +var = var38; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$type_test for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType, String): RuntimeVariable */ val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__type_test(val* self, val* p0, val* p1, val* p2) { val* var /* : RuntimeVariable */; val* var_value /* var value: RuntimeVariable */; @@ -9,1294 +1780,1740 @@ val* var1 /* : NativeArray[String] */; static val* varonce; static val* varonce2; val* var3 /* : String */; -char* var4 /* : NativeString */; +char* var4 /* : CString */; val* var5 /* : String */; -static val* varonce6; -val* var7 /* : String */; -char* var8 /* : NativeString */; -val* var9 /* : String */; +val* var6 /* : nullable Int */; +val* var7 /* : nullable Int */; +val* var8 /* : nullable Bool */; +val* var9 /* : nullable Bool */; static val* varonce10; val* var11 /* : String */; -char* var12 /* : NativeString */; +char* var12 /* : CString */; val* var13 /* : String */; -val* var14 /* : String */; -val* var15 /* : String */; -val* var16 /* : String */; -val* var17 /* : MClassType */; -val* var18 /* : RuntimeVariable */; -val* var_res /* var res: RuntimeVariable */; -static val* varonce19; -val* var20 /* : String */; -char* var21 /* : NativeString */; -val* var22 /* : String */; -val* var23 /* : String */; -val* var_cltype /* var cltype: String */; -val* var25 /* : NativeArray[String] */; -static val* varonce24; -static val* varonce26; +val* var14 /* : nullable Int */; +val* var15 /* : nullable Int */; +val* var16 /* : nullable Bool */; +val* var17 /* : nullable Bool */; +static val* varonce18; +val* var19 /* : String */; +char* var20 /* : CString */; +val* var21 /* : String */; +val* var22 /* : nullable Int */; +val* var23 /* : nullable Int */; +val* var24 /* : nullable Bool */; +val* var25 /* : nullable Bool */; +val* var26 /* : String */; val* var27 /* : String */; -char* var28 /* : NativeString */; -val* var29 /* : String */; -static val* varonce30; -val* var31 /* : String */; -char* var32 /* : NativeString */; -val* var33 /* : String */; +val* var28 /* : String */; +val* var29 /* : MClassType */; +val* var30 /* : RuntimeVariable */; +val* var_res /* var res: RuntimeVariable */; +static val* varonce31; +val* var32 /* : String */; +char* var33 /* : CString */; val* var34 /* : String */; -static val* varonce35; -val* var36 /* : String */; -char* var37 /* : NativeString */; -val* var38 /* : String */; +val* var35 /* : nullable Int */; +val* var36 /* : nullable Int */; +val* var37 /* : nullable Bool */; +val* var38 /* : nullable Bool */; val* var39 /* : String */; -val* var_idtype /* var idtype: String */; +val* var_cltype /* var cltype: String */; val* var41 /* : NativeArray[String] */; static val* varonce40; static val* varonce42; val* var43 /* : String */; -char* var44 /* : NativeString */; +char* var44 /* : CString */; val* var45 /* : String */; -static val* varonce46; -val* var47 /* : String */; -char* var48 /* : NativeString */; -val* var49 /* : String */; -val* var50 /* : String */; -short int var51 /* : Bool */; -short int var_maybe_null /* var maybe_null: Bool */; -static val* varonce52; +val* var46 /* : nullable Int */; +val* var47 /* : nullable Int */; +val* var48 /* : nullable Bool */; +val* var49 /* : nullable Bool */; +static val* varonce50; +val* var51 /* : String */; +char* var52 /* : CString */; val* var53 /* : String */; -char* var54 /* : NativeString */; -val* var55 /* : String */; +val* var54 /* : nullable Int */; +val* var55 /* : nullable Int */; +val* var56 /* : nullable Bool */; +val* var57 /* : nullable Bool */; +val* var58 /* : String */; +static val* varonce59; +val* var60 /* : String */; +char* var61 /* : CString */; +val* var62 /* : String */; +val* var63 /* : nullable Int */; +val* var64 /* : nullable Int */; +val* var65 /* : nullable Bool */; +val* var66 /* : nullable Bool */; +val* var67 /* : String */; +val* var_idtype /* var idtype: String */; +val* var69 /* : NativeArray[String] */; +static val* varonce68; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : CString */; +val* var73 /* : String */; +val* var74 /* : nullable Int */; +val* var75 /* : nullable Int */; +val* var76 /* : nullable Bool */; +val* var77 /* : nullable Bool */; +static val* varonce78; +val* var79 /* : String */; +char* var80 /* : CString */; +val* var81 /* : String */; +val* var82 /* : nullable Int */; +val* var83 /* : nullable Int */; +val* var84 /* : nullable Bool */; +val* var85 /* : nullable Bool */; +val* var86 /* : String */; +short int var87 /* : Bool */; +short int var_maybe_null /* var maybe_null: Bool */; +static val* varonce88; +val* var89 /* : String */; +char* var90 /* : CString */; +val* var91 /* : String */; +val* var92 /* : nullable Int */; +val* var93 /* : nullable Int */; +val* var94 /* : nullable Bool */; +val* var95 /* : nullable Bool */; val* var_accept_null /* var accept_null: String */; -short int var56 /* : Bool */; +short int var96 /* : Bool */; int cltype; int idtype; -val* var57 /* : MType */; -val* var59 /* : MType */; -static val* varonce60; -val* var61 /* : String */; -char* var62 /* : NativeString */; -val* var63 /* : String */; -short int var64 /* : Bool */; -int cltype65; -int idtype66; -val* var67 /* : nullable StaticFrame */; -val* var69 /* : nullable StaticFrame */; -val* var70 /* : MPropDef */; -val* var72 /* : MPropDef */; -val* var73 /* : MClassDef */; -val* var75 /* : MClassDef */; -val* var76 /* : MClassType */; -val* var78 /* : MClassType */; -val* var79 /* : nullable StaticFrame */; -val* var81 /* : nullable StaticFrame */; -val* var82 /* : MPropDef */; -val* var84 /* : MPropDef */; -val* var85 /* : MClassDef */; -val* var87 /* : MClassDef */; -val* var88 /* : MClassType */; -val* var90 /* : MClassType */; -val* var91 /* : nullable StaticFrame */; -val* var93 /* : nullable StaticFrame */; -val* var94 /* : MPropDef */; -val* var96 /* : MPropDef */; -val* var97 /* : MClassDef */; -val* var99 /* : MClassDef */; -val* var100 /* : MModule */; -val* var102 /* : MModule */; -val* var103 /* : MType */; -short int var104 /* : Bool */; -int cltype105; -int idtype106; -val* var107 /* : MType */; -val* var109 /* : MType */; -static val* varonce110; -val* var111 /* : String */; -char* var112 /* : NativeString */; -val* var113 /* : String */; -val* var114 /* : MType */; -val* var116 /* : MType */; -val* var117 /* : nullable StaticFrame */; -val* var119 /* : nullable StaticFrame */; -val* var120 /* : MPropDef */; -val* var122 /* : MPropDef */; -val* var123 /* : MClassDef */; -val* var125 /* : MClassDef */; -val* var126 /* : MModule */; -val* var128 /* : MModule */; -val* var129 /* : nullable StaticFrame */; -val* var131 /* : nullable StaticFrame */; -val* var132 /* : MPropDef */; -val* var134 /* : MPropDef */; -val* var135 /* : MClassDef */; -val* var137 /* : MClassDef */; -val* var138 /* : MClassType */; -val* var140 /* : MClassType */; -short int var141 /* : Bool */; -val* var143 /* : NativeArray[String] */; -static val* varonce142; -static val* varonce144; -val* var145 /* : String */; -char* var146 /* : NativeString */; -val* var147 /* : String */; -static val* varonce148; -val* var149 /* : String */; -char* var150 /* : NativeString */; -val* var151 /* : String */; -static val* varonce152; -val* var153 /* : String */; -char* var154 /* : NativeString */; +val* var97 /* : MType */; +val* var99 /* : MType */; +static val* varonce100; +val* var101 /* : String */; +char* var102 /* : CString */; +val* var103 /* : String */; +val* var104 /* : nullable Int */; +val* var105 /* : nullable Int */; +val* var106 /* : nullable Bool */; +val* var107 /* : nullable Bool */; +short int var108 /* : Bool */; +int cltype109; +int idtype110; +val* var111 /* : nullable StaticFrame */; +val* var113 /* : nullable StaticFrame */; +val* var114 /* : MPropDef */; +val* var116 /* : MPropDef */; +val* var117 /* : MClassDef */; +val* var119 /* : MClassDef */; +val* var120 /* : MClassType */; +val* var122 /* : MClassType */; +val* var123 /* : nullable StaticFrame */; +val* var125 /* : nullable StaticFrame */; +val* var126 /* : MPropDef */; +val* var128 /* : MPropDef */; +val* var129 /* : MClassDef */; +val* var131 /* : MClassDef */; +val* var132 /* : MClassType */; +val* var134 /* : MClassType */; +val* var135 /* : nullable StaticFrame */; +val* var137 /* : nullable StaticFrame */; +val* var138 /* : MPropDef */; +val* var140 /* : MPropDef */; +val* var141 /* : MClassDef */; +val* var143 /* : MClassDef */; +val* var144 /* : MModule */; +val* var146 /* : MModule */; +val* var147 /* : MType */; +short int var148 /* : Bool */; +int cltype149; +int idtype150; +val* var151 /* : MType */; +val* var153 /* : MType */; +static val* varonce154; val* var155 /* : String */; -val* var156 /* : String */; +char* var156 /* : CString */; val* var157 /* : String */; -val* var158 /* : String */; -val* var159 /* : String */; -val* var160 /* : AbstractCompiler */; -val* var162 /* : AbstractCompiler */; -val* var163 /* : ModelBuilder */; -val* var165 /* : ModelBuilder */; -val* var166 /* : ToolContext */; -val* var168 /* : ToolContext */; -val* var169 /* : OptionBool */; -val* var171 /* : OptionBool */; -val* var172 /* : nullable Object */; -val* var174 /* : nullable Object */; -short int var175 /* : Bool */; -val* var176 /* : AbstractCompiler */; -val* var178 /* : AbstractCompiler */; -val* var179 /* : HashMap[String, Int] */; -val* var181 /* : HashMap[String, Int] */; -val* var_ /* var : HashMap[String, Int] */; -val* var_182 /* var : String */; -val* var183 /* : nullable Object */; -long var184 /* : Int */; -short int var186 /* : Bool */; -int cltype187; -int idtype188; -const char* var_class_name; -long var189 /* : Int */; -long var190 /* : Int */; -val* var191 /* : nullable Object */; -val* var193 /* : NativeArray[String] */; +val* var158 /* : nullable Int */; +val* var159 /* : nullable Int */; +val* var160 /* : nullable Bool */; +val* var161 /* : nullable Bool */; +val* var162 /* : MType */; +val* var164 /* : MType */; +val* var165 /* : nullable StaticFrame */; +val* var167 /* : nullable StaticFrame */; +val* var168 /* : MPropDef */; +val* var170 /* : MPropDef */; +val* var171 /* : MClassDef */; +val* var173 /* : MClassDef */; +val* var174 /* : MModule */; +val* var176 /* : MModule */; +val* var177 /* : nullable StaticFrame */; +val* var179 /* : nullable StaticFrame */; +val* var180 /* : MPropDef */; +val* var182 /* : MPropDef */; +val* var183 /* : MClassDef */; +val* var185 /* : MClassDef */; +val* var186 /* : MClassType */; +val* var188 /* : MClassType */; +short int var189 /* : Bool */; +val* var191 /* : NativeArray[String] */; +static val* varonce190; static val* varonce192; -static val* varonce194; +val* var193 /* : String */; +char* var194 /* : CString */; val* var195 /* : String */; -char* var196 /* : NativeString */; -val* var197 /* : String */; -static val* varonce198; -val* var199 /* : String */; -char* var200 /* : NativeString */; +val* var196 /* : nullable Int */; +val* var197 /* : nullable Int */; +val* var198 /* : nullable Bool */; +val* var199 /* : nullable Bool */; +static val* varonce200; val* var201 /* : String */; -val* var202 /* : String */; -val* var203 /* : MType */; -val* var205 /* : MType */; -short int var206 /* : Bool */; -short int var207 /* : Bool */; -val* var209 /* : NativeArray[String] */; +char* var202 /* : CString */; +val* var203 /* : String */; +val* var204 /* : nullable Int */; +val* var205 /* : nullable Int */; +val* var206 /* : nullable Bool */; +val* var207 /* : nullable Bool */; static val* varonce208; -static val* varonce210; +val* var209 /* : String */; +char* var210 /* : CString */; val* var211 /* : String */; -char* var212 /* : NativeString */; -val* var213 /* : String */; -val* var214 /* : String */; -val* var215 /* : String */; -val* var_class_ptr /* var class_ptr: nullable Object */; -val* var216 /* : MType */; -val* var218 /* : MType */; -short int var219 /* : Bool */; -int cltype220; -int idtype221; -const char* var_class_name222; -val* var223 /* : MClass */; -val* var225 /* : MClass */; -val* var_mclass /* var mclass: MClass */; -val* var227 /* : NativeArray[String] */; -static val* varonce226; -static val* varonce228; -val* var229 /* : String */; -char* var230 /* : NativeString */; -val* var231 /* : String */; -val* var232 /* : String */; -val* var233 /* : String */; -val* var235 /* : NativeArray[String] */; -static val* varonce234; -static val* varonce236; -val* var237 /* : String */; -char* var238 /* : NativeString */; -val* var239 /* : String */; -static val* varonce240; -val* var241 /* : String */; -char* var242 /* : NativeString */; -val* var243 /* : String */; -val* var244 /* : String */; -val* var245 /* : String */; +val* var212 /* : nullable Int */; +val* var213 /* : nullable Int */; +val* var214 /* : nullable Bool */; +val* var215 /* : nullable Bool */; +val* var216 /* : String */; +val* var217 /* : String */; +val* var218 /* : String */; +val* var219 /* : String */; +val* var220 /* : AbstractCompiler */; +val* var222 /* : AbstractCompiler */; +val* var223 /* : ModelBuilder */; +val* var225 /* : ModelBuilder */; +val* var226 /* : ToolContext */; +val* var228 /* : ToolContext */; +val* var229 /* : OptionBool */; +val* var231 /* : OptionBool */; +val* var232 /* : nullable Object */; +val* var234 /* : nullable Object */; +short int var235 /* : Bool */; +val* var236 /* : AbstractCompiler */; +val* var238 /* : AbstractCompiler */; +val* var239 /* : HashMap[String, Int] */; +val* var241 /* : HashMap[String, Int] */; +val* var_ /* var : HashMap[String, Int] */; +val* var_242 /* var : String */; +val* var243 /* : nullable Object */; +long var244 /* : Int */; short int var246 /* : Bool */; int cltype247; int idtype248; -val* var250 /* : NativeArray[String] */; -static val* varonce249; -static val* varonce251; -val* var252 /* : String */; -char* var253 /* : NativeString */; -val* var254 /* : String */; -val* var255 /* : MClass */; -val* var257 /* : MClass */; -val* var258 /* : String */; -val* var259 /* : String */; -val* var261 /* : NativeArray[String] */; -static val* varonce260; +const char* var_class_name; +long var249 /* : Int */; +long var250 /* : Int */; +val* var251 /* : nullable Object */; +val* var253 /* : NativeArray[String] */; +static val* varonce252; +static val* varonce254; +val* var255 /* : String */; +char* var256 /* : CString */; +val* var257 /* : String */; +val* var258 /* : nullable Int */; +val* var259 /* : nullable Int */; +val* var260 /* : nullable Bool */; +val* var261 /* : nullable Bool */; static val* varonce262; val* var263 /* : String */; -char* var264 /* : NativeString */; +char* var264 /* : CString */; val* var265 /* : String */; -static val* varonce266; -val* var267 /* : String */; -char* var268 /* : NativeString */; -val* var269 /* : String */; -val* var270 /* : MClass */; -val* var272 /* : MClass */; -val* var273 /* : String */; -val* var274 /* : String */; -val* var276 /* : NativeArray[String] */; -static val* varonce275; -static val* varonce277; -val* var278 /* : String */; -char* var279 /* : NativeString */; -val* var280 /* : String */; -static val* varonce281; -val* var282 /* : String */; -char* var283 /* : NativeString */; -val* var284 /* : String */; -val* var285 /* : MClass */; -val* var287 /* : MClass */; -val* var288 /* : String */; -val* var289 /* : String */; -val* var290 /* : AbstractCompiler */; -val* var292 /* : AbstractCompiler */; -val* var293 /* : ModelBuilder */; -val* var295 /* : ModelBuilder */; -val* var296 /* : ToolContext */; -val* var298 /* : ToolContext */; -val* var299 /* : OptionBool */; -val* var301 /* : OptionBool */; -val* var302 /* : nullable Object */; -val* var304 /* : nullable Object */; -short int var305 /* : Bool */; -val* var306 /* : AbstractCompiler */; -val* var308 /* : AbstractCompiler */; -val* var309 /* : HashMap[String, Int] */; -val* var311 /* : HashMap[String, Int] */; -val* var_312 /* var : HashMap[String, Int] */; -val* var_313 /* var : String */; -val* var314 /* : nullable Object */; -long var315 /* : Int */; -short int var317 /* : Bool */; -int cltype318; -int idtype319; -const char* var_class_name320; -long var321 /* : Int */; -long var322 /* : Int */; -val* var323 /* : nullable Object */; -val* var325 /* : NativeArray[String] */; -static val* varonce324; -static val* varonce326; -val* var327 /* : String */; -char* var328 /* : NativeString */; +val* var266 /* : nullable Int */; +val* var267 /* : nullable Int */; +val* var268 /* : nullable Bool */; +val* var269 /* : nullable Bool */; +val* var270 /* : String */; +val* var271 /* : MType */; +val* var273 /* : MType */; +short int var274 /* : Bool */; +short int var275 /* : Bool */; +val* var277 /* : NativeArray[String] */; +static val* varonce276; +static val* varonce278; +val* var279 /* : String */; +char* var280 /* : CString */; +val* var281 /* : String */; +val* var282 /* : nullable Int */; +val* var283 /* : nullable Int */; +val* var284 /* : nullable Bool */; +val* var285 /* : nullable Bool */; +val* var286 /* : String */; +val* var287 /* : String */; +val* var_class_ptr /* var class_ptr: nullable Object */; +val* var288 /* : MType */; +val* var290 /* : MType */; +short int var291 /* : Bool */; +int cltype292; +int idtype293; +const char* var_class_name294; +val* var295 /* : MClass */; +val* var297 /* : MClass */; +val* var_mclass /* var mclass: MClass */; +val* var299 /* : NativeArray[String] */; +static val* varonce298; +static val* varonce300; +val* var301 /* : String */; +char* var302 /* : CString */; +val* var303 /* : String */; +val* var304 /* : nullable Int */; +val* var305 /* : nullable Int */; +val* var306 /* : nullable Bool */; +val* var307 /* : nullable Bool */; +val* var308 /* : String */; +val* var309 /* : String */; +val* var311 /* : NativeArray[String] */; +static val* varonce310; +static val* varonce312; +val* var313 /* : String */; +char* var314 /* : CString */; +val* var315 /* : String */; +val* var316 /* : nullable Int */; +val* var317 /* : nullable Int */; +val* var318 /* : nullable Bool */; +val* var319 /* : nullable Bool */; +static val* varonce320; +val* var321 /* : String */; +char* var322 /* : CString */; +val* var323 /* : String */; +val* var324 /* : nullable Int */; +val* var325 /* : nullable Int */; +val* var326 /* : nullable Bool */; +val* var327 /* : nullable Bool */; +val* var328 /* : String */; val* var329 /* : String */; -static val* varonce330; -val* var331 /* : String */; -char* var332 /* : NativeString */; -val* var333 /* : String */; -val* var334 /* : String */; -short int var335 /* : Bool */; -int cltype336; -int idtype337; -val* var338 /* : nullable StaticFrame */; -val* var340 /* : nullable StaticFrame */; -val* var341 /* : Array[RuntimeVariable] */; -val* var343 /* : Array[RuntimeVariable] */; -val* var344 /* : nullable Object */; -val* var_recv /* var recv: RuntimeVariable */; -val* var345 /* : MType */; -val* var347 /* : MType */; -short int var348 /* : Bool */; -short int var349 /* : Bool */; -val* var351 /* : NativeArray[String] */; +short int var330 /* : Bool */; +int cltype331; +int idtype332; +val* var334 /* : NativeArray[String] */; +static val* varonce333; +static val* varonce335; +val* var336 /* : String */; +char* var337 /* : CString */; +val* var338 /* : String */; +val* var339 /* : nullable Int */; +val* var340 /* : nullable Int */; +val* var341 /* : nullable Bool */; +val* var342 /* : nullable Bool */; +val* var343 /* : MClass */; +val* var345 /* : MClass */; +val* var346 /* : String */; +val* var347 /* : String */; +val* var349 /* : NativeArray[String] */; +static val* varonce348; static val* varonce350; -static val* varonce352; +val* var351 /* : String */; +char* var352 /* : CString */; val* var353 /* : String */; -char* var354 /* : NativeString */; -val* var355 /* : String */; -val* var356 /* : String */; -val* var357 /* : String */; -val* var_recv_ptr /* var recv_ptr: nullable Object */; -val* var358 /* : MType */; -val* var360 /* : MType */; -short int var361 /* : Bool */; -int cltype362; -int idtype363; -const char* var_class_name364; -val* var365 /* : MClass */; -val* var367 /* : MClass */; -val* var_mclass368 /* var mclass: MClass */; -val* var370 /* : NativeArray[String] */; -static val* varonce369; +val* var354 /* : nullable Int */; +val* var355 /* : nullable Int */; +val* var356 /* : nullable Bool */; +val* var357 /* : nullable Bool */; +static val* varonce358; +val* var359 /* : String */; +char* var360 /* : CString */; +val* var361 /* : String */; +val* var362 /* : nullable Int */; +val* var363 /* : nullable Int */; +val* var364 /* : nullable Bool */; +val* var365 /* : nullable Bool */; +val* var366 /* : MClass */; +val* var368 /* : MClass */; +val* var369 /* : String */; +val* var370 /* : String */; +val* var372 /* : NativeArray[String] */; static val* varonce371; -val* var372 /* : String */; -char* var373 /* : NativeString */; +static val* varonce373; val* var374 /* : String */; -val* var375 /* : String */; +char* var375 /* : CString */; val* var376 /* : String */; -val* var378 /* : NativeArray[String] */; -static val* varonce377; -static val* varonce379; -val* var380 /* : String */; -char* var381 /* : NativeString */; +val* var377 /* : nullable Int */; +val* var378 /* : nullable Int */; +val* var379 /* : nullable Bool */; +val* var380 /* : nullable Bool */; +static val* varonce381; val* var382 /* : String */; -static val* varonce383; +char* var383 /* : CString */; val* var384 /* : String */; -char* var385 /* : NativeString */; -val* var386 /* : String */; -val* var387 /* : String */; -val* var388 /* : String */; -static val* varonce389; -val* var390 /* : String */; -char* var391 /* : NativeString */; +val* var385 /* : nullable Int */; +val* var386 /* : nullable Int */; +val* var387 /* : nullable Bool */; +val* var388 /* : nullable Bool */; +val* var389 /* : MClass */; +val* var391 /* : MClass */; val* var392 /* : String */; val* var393 /* : String */; -val* var_entry /* var entry: 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 */; -val* var404 /* : String */; -val* var405 /* : MVirtualTypeProp */; -val* var407 /* : MVirtualTypeProp */; -val* var408 /* : String */; -val* var410 /* : NativeArray[String] */; -static val* varonce409; -static val* varonce411; -val* var412 /* : String */; -char* var413 /* : NativeString */; -val* var414 /* : String */; -static val* varonce415; -val* var416 /* : String */; -char* var417 /* : NativeString */; -val* var418 /* : String */; -static val* varonce419; -val* var420 /* : String */; -char* var421 /* : NativeString */; -val* var422 /* : String */; -val* var423 /* : MVirtualTypeProp */; -val* var425 /* : MVirtualTypeProp */; -val* var426 /* : String */; -val* var427 /* : String */; +val* var394 /* : AbstractCompiler */; +val* var396 /* : AbstractCompiler */; +val* var397 /* : ModelBuilder */; +val* var399 /* : ModelBuilder */; +val* var400 /* : ToolContext */; +val* var402 /* : ToolContext */; +val* var403 /* : OptionBool */; +val* var405 /* : OptionBool */; +val* var406 /* : nullable Object */; +val* var408 /* : nullable Object */; +short int var409 /* : Bool */; +val* var410 /* : AbstractCompiler */; +val* var412 /* : AbstractCompiler */; +val* var413 /* : HashMap[String, Int] */; +val* var415 /* : HashMap[String, Int] */; +val* var_416 /* var : HashMap[String, Int] */; +val* var_417 /* var : String */; +val* var418 /* : nullable Object */; +long var419 /* : Int */; +short int var421 /* : Bool */; +int cltype422; +int idtype423; +const char* var_class_name424; +long var425 /* : Int */; +long var426 /* : Int */; +val* var427 /* : nullable Object */; val* var429 /* : NativeArray[String] */; static val* varonce428; static val* varonce430; val* var431 /* : String */; -char* var432 /* : NativeString */; +char* var432 /* : CString */; val* var433 /* : String */; -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* var434 /* : nullable Int */; +val* var435 /* : nullable Int */; +val* var436 /* : nullable Bool */; +val* var437 /* : nullable Bool */; +static val* varonce438; +val* var439 /* : String */; +char* var440 /* : CString */; +val* var441 /* : String */; +val* var442 /* : nullable Int */; +val* var443 /* : nullable Int */; +val* var444 /* : nullable Bool */; +val* var445 /* : nullable Bool */; val* var446 /* : String */; -char* var447 /* : NativeString */; -val* var448 /* : String */; -val* var449 /* : String */; -short int var450 /* : Bool */; -short int var_451 /* var : Bool */; -static val* varonce452; -val* var453 /* : String */; -char* var454 /* : NativeString */; -val* var455 /* : String */; -short int var456 /* : Bool */; -static val* varonce457; -val* var458 /* : String */; -char* var459 /* : NativeString */; -val* var460 /* : String */; -val* var461 /* : String */; -val* var_is_nullable /* var is_nullable: String */; +short int var447 /* : Bool */; +int cltype448; +int idtype449; +val* var450 /* : nullable StaticFrame */; +val* var452 /* : nullable StaticFrame */; +val* var453 /* : Array[RuntimeVariable] */; +val* var455 /* : Array[RuntimeVariable] */; +val* var456 /* : nullable Object */; +val* var_recv /* var recv: RuntimeVariable */; +val* var457 /* : MType */; +val* var459 /* : MType */; +short int var460 /* : Bool */; +short int var461 /* : Bool */; val* var463 /* : NativeArray[String] */; static val* varonce462; static val* varonce464; val* var465 /* : String */; -char* var466 /* : NativeString */; +char* var466 /* : CString */; val* var467 /* : String */; -static val* varonce468; -val* var469 /* : String */; -char* var470 /* : NativeString */; -val* var471 /* : String */; +val* var468 /* : nullable Int */; +val* var469 /* : nullable Int */; +val* var470 /* : nullable Bool */; +val* var471 /* : nullable Bool */; val* var472 /* : String */; -val* var474 /* : NativeArray[String] */; -static val* varonce473; -static val* varonce475; -val* var476 /* : String */; -char* var477 /* : NativeString */; -val* var478 /* : String */; -static val* varonce479; -val* var480 /* : String */; -char* var481 /* : NativeString */; -val* var482 /* : String */; -val* var483 /* : String */; -val* var484 /* : String */; -val* var485 /* : AbstractCompiler */; -val* var487 /* : AbstractCompiler */; -val* var488 /* : ModelBuilder */; -val* var490 /* : ModelBuilder */; -val* var491 /* : ToolContext */; -val* var493 /* : ToolContext */; -val* var494 /* : OptionBool */; -val* var496 /* : OptionBool */; -val* var497 /* : nullable Object */; -val* var499 /* : nullable Object */; -short int var500 /* : Bool */; -val* var501 /* : AbstractCompiler */; -val* var503 /* : AbstractCompiler */; -val* var504 /* : HashMap[String, Int] */; -val* var506 /* : HashMap[String, Int] */; -val* var_507 /* var : HashMap[String, Int] */; -val* var_508 /* var : String */; -val* var509 /* : nullable Object */; -long var510 /* : Int */; -short int var512 /* : Bool */; -int cltype513; -int idtype514; -const char* var_class_name515; -long var516 /* : Int */; -long var517 /* : Int */; -val* var518 /* : nullable Object */; -val* var520 /* : NativeArray[String] */; -static val* varonce519; -static val* varonce521; -val* var522 /* : String */; -char* var523 /* : NativeString */; -val* var524 /* : String */; -static val* varonce525; -val* var526 /* : String */; -char* var527 /* : NativeString */; -val* var528 /* : String */; +val* var473 /* : String */; +val* var_recv_ptr /* var recv_ptr: nullable Object */; +val* var474 /* : MType */; +val* var476 /* : MType */; +short int var477 /* : Bool */; +int cltype478; +int idtype479; +const char* var_class_name480; +val* var481 /* : MClass */; +val* var483 /* : MClass */; +val* var_mclass484 /* var mclass: MClass */; +val* var486 /* : NativeArray[String] */; +static val* varonce485; +static val* varonce487; +val* var488 /* : String */; +char* var489 /* : CString */; +val* var490 /* : String */; +val* var491 /* : nullable Int */; +val* var492 /* : nullable Int */; +val* var493 /* : nullable Bool */; +val* var494 /* : nullable Bool */; +val* var495 /* : String */; +val* var496 /* : String */; +val* var498 /* : NativeArray[String] */; +static val* varonce497; +static val* varonce499; +val* var500 /* : String */; +char* var501 /* : CString */; +val* var502 /* : String */; +val* var503 /* : nullable Int */; +val* var504 /* : nullable Int */; +val* var505 /* : nullable Bool */; +val* var506 /* : nullable Bool */; +static val* varonce507; +val* var508 /* : String */; +char* var509 /* : CString */; +val* var510 /* : String */; +val* var511 /* : nullable Int */; +val* var512 /* : nullable Int */; +val* var513 /* : nullable Bool */; +val* var514 /* : nullable Bool */; +val* var515 /* : String */; +val* var516 /* : String */; +static val* varonce517; +val* var518 /* : String */; +char* var519 /* : CString */; +val* var520 /* : String */; +val* var521 /* : nullable Int */; +val* var522 /* : nullable Int */; +val* var523 /* : nullable Bool */; +val* var524 /* : nullable Bool */; +val* var525 /* : String */; +val* var_entry /* var entry: String */; +val* var527 /* : NativeArray[String] */; +static val* varonce526; +static val* varonce528; val* var529 /* : String */; -val* var531 /* : NativeArray[String] */; -static val* varonce530; -static val* varonce532; -val* var533 /* : String */; -char* var534 /* : NativeString */; -val* var535 /* : String */; +char* var530 /* : CString */; +val* var531 /* : String */; +val* var532 /* : nullable Int */; +val* var533 /* : nullable Int */; +val* var534 /* : nullable Bool */; +val* var535 /* : nullable Bool */; static val* varonce536; val* var537 /* : String */; -char* var538 /* : NativeString */; +char* var538 /* : CString */; val* var539 /* : String */; -static val* varonce540; -val* var541 /* : String */; -char* var542 /* : NativeString */; -val* var543 /* : String */; +val* var540 /* : nullable Int */; +val* var541 /* : nullable Int */; +val* var542 /* : nullable Bool */; +val* var543 /* : nullable Bool */; val* var544 /* : String */; -val* var545 /* : String */; -val* var546 /* : String */; -val* var548 /* : NativeArray[String] */; -static val* varonce547; +val* var545 /* : MVirtualTypeProp */; +val* var547 /* : MVirtualTypeProp */; +val* var548 /* : String */; +val* var550 /* : NativeArray[String] */; static val* varonce549; -val* var550 /* : String */; -char* var551 /* : NativeString */; +static val* varonce551; val* var552 /* : String */; -static val* varonce553; +char* var553 /* : CString */; val* var554 /* : String */; -char* var555 /* : NativeString */; -val* var556 /* : String */; -val* var557 /* : String */; -val* var558 /* : String */; -val* var560 /* : NativeArray[String] */; +val* var555 /* : nullable Int */; +val* var556 /* : nullable Int */; +val* var557 /* : nullable Bool */; +val* var558 /* : nullable Bool */; static val* varonce559; -static val* varonce561; +val* var560 /* : String */; +char* var561 /* : CString */; val* var562 /* : String */; -char* var563 /* : NativeString */; -val* var564 /* : String */; -static val* varonce565; -val* var566 /* : String */; -char* var567 /* : NativeString */; +val* var563 /* : nullable Int */; +val* var564 /* : nullable Int */; +val* var565 /* : nullable Bool */; +val* var566 /* : nullable Bool */; +static val* varonce567; val* var568 /* : String */; -val* var569 /* : String */; +char* var569 /* : CString */; val* var570 /* : String */; -static val* varonce571; -val* var572 /* : String */; -char* var573 /* : NativeString */; -val* var574 /* : String */; -val* var576 /* : NativeArray[String] */; -static val* varonce575; -static val* varonce577; +val* var571 /* : nullable Int */; +val* var572 /* : nullable Int */; +val* var573 /* : nullable Bool */; +val* var574 /* : nullable Bool */; +val* var575 /* : MVirtualTypeProp */; +val* var577 /* : MVirtualTypeProp */; val* var578 /* : String */; -char* var579 /* : NativeString */; -val* var580 /* : String */; -static val* varonce581; -val* var582 /* : String */; -char* var583 /* : NativeString */; -val* var584 /* : String */; -static val* varonce585; -val* var586 /* : String */; -char* var587 /* : NativeString */; -val* var588 /* : String */; -val* var589 /* : String */; -val* var591 /* : NativeArray[String] */; +val* var579 /* : String */; +val* var581 /* : NativeArray[String] */; +static val* varonce580; +static val* varonce582; +val* var583 /* : String */; +char* var584 /* : CString */; +val* var585 /* : String */; +val* var586 /* : nullable Int */; +val* var587 /* : nullable Int */; +val* var588 /* : nullable Bool */; +val* var589 /* : nullable Bool */; static val* varonce590; -static val* varonce592; +val* var591 /* : String */; +char* var592 /* : CString */; val* var593 /* : String */; -char* var594 /* : NativeString */; -val* var595 /* : String */; -val* var596 /* : String */; -val* var597 /* : String */; -static val* varonce598; -val* var599 /* : String */; -char* var600 /* : NativeString */; -val* var601 /* : String */; -val* var603 /* : NativeArray[String] */; -static val* varonce602; -static val* varonce604; -val* var605 /* : String */; -char* var606 /* : NativeString */; -val* var607 /* : String */; -static val* varonce608; -val* var609 /* : String */; -char* var610 /* : NativeString */; -val* var611 /* : String */; -static val* varonce612; -val* var613 /* : String */; -char* var614 /* : NativeString */; -val* var615 /* : String */; -static val* varonce616; +val* var594 /* : nullable Int */; +val* var595 /* : nullable Int */; +val* var596 /* : nullable Bool */; +val* var597 /* : nullable Bool */; +val* var598 /* : String */; +val* var600 /* : NativeArray[String] */; +static val* varonce599; +static val* varonce601; +val* var602 /* : String */; +char* var603 /* : CString */; +val* var604 /* : String */; +val* var605 /* : nullable Int */; +val* var606 /* : nullable Int */; +val* var607 /* : nullable Bool */; +val* var608 /* : nullable Bool */; +static val* varonce609; +val* var610 /* : String */; +char* var611 /* : CString */; +val* var612 /* : String */; +val* var613 /* : nullable Int */; +val* var614 /* : nullable Int */; +val* var615 /* : nullable Bool */; +val* var616 /* : nullable Bool */; val* var617 /* : String */; -char* var618 /* : NativeString */; -val* var619 /* : String */; -val* var620 /* : String */; +short int var618 /* : Bool */; +short int var_619 /* var : Bool */; +static val* varonce620; val* var621 /* : String */; -static val* varonce622; +char* var622 /* : CString */; val* var623 /* : String */; -char* var624 /* : NativeString */; -val* var625 /* : String */; -static val* varonce626; -val* var627 /* : String */; -char* var628 /* : NativeString */; -val* var629 /* : String */; +val* var624 /* : nullable Int */; +val* var625 /* : nullable Int */; +val* var626 /* : nullable Bool */; +val* var627 /* : nullable Bool */; +short int var628 /* : Bool */; +static val* varonce629; +val* var630 /* : String */; +char* var631 /* : CString */; +val* var632 /* : String */; +val* var633 /* : nullable Int */; +val* var634 /* : nullable Int */; +val* var635 /* : nullable Bool */; +val* var636 /* : nullable Bool */; +val* var637 /* : String */; +val* var_is_nullable /* var is_nullable: String */; +val* var639 /* : NativeArray[String] */; +static val* varonce638; +static val* varonce640; +val* var641 /* : String */; +char* var642 /* : CString */; +val* var643 /* : String */; +val* var644 /* : nullable Int */; +val* var645 /* : nullable Int */; +val* var646 /* : nullable Bool */; +val* var647 /* : nullable Bool */; +static val* varonce648; +val* var649 /* : String */; +char* var650 /* : CString */; +val* var651 /* : String */; +val* var652 /* : nullable Int */; +val* var653 /* : nullable Int */; +val* var654 /* : nullable Bool */; +val* var655 /* : nullable Bool */; +val* var656 /* : String */; +val* var658 /* : NativeArray[String] */; +static val* varonce657; +static val* varonce659; +val* var660 /* : String */; +char* var661 /* : CString */; +val* var662 /* : String */; +val* var663 /* : nullable Int */; +val* var664 /* : nullable Int */; +val* var665 /* : nullable Bool */; +val* var666 /* : nullable Bool */; +static val* varonce667; +val* var668 /* : String */; +char* var669 /* : CString */; +val* var670 /* : String */; +val* var671 /* : nullable Int */; +val* var672 /* : nullable Int */; +val* var673 /* : nullable Bool */; +val* var674 /* : nullable Bool */; +val* var675 /* : String */; +val* var676 /* : String */; +val* var677 /* : AbstractCompiler */; +val* var679 /* : AbstractCompiler */; +val* var680 /* : ModelBuilder */; +val* var682 /* : ModelBuilder */; +val* var683 /* : ToolContext */; +val* var685 /* : ToolContext */; +val* var686 /* : OptionBool */; +val* var688 /* : OptionBool */; +val* var689 /* : nullable Object */; +val* var691 /* : nullable Object */; +short int var692 /* : Bool */; +val* var693 /* : AbstractCompiler */; +val* var695 /* : AbstractCompiler */; +val* var696 /* : HashMap[String, Int] */; +val* var698 /* : HashMap[String, Int] */; +val* var_699 /* var : HashMap[String, Int] */; +val* var_700 /* var : String */; +val* var701 /* : nullable Object */; +long var702 /* : Int */; +short int var704 /* : Bool */; +int cltype705; +int idtype706; +const char* var_class_name707; +long var708 /* : Int */; +long var709 /* : Int */; +val* var710 /* : nullable Object */; +val* var712 /* : NativeArray[String] */; +static val* varonce711; +static val* varonce713; +val* var714 /* : String */; +char* var715 /* : CString */; +val* var716 /* : String */; +val* var717 /* : nullable Int */; +val* var718 /* : nullable Int */; +val* var719 /* : nullable Bool */; +val* var720 /* : nullable Bool */; +static val* varonce721; +val* var722 /* : String */; +char* var723 /* : CString */; +val* var724 /* : String */; +val* var725 /* : nullable Int */; +val* var726 /* : nullable Int */; +val* var727 /* : nullable Bool */; +val* var728 /* : nullable Bool */; +val* var729 /* : String */; +val* var731 /* : NativeArray[String] */; +static val* varonce730; +static val* varonce732; +val* var733 /* : String */; +char* var734 /* : CString */; +val* var735 /* : String */; +val* var736 /* : nullable Int */; +val* var737 /* : nullable Int */; +val* var738 /* : nullable Bool */; +val* var739 /* : nullable Bool */; +static val* varonce740; +val* var741 /* : String */; +char* var742 /* : CString */; +val* var743 /* : String */; +val* var744 /* : nullable Int */; +val* var745 /* : nullable Int */; +val* var746 /* : nullable Bool */; +val* var747 /* : nullable Bool */; +static val* varonce748; +val* var749 /* : String */; +char* var750 /* : CString */; +val* var751 /* : String */; +val* var752 /* : nullable Int */; +val* var753 /* : nullable Int */; +val* var754 /* : nullable Bool */; +val* var755 /* : nullable Bool */; +val* var756 /* : String */; +val* var757 /* : String */; +val* var758 /* : String */; +val* var760 /* : NativeArray[String] */; +static val* varonce759; +static val* varonce761; +val* var762 /* : String */; +char* var763 /* : CString */; +val* var764 /* : String */; +val* var765 /* : nullable Int */; +val* var766 /* : nullable Int */; +val* var767 /* : nullable Bool */; +val* var768 /* : nullable Bool */; +static val* varonce769; +val* var770 /* : String */; +char* var771 /* : CString */; +val* var772 /* : String */; +val* var773 /* : nullable Int */; +val* var774 /* : nullable Int */; +val* var775 /* : nullable Bool */; +val* var776 /* : nullable Bool */; +val* var777 /* : String */; +val* var778 /* : String */; +val* var780 /* : NativeArray[String] */; +static val* varonce779; +static val* varonce781; +val* var782 /* : String */; +char* var783 /* : CString */; +val* var784 /* : String */; +val* var785 /* : nullable Int */; +val* var786 /* : nullable Int */; +val* var787 /* : nullable Bool */; +val* var788 /* : nullable Bool */; +static val* varonce789; +val* var790 /* : String */; +char* var791 /* : CString */; +val* var792 /* : String */; +val* var793 /* : nullable Int */; +val* var794 /* : nullable Int */; +val* var795 /* : nullable Bool */; +val* var796 /* : nullable Bool */; +val* var797 /* : String */; +val* var798 /* : String */; +static val* varonce799; +val* var800 /* : String */; +char* var801 /* : CString */; +val* var802 /* : String */; +val* var803 /* : nullable Int */; +val* var804 /* : nullable Int */; +val* var805 /* : nullable Bool */; +val* var806 /* : nullable Bool */; +val* var808 /* : NativeArray[String] */; +static val* varonce807; +static val* varonce809; +val* var810 /* : String */; +char* var811 /* : CString */; +val* var812 /* : String */; +val* var813 /* : nullable Int */; +val* var814 /* : nullable Int */; +val* var815 /* : nullable Bool */; +val* var816 /* : nullable Bool */; +static val* varonce817; +val* var818 /* : String */; +char* var819 /* : CString */; +val* var820 /* : String */; +val* var821 /* : nullable Int */; +val* var822 /* : nullable Int */; +val* var823 /* : nullable Bool */; +val* var824 /* : nullable Bool */; +static val* varonce825; +val* var826 /* : String */; +char* var827 /* : CString */; +val* var828 /* : String */; +val* var829 /* : nullable Int */; +val* var830 /* : nullable Int */; +val* var831 /* : nullable Bool */; +val* var832 /* : nullable Bool */; +val* var833 /* : String */; +val* var835 /* : NativeArray[String] */; +static val* varonce834; +static val* varonce836; +val* var837 /* : String */; +char* var838 /* : CString */; +val* var839 /* : String */; +val* var840 /* : nullable Int */; +val* var841 /* : nullable Int */; +val* var842 /* : nullable Bool */; +val* var843 /* : nullable Bool */; +val* var844 /* : String */; +val* var845 /* : String */; +static val* varonce846; +val* var847 /* : String */; +char* var848 /* : CString */; +val* var849 /* : String */; +val* var850 /* : nullable Int */; +val* var851 /* : nullable Int */; +val* var852 /* : nullable Bool */; +val* var853 /* : nullable Bool */; +val* var855 /* : NativeArray[String] */; +static val* varonce854; +static val* varonce856; +val* var857 /* : String */; +char* var858 /* : CString */; +val* var859 /* : String */; +val* var860 /* : nullable Int */; +val* var861 /* : nullable Int */; +val* var862 /* : nullable Bool */; +val* var863 /* : nullable Bool */; +static val* varonce864; +val* var865 /* : String */; +char* var866 /* : CString */; +val* var867 /* : String */; +val* var868 /* : nullable Int */; +val* var869 /* : nullable Int */; +val* var870 /* : nullable Bool */; +val* var871 /* : nullable Bool */; +static val* varonce872; +val* var873 /* : String */; +char* var874 /* : CString */; +val* var875 /* : String */; +val* var876 /* : nullable Int */; +val* var877 /* : nullable Int */; +val* var878 /* : nullable Bool */; +val* var879 /* : nullable Bool */; +static val* varonce880; +val* var881 /* : String */; +char* var882 /* : CString */; +val* var883 /* : String */; +val* var884 /* : nullable Int */; +val* var885 /* : nullable Int */; +val* var886 /* : nullable Bool */; +val* var887 /* : nullable Bool */; +val* var888 /* : String */; +val* var889 /* : String */; +static val* varonce890; +val* var891 /* : String */; +char* var892 /* : CString */; +val* var893 /* : String */; +val* var894 /* : nullable Int */; +val* var895 /* : nullable Int */; +val* var896 /* : nullable Bool */; +val* var897 /* : nullable Bool */; +static val* varonce898; +val* var899 /* : String */; +char* var900 /* : CString */; +val* var901 /* : String */; +val* var902 /* : nullable Int */; +val* var903 /* : nullable Int */; +val* var904 /* : nullable Bool */; +val* var905 /* : nullable Bool */; var_value = p0; var_mtype = p1; var_tag = p2; if (unlikely(varonce==NULL)) { -var1 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); +var1 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String); if (likely(varonce2!=NULL)) { var3 = varonce2; } else { var4 = "/* type test for "; -var5 = core__flat___NativeString___to_s_full(var4, 17l, 17l); +var6 = (val*)(17l<<2|1); +var7 = (val*)(17l<<2|1); +var8 = (val*)((long)(0)<<2|3); +var9 = (val*)((long)(0)<<2|3); +var5 = core__flat___CString___to_s_unsafe(var4, var6, var7, var8, var9); var3 = var5; varonce2 = var3; } ((struct instance_core__NativeArray*)var1)->values[0]=var3; -if (likely(varonce6!=NULL)) { -var7 = varonce6; -} else { -var8 = " isa "; -var9 = core__flat___NativeString___to_s_full(var8, 5l, 5l); -var7 = var9; -varonce6 = var7; -} -((struct instance_core__NativeArray*)var1)->values[2]=var7; if (likely(varonce10!=NULL)) { var11 = varonce10; } else { -var12 = " */"; -var13 = core__flat___NativeString___to_s_full(var12, 3l, 3l); +var12 = " isa "; +var14 = (val*)(5l<<2|1); +var15 = (val*)(5l<<2|1); +var16 = (val*)((long)(0)<<2|3); +var17 = (val*)((long)(0)<<2|3); +var13 = core__flat___CString___to_s_unsafe(var12, var14, var15, var16, var17); var11 = var13; varonce10 = var11; } -((struct instance_core__NativeArray*)var1)->values[4]=var11; +((struct instance_core__NativeArray*)var1)->values[2]=var11; +if (likely(varonce18!=NULL)) { +var19 = varonce18; +} else { +var20 = " */"; +var22 = (val*)(3l<<2|1); +var23 = (val*)(3l<<2|1); +var24 = (val*)((long)(0)<<2|3); +var25 = (val*)((long)(0)<<2|3); +var21 = core__flat___CString___to_s_unsafe(var20, var22, var23, var24, var25); +var19 = var21; +varonce18 = var19; +} +((struct instance_core__NativeArray*)var1)->values[4]=var19; } else { var1 = varonce; varonce = NULL; } { -var14 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); +var26 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); } -((struct instance_core__NativeArray*)var1)->values[1]=var14; +((struct instance_core__NativeArray*)var1)->values[1]=var26; { -var15 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +var27 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ } -((struct instance_core__NativeArray*)var1)->values[3]=var15; +((struct instance_core__NativeArray*)var1)->values[3]=var27; { -var16 = ((val*(*)(val* self))(var1->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1); /* native_to_s on */ +var28 = ((val*(*)(val* self))(var1->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1); /* native_to_s on */ } varonce = var1; { -nitc___nitc__AbstractCompilerVisitor___add(self, var16); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var28); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } { -var17 = nitc___nitc__AbstractCompilerVisitor___bool_type(self); +var29 = nitc___nitc__AbstractCompilerVisitor___bool_type(self); } { -var18 = nitc___nitc__AbstractCompilerVisitor___new_var(self, var17); +var30 = nitc___nitc__AbstractCompilerVisitor___new_var(self, var29); } -var_res = var18; -if (likely(varonce19!=NULL)) { -var20 = varonce19; +var_res = var30; +if (likely(varonce31!=NULL)) { +var32 = varonce31; } else { -var21 = "cltype"; -var22 = core__flat___NativeString___to_s_full(var21, 6l, 6l); -var20 = var22; -varonce19 = var20; +var33 = "cltype"; +var35 = (val*)(6l<<2|1); +var36 = (val*)(6l<<2|1); +var37 = (val*)((long)(0)<<2|3); +var38 = (val*)((long)(0)<<2|3); +var34 = core__flat___CString___to_s_unsafe(var33, var35, var36, var37, var38); +var32 = var34; +varonce31 = var32; } { -var23 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var20); +var39 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var32); } -var_cltype = var23; -if (unlikely(varonce24==NULL)) { -var25 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce26!=NULL)) { -var27 = varonce26; +var_cltype = var39; +if (unlikely(varonce40==NULL)) { +var41 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce42!=NULL)) { +var43 = varonce42; } else { -var28 = "int "; -var29 = core__flat___NativeString___to_s_full(var28, 4l, 4l); -var27 = var29; -varonce26 = var27; +var44 = "int "; +var46 = (val*)(4l<<2|1); +var47 = (val*)(4l<<2|1); +var48 = (val*)((long)(0)<<2|3); +var49 = (val*)((long)(0)<<2|3); +var45 = core__flat___CString___to_s_unsafe(var44, var46, var47, var48, var49); +var43 = var45; +varonce42 = var43; } -((struct instance_core__NativeArray*)var25)->values[0]=var27; -if (likely(varonce30!=NULL)) { -var31 = varonce30; +((struct instance_core__NativeArray*)var41)->values[0]=var43; +if (likely(varonce50!=NULL)) { +var51 = varonce50; } else { -var32 = ";"; -var33 = core__flat___NativeString___to_s_full(var32, 1l, 1l); -var31 = var33; -varonce30 = var31; +var52 = ";"; +var54 = (val*)(1l<<2|1); +var55 = (val*)(1l<<2|1); +var56 = (val*)((long)(0)<<2|3); +var57 = (val*)((long)(0)<<2|3); +var53 = core__flat___CString___to_s_unsafe(var52, var54, var55, var56, var57); +var51 = var53; +varonce50 = var51; } -((struct instance_core__NativeArray*)var25)->values[2]=var31; +((struct instance_core__NativeArray*)var41)->values[2]=var51; } else { -var25 = varonce24; -varonce24 = NULL; +var41 = varonce40; +varonce40 = NULL; } -((struct instance_core__NativeArray*)var25)->values[1]=var_cltype; +((struct instance_core__NativeArray*)var41)->values[1]=var_cltype; { -var34 = ((val*(*)(val* self))(var25->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var25); /* native_to_s on */ +var58 = ((val*(*)(val* self))(var41->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var41); /* native_to_s on */ } -varonce24 = var25; +varonce40 = var41; { -nitc___nitc__AbstractCompilerVisitor___add_decl(self, var34); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nitc___nitc__AbstractCompilerVisitor___add_decl(self, var58); /* Direct call abstract_compiler$AbstractCompilerVisitor$add_decl on */ } -if (likely(varonce35!=NULL)) { -var36 = varonce35; +if (likely(varonce59!=NULL)) { +var60 = varonce59; } else { -var37 = "idtype"; -var38 = core__flat___NativeString___to_s_full(var37, 6l, 6l); -var36 = var38; -varonce35 = var36; +var61 = "idtype"; +var63 = (val*)(6l<<2|1); +var64 = (val*)(6l<<2|1); +var65 = (val*)((long)(0)<<2|3); +var66 = (val*)((long)(0)<<2|3); +var62 = core__flat___CString___to_s_unsafe(var61, var63, var64, var65, var66); +var60 = var62; +varonce59 = var60; } { -var39 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var36); +var67 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var60); } -var_idtype = var39; -if (unlikely(varonce40==NULL)) { -var41 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce42!=NULL)) { -var43 = varonce42; +var_idtype = var67; +if (unlikely(varonce68==NULL)) { +var69 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce70!=NULL)) { +var71 = varonce70; } else { -var44 = "int "; -var45 = core__flat___NativeString___to_s_full(var44, 4l, 4l); -var43 = var45; -varonce42 = var43; +var72 = "int "; +var74 = (val*)(4l<<2|1); +var75 = (val*)(4l<<2|1); +var76 = (val*)((long)(0)<<2|3); +var77 = (val*)((long)(0)<<2|3); +var73 = core__flat___CString___to_s_unsafe(var72, var74, var75, var76, var77); +var71 = var73; +varonce70 = var71; } -((struct instance_core__NativeArray*)var41)->values[0]=var43; -if (likely(varonce46!=NULL)) { -var47 = varonce46; +((struct instance_core__NativeArray*)var69)->values[0]=var71; +if (likely(varonce78!=NULL)) { +var79 = varonce78; } else { -var48 = ";"; -var49 = core__flat___NativeString___to_s_full(var48, 1l, 1l); -var47 = var49; -varonce46 = var47; +var80 = ";"; +var82 = (val*)(1l<<2|1); +var83 = (val*)(1l<<2|1); +var84 = (val*)((long)(0)<<2|3); +var85 = (val*)((long)(0)<<2|3); +var81 = core__flat___CString___to_s_unsafe(var80, var82, var83, var84, var85); +var79 = var81; +varonce78 = var79; } -((struct instance_core__NativeArray*)var41)->values[2]=var47; +((struct instance_core__NativeArray*)var69)->values[2]=var79; } else { -var41 = varonce40; -varonce40 = NULL; +var69 = varonce68; +varonce68 = NULL; } -((struct instance_core__NativeArray*)var41)->values[1]=var_idtype; +((struct instance_core__NativeArray*)var69)->values[1]=var_idtype; { -var50 = ((val*(*)(val* self))(var41->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var41); /* native_to_s on */ +var86 = ((val*(*)(val* self))(var69->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var69); /* native_to_s on */ } -varonce40 = var41; +varonce68 = var69; { -nitc___nitc__AbstractCompilerVisitor___add_decl(self, var50); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nitc___nitc__AbstractCompilerVisitor___add_decl(self, var86); /* Direct call abstract_compiler$AbstractCompilerVisitor$add_decl on */ } { -var51 = nitc___nitc__SeparateCompilerVisitor___maybe_null(self, var_value); +var87 = nitc___nitc__SeparateCompilerVisitor___maybe_null(self, var_value); } -var_maybe_null = var51; -if (likely(varonce52!=NULL)) { -var53 = varonce52; +var_maybe_null = var87; +if (likely(varonce88!=NULL)) { +var89 = varonce88; } else { -var54 = "0"; -var55 = core__flat___NativeString___to_s_full(var54, 1l, 1l); -var53 = var55; -varonce52 = var53; +var90 = "0"; +var92 = (val*)(1l<<2|1); +var93 = (val*)(1l<<2|1); +var94 = (val*)((long)(0)<<2|3); +var95 = (val*)((long)(0)<<2|3); +var91 = core__flat___CString___to_s_unsafe(var90, var92, var93, var94, var95); +var89 = var91; +varonce88 = var89; } -var_accept_null = var53; +var_accept_null = var89; /* isa MNullableType */ cltype = type_nitc__MNullableType.color; idtype = type_nitc__MNullableType.id; if(cltype >= var_mtype->type->table_size) { -var56 = 0; +var96 = 0; } else { -var56 = var_mtype->type->type_table[cltype] == idtype; +var96 = var_mtype->type->type_table[cltype] == idtype; } -if (var56){ +if (var96){ { -{ /* Inline model#MProxyType#mtype (var_mtype) on */ -var59 = var_mtype->attrs[COLOR_nitc__model__MProxyType___mtype].val; /* _mtype on */ -if (unlikely(var59 == NULL)) { +{ /* Inline model$MProxyType$mtype (var_mtype) on */ +var99 = var_mtype->attrs[COLOR_nitc__model__MProxyType___mtype].val; /* _mtype on */ +if (unlikely(var99 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1625); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1689); fatal_exit(1); } -var57 = var59; -RET_LABEL58:(void)0; +var97 = var99; +RET_LABEL98:(void)0; } } -var_mtype = var57; -if (likely(varonce60!=NULL)) { -var61 = varonce60; +var_mtype = var97; +if (likely(varonce100!=NULL)) { +var101 = varonce100; } else { -var62 = "1"; -var63 = core__flat___NativeString___to_s_full(var62, 1l, 1l); -var61 = var63; -varonce60 = var61; +var102 = "1"; +var104 = (val*)(1l<<2|1); +var105 = (val*)(1l<<2|1); +var106 = (val*)((long)(0)<<2|3); +var107 = (val*)((long)(0)<<2|3); +var103 = core__flat___CString___to_s_unsafe(var102, var104, var105, var106, var107); +var101 = var103; +varonce100 = var101; } -var_accept_null = var61; +var_accept_null = var101; } else { } /* isa MParameterType */ -cltype65 = type_nitc__MParameterType.color; -idtype66 = type_nitc__MParameterType.id; -if(cltype65 >= var_mtype->type->table_size) { -var64 = 0; +cltype109 = type_nitc__MParameterType.color; +idtype110 = type_nitc__MParameterType.id; +if(cltype109 >= var_mtype->type->table_size) { +var108 = 0; } else { -var64 = var_mtype->type->type_table[cltype65] == idtype66; +var108 = var_mtype->type->type_table[cltype109] == idtype110; } -if (var64){ +if (var108){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var69 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var67 = var69; -RET_LABEL68:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var113 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var111 = var113; +RET_LABEL112:(void)0; +} } +if (var111 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); } -if (var67 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 521); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var67) on */ -if (unlikely(var67 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$mpropdef (var111) on */ +if (unlikely(var111 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var72 = var67->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var72 == NULL)) { +var116 = var111->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var116 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var70 = var72; -RET_LABEL71:(void)0; +var114 = var116; +RET_LABEL115:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var70) on */ -var75 = var70->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var75 == NULL)) { +{ /* Inline model$MPropDef$mclassdef (var114) on */ +var119 = var114->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var119 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354); fatal_exit(1); } -var73 = var75; -RET_LABEL74:(void)0; +var117 = var119; +RET_LABEL118:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var73) on */ -var78 = var73->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var78 == NULL)) { +{ /* Inline model$MClassDef$bound_mtype (var117) on */ +var122 = var117->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var122 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594); fatal_exit(1); } -var76 = var78; -RET_LABEL77:(void)0; +var120 = var122; +RET_LABEL121:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var81 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var79 = var81; -RET_LABEL80:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var125 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var123 = var125; +RET_LABEL124:(void)0; } } -if (var79 == NULL) { +if (var123 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 521); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var79) on */ -if (unlikely(var79 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$mpropdef (var123) on */ +if (unlikely(var123 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var84 = var79->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var84 == NULL)) { +var128 = var123->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var128 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var82 = var84; -RET_LABEL83:(void)0; +var126 = var128; +RET_LABEL127:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var82) on */ -var87 = var82->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var87 == NULL)) { +{ /* Inline model$MPropDef$mclassdef (var126) on */ +var131 = var126->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var131 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354); fatal_exit(1); } -var85 = var87; -RET_LABEL86:(void)0; +var129 = var131; +RET_LABEL130:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var85) on */ -var90 = var85->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var90 == NULL)) { +{ /* Inline model$MClassDef$bound_mtype (var129) on */ +var134 = var129->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var134 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594); fatal_exit(1); } -var88 = var90; -RET_LABEL89:(void)0; +var132 = var134; +RET_LABEL133:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var93 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var91 = var93; -RET_LABEL92:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var137 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var135 = var137; +RET_LABEL136:(void)0; +} } +if (var135 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); } -if (var91 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 521); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var91) on */ -if (unlikely(var91 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$mpropdef (var135) on */ +if (unlikely(var135 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var96 = var91->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var96 == NULL)) { +var140 = var135->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var140 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var94 = var96; -RET_LABEL95:(void)0; +var138 = var140; +RET_LABEL139:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var94) on */ -var99 = var94->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var99 == NULL)) { +{ /* Inline model$MPropDef$mclassdef (var138) on */ +var143 = var138->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var143 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354); fatal_exit(1); } -var97 = var99; -RET_LABEL98:(void)0; +var141 = var143; +RET_LABEL142:(void)0; } } { -{ /* Inline model#MClassDef#mmodule (var97) on */ -var102 = var97->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var102 == NULL)) { +{ /* Inline model$MClassDef$mmodule (var141) on */ +var146 = var141->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var146 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 573); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 588); fatal_exit(1); } -var100 = var102; -RET_LABEL101:(void)0; +var144 = var146; +RET_LABEL145:(void)0; } } { -var103 = nitc___nitc__MParameterType___MType__resolve_for(var_mtype, var76, var88, var100, 0); +var147 = nitc___nitc__MParameterType___MType__resolve_for(var_mtype, var120, var132, var144, 0); } -var_mtype = var103; +var_mtype = var147; /* isa MNullableType */ -cltype105 = type_nitc__MNullableType.color; -idtype106 = type_nitc__MNullableType.id; -if(cltype105 >= var_mtype->type->table_size) { -var104 = 0; +cltype149 = type_nitc__MNullableType.color; +idtype150 = type_nitc__MNullableType.id; +if(cltype149 >= var_mtype->type->table_size) { +var148 = 0; } else { -var104 = var_mtype->type->type_table[cltype105] == idtype106; +var148 = var_mtype->type->type_table[cltype149] == idtype150; } -if (var104){ +if (var148){ { -{ /* Inline model#MProxyType#mtype (var_mtype) on */ -var109 = var_mtype->attrs[COLOR_nitc__model__MProxyType___mtype].val; /* _mtype on */ -if (unlikely(var109 == NULL)) { +{ /* Inline model$MProxyType$mtype (var_mtype) on */ +var153 = var_mtype->attrs[COLOR_nitc__model__MProxyType___mtype].val; /* _mtype on */ +if (unlikely(var153 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1625); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1689); fatal_exit(1); } -var107 = var109; -RET_LABEL108:(void)0; +var151 = var153; +RET_LABEL152:(void)0; } } -var_mtype = var107; -if (likely(varonce110!=NULL)) { -var111 = varonce110; +var_mtype = var151; +if (likely(varonce154!=NULL)) { +var155 = varonce154; } else { -var112 = "1"; -var113 = core__flat___NativeString___to_s_full(var112, 1l, 1l); -var111 = var113; -varonce110 = var111; +var156 = "1"; +var158 = (val*)(1l<<2|1); +var159 = (val*)(1l<<2|1); +var160 = (val*)((long)(0)<<2|3); +var161 = (val*)((long)(0)<<2|3); +var157 = core__flat___CString___to_s_unsafe(var156, var158, var159, var160, var161); +var155 = var157; +varonce154 = var155; } -var_accept_null = var111; +var_accept_null = var155; } else { } } else { } { -{ /* Inline abstract_compiler#RuntimeVariable#mcasttype (var_value) on */ -var116 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mcasttype].val; /* _mcasttype on */ -if (unlikely(var116 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mcasttype (var_value) on */ +var164 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mcasttype].val; /* _mcasttype on */ +if (unlikely(var164 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mcasttype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1873); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1986); fatal_exit(1); } -var114 = var116; -RET_LABEL115:(void)0; +var162 = var164; +RET_LABEL163:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var119 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var117 = var119; -RET_LABEL118:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var167 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var165 = var167; +RET_LABEL166:(void)0; } } -if (var117 == NULL) { +if (var165 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 528); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var117) on */ -if (unlikely(var117 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$mpropdef (var165) on */ +if (unlikely(var165 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var122 = var117->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var122 == NULL)) { +var170 = var165->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var170 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var120 = var122; -RET_LABEL121:(void)0; +var168 = var170; +RET_LABEL169:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var120) on */ -var125 = var120->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var125 == NULL)) { +{ /* Inline model$MPropDef$mclassdef (var168) on */ +var173 = var168->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var173 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354); fatal_exit(1); } -var123 = var125; -RET_LABEL124:(void)0; +var171 = var173; +RET_LABEL172:(void)0; } } { -{ /* Inline model#MClassDef#mmodule (var123) on */ -var128 = var123->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var128 == NULL)) { +{ /* Inline model$MClassDef$mmodule (var171) on */ +var176 = var171->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var176 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 573); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 588); fatal_exit(1); } -var126 = var128; -RET_LABEL127:(void)0; +var174 = var176; +RET_LABEL175:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var131 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var129 = var131; -RET_LABEL130:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var179 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var177 = var179; +RET_LABEL178:(void)0; } } -if (var129 == NULL) { +if (var177 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 528); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var129) on */ -if (unlikely(var129 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$mpropdef (var177) on */ +if (unlikely(var177 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var134 = var129->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var134 == NULL)) { +var182 = var177->attrs[COLOR_nitc__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var182 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1914); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2027); fatal_exit(1); } -var132 = var134; -RET_LABEL133:(void)0; +var180 = var182; +RET_LABEL181:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var132) on */ -var137 = var132->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var137 == NULL)) { +{ /* Inline model$MPropDef$mclassdef (var180) on */ +var185 = var180->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var185 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2227); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354); fatal_exit(1); } -var135 = var137; -RET_LABEL136:(void)0; +var183 = var185; +RET_LABEL184:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var135) on */ -var140 = var135->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var140 == NULL)) { +{ /* Inline model$MClassDef$bound_mtype (var183) on */ +var188 = var183->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var188 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 579); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594); fatal_exit(1); } -var138 = var140; -RET_LABEL139:(void)0; +var186 = var188; +RET_LABEL187:(void)0; } } { -var141 = nitc___nitc__MType___is_subtype(var114, var126, var138, var_mtype); -} -if (var141){ -if (unlikely(varonce142==NULL)) { -var143 = NEW_core__NativeArray(6l, &type_core__NativeArray__core__String); -if (likely(varonce144!=NULL)) { -var145 = varonce144; -} else { -var146 = " = 1; /* easy "; -var147 = core__flat___NativeString___to_s_full(var146, 14l, 14l); -var145 = var147; -varonce144 = var145; +var189 = nitc___nitc__MType___is_subtype(var162, var174, var186, var_mtype); } -((struct instance_core__NativeArray*)var143)->values[1]=var145; -if (likely(varonce148!=NULL)) { -var149 = varonce148; +if (var189){ +if (unlikely(varonce190==NULL)) { +var191 = NEW_core__NativeArray((int)6l, &type_core__NativeArray__core__String); +if (likely(varonce192!=NULL)) { +var193 = varonce192; } else { -var150 = " isa "; -var151 = core__flat___NativeString___to_s_full(var150, 5l, 5l); -var149 = var151; -varonce148 = var149; +var194 = " = 1; /* easy "; +var196 = (val*)(14l<<2|1); +var197 = (val*)(14l<<2|1); +var198 = (val*)((long)(0)<<2|3); +var199 = (val*)((long)(0)<<2|3); +var195 = core__flat___CString___to_s_unsafe(var194, var196, var197, var198, var199); +var193 = var195; +varonce192 = var193; } -((struct instance_core__NativeArray*)var143)->values[3]=var149; -if (likely(varonce152!=NULL)) { -var153 = varonce152; +((struct instance_core__NativeArray*)var191)->values[1]=var193; +if (likely(varonce200!=NULL)) { +var201 = varonce200; +} else { +var202 = " isa "; +var204 = (val*)(5l<<2|1); +var205 = (val*)(5l<<2|1); +var206 = (val*)((long)(0)<<2|3); +var207 = (val*)((long)(0)<<2|3); +var203 = core__flat___CString___to_s_unsafe(var202, var204, var205, var206, var207); +var201 = var203; +varonce200 = var201; +} +((struct instance_core__NativeArray*)var191)->values[3]=var201; +if (likely(varonce208!=NULL)) { +var209 = varonce208; } else { -var154 = "*/"; -var155 = core__flat___NativeString___to_s_full(var154, 2l, 2l); -var153 = var155; -varonce152 = var153; +var210 = "*/"; +var212 = (val*)(2l<<2|1); +var213 = (val*)(2l<<2|1); +var214 = (val*)((long)(0)<<2|3); +var215 = (val*)((long)(0)<<2|3); +var211 = core__flat___CString___to_s_unsafe(var210, var212, var213, var214, var215); +var209 = var211; +varonce208 = var209; } -((struct instance_core__NativeArray*)var143)->values[5]=var153; +((struct instance_core__NativeArray*)var191)->values[5]=var209; } else { -var143 = varonce142; -varonce142 = NULL; +var191 = varonce190; +varonce190 = NULL; } { -var156 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var216 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var143)->values[0]=var156; +((struct instance_core__NativeArray*)var191)->values[0]=var216; { -var157 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); +var217 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); } -((struct instance_core__NativeArray*)var143)->values[2]=var157; +((struct instance_core__NativeArray*)var191)->values[2]=var217; { -var158 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +var218 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ } -((struct instance_core__NativeArray*)var143)->values[4]=var158; +((struct instance_core__NativeArray*)var191)->values[4]=var218; { -var159 = ((val*(*)(val* self))(var143->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var143); /* native_to_s on */ +var219 = ((val*(*)(val* self))(var191->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var191); /* native_to_s on */ } -varonce142 = var143; +varonce190 = var191; { -nitc___nitc__AbstractCompilerVisitor___add(self, var159); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var219); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var162 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var162 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var222 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var222 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var160 = var162; -RET_LABEL161:(void)0; +var220 = var222; +RET_LABEL221:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var160) on */ -var165 = var160->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var165 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$modelbuilder (var220) on */ +var225 = var220->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var225 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 552); fatal_exit(1); } -var163 = var165; -RET_LABEL164:(void)0; +var223 = var225; +RET_LABEL224:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var163) on */ -var168 = var163->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var168 == NULL)) { +{ /* Inline modelbuilder_base$ModelBuilder$toolcontext (var223) on */ +var228 = var223->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var228 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47); fatal_exit(1); } -var166 = var168; -RET_LABEL167:(void)0; +var226 = var228; +RET_LABEL227:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var166) on */ -var171 = var166->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var171 == NULL)) { +{ /* Inline abstract_compiler$ToolContext$opt_typing_test_metrics (var226) on */ +var231 = var226->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var231 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 60); fatal_exit(1); } -var169 = var171; -RET_LABEL170:(void)0; +var229 = var231; +RET_LABEL230:(void)0; } } { -{ /* Inline opts#Option#value (var169) on */ -var174 = var169->attrs[COLOR_opts__Option___value].val; /* _value on */ -var172 = var174; -RET_LABEL173:(void)0; +{ /* Inline opts$Option$value (var229) on */ +var234 = var229->attrs[COLOR_opts__Option___value].val; /* _value on */ +var232 = var234; +RET_LABEL233:(void)0; } } -var175 = (short int)((long)(var172)>>2); -if (var175){ +var235 = (short int)((long)(var232)>>2); +if (var235){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var178 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var178 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var238 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var238 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var176 = var178; -RET_LABEL177:(void)0; +var236 = var238; +RET_LABEL237:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_skipped (var176) on */ -var181 = var176->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_skipped].val; /* _count_type_test_skipped on */ -if (unlikely(var181 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$count_type_test_skipped (var236) on */ +var241 = var236->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_skipped].val; /* _count_type_test_skipped on */ +if (unlikely(var241 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_skipped"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1048); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1113); fatal_exit(1); } -var179 = var181; -RET_LABEL180:(void)0; +var239 = var241; +RET_LABEL240:(void)0; } } -var_ = var179; -var_182 = var_tag; +var_ = var239; +var_242 = var_tag; { -var183 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_, var_182); +var243 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_, var_242); } { -{ /* Inline kernel#Int#+ (var183,1l) on */ +{ /* Inline kernel$Int$+ (var243,1l) on */ /* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ /* <1l:Int> isa OTHER */ -var186 = 1; /* easy <1l:Int> isa OTHER*/ -if (unlikely(!var186)) { +var246 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var246)) { 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); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); fatal_exit(1); } -var189 = (long)(var183)>>2; -var190 = var189 + 1l; -var184 = var190; -goto RET_LABEL185; -RET_LABEL185:(void)0; +var249 = (long)(var243)>>2; +var250 = var249 + 1l; +var244 = var250; +goto RET_LABEL245; +RET_LABEL245:(void)0; } } { -var191 = (val*)(var184<<2|1); -core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_, var_182, var191); /* Direct call hash_collection#HashMap#[]= on */ +var251 = (val*)(var244<<2|1); +core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_, var_242, var251); /* Direct call hash_collection$HashMap$[]= on */ } -if (unlikely(varonce192==NULL)) { -var193 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce194!=NULL)) { -var195 = varonce194; +if (unlikely(varonce252==NULL)) { +var253 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce254!=NULL)) { +var255 = varonce254; } else { -var196 = "count_type_test_skipped_"; -var197 = core__flat___NativeString___to_s_full(var196, 24l, 24l); -var195 = var197; -varonce194 = var195; +var256 = "count_type_test_skipped_"; +var258 = (val*)(24l<<2|1); +var259 = (val*)(24l<<2|1); +var260 = (val*)((long)(0)<<2|3); +var261 = (val*)((long)(0)<<2|3); +var257 = core__flat___CString___to_s_unsafe(var256, var258, var259, var260, var261); +var255 = var257; +varonce254 = var255; } -((struct instance_core__NativeArray*)var193)->values[0]=var195; -if (likely(varonce198!=NULL)) { -var199 = varonce198; +((struct instance_core__NativeArray*)var253)->values[0]=var255; +if (likely(varonce262!=NULL)) { +var263 = varonce262; } else { -var200 = "++;"; -var201 = core__flat___NativeString___to_s_full(var200, 3l, 3l); -var199 = var201; -varonce198 = var199; +var264 = "++;"; +var266 = (val*)(3l<<2|1); +var267 = (val*)(3l<<2|1); +var268 = (val*)((long)(0)<<2|3); +var269 = (val*)((long)(0)<<2|3); +var265 = core__flat___CString___to_s_unsafe(var264, var266, var267, var268, var269); +var263 = var265; +varonce262 = var263; } -((struct instance_core__NativeArray*)var193)->values[2]=var199; +((struct instance_core__NativeArray*)var253)->values[2]=var263; } else { -var193 = varonce192; -varonce192 = NULL; +var253 = varonce252; +varonce252 = NULL; } -((struct instance_core__NativeArray*)var193)->values[1]=var_tag; +((struct instance_core__NativeArray*)var253)->values[1]=var_tag; { -var202 = ((val*(*)(val* self))(var193->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var193); /* native_to_s on */ +var270 = ((val*(*)(val* self))(var253->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var253); /* native_to_s on */ } -varonce192 = var193; +varonce252 = var253; { -nitc___nitc__AbstractCompilerVisitor___add(self, var202); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var270); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { } @@ -1305,1091 +3522,1316 @@ goto RET_LABEL; } else { } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var205 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var205 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var273 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var273 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var203 = var205; -RET_LABEL204:(void)0; +var271 = var273; +RET_LABEL272:(void)0; } } { -var206 = ((short int(*)(val* self))(var203->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var203); /* is_c_primitive on */ +var274 = ((short int(*)(val* self))(var271->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var271); /* is_c_primitive on */ } -var207 = !var206; -if (var207){ -if (unlikely(varonce208==NULL)) { -var209 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce210!=NULL)) { -var211 = varonce210; +var275 = !var274; +if (var275){ +if (unlikely(varonce276==NULL)) { +var277 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce278!=NULL)) { +var279 = varonce278; } else { -var212 = "->class->"; -var213 = core__flat___NativeString___to_s_full(var212, 9l, 9l); -var211 = var213; -varonce210 = var211; +var280 = "->class->"; +var282 = (val*)(9l<<2|1); +var283 = (val*)(9l<<2|1); +var284 = (val*)((long)(0)<<2|3); +var285 = (val*)((long)(0)<<2|3); +var281 = core__flat___CString___to_s_unsafe(var280, var282, var283, var284, var285); +var279 = var281; +varonce278 = var279; } -((struct instance_core__NativeArray*)var209)->values[1]=var211; +((struct instance_core__NativeArray*)var277)->values[1]=var279; } else { -var209 = varonce208; -varonce208 = NULL; +var277 = varonce276; +varonce276 = NULL; } { -var214 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var286 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var209)->values[0]=var214; +((struct instance_core__NativeArray*)var277)->values[0]=var286; { -var215 = ((val*(*)(val* self))(var209->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var209); /* native_to_s on */ +var287 = ((val*(*)(val* self))(var277->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var277); /* native_to_s on */ } -varonce208 = var209; -var_class_ptr = var215; +varonce276 = var277; +var_class_ptr = var287; } else { { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var218 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var218 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var290 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var290 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var216 = var218; -RET_LABEL217:(void)0; +var288 = var290; +RET_LABEL289:(void)0; } } -/* isa MClassType */ -cltype220 = type_nitc__MClassType.color; -idtype221 = type_nitc__MClassType.id; -if(cltype220 >= var216->type->table_size) { -var219 = 0; +/* isa MClassType */ +cltype292 = type_nitc__MClassType.color; +idtype293 = type_nitc__MClassType.id; +if(cltype292 >= var288->type->table_size) { +var291 = 0; } else { -var219 = var216->type->type_table[cltype220] == idtype221; +var291 = var288->type->type_table[cltype292] == idtype293; } -if (unlikely(!var219)) { -var_class_name222 = var216 == NULL ? "null" : var216->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name222); +if (unlikely(!var291)) { +var_class_name294 = var288 == NULL ? "null" : var288->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name294); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 541); fatal_exit(1); } { -{ /* Inline model#MClassType#mclass (var216) on */ -var225 = var216->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var225 == NULL)) { +{ /* Inline model$MClassType$mclass (var288) on */ +var297 = var288->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var297 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } -var223 = var225; -RET_LABEL224:(void)0; +var295 = var297; +RET_LABEL296:(void)0; } } -var_mclass = var223; -if (unlikely(varonce226==NULL)) { -var227 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce228!=NULL)) { -var229 = varonce228; +var_mclass = var295; +if (unlikely(varonce298==NULL)) { +var299 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce300!=NULL)) { +var301 = varonce300; } else { -var230 = "class_"; -var231 = core__flat___NativeString___to_s_full(var230, 6l, 6l); -var229 = var231; -varonce228 = var229; +var302 = "class_"; +var304 = (val*)(6l<<2|1); +var305 = (val*)(6l<<2|1); +var306 = (val*)((long)(0)<<2|3); +var307 = (val*)((long)(0)<<2|3); +var303 = core__flat___CString___to_s_unsafe(var302, var304, var305, var306, var307); +var301 = var303; +varonce300 = var301; } -((struct instance_core__NativeArray*)var227)->values[0]=var229; +((struct instance_core__NativeArray*)var299)->values[0]=var301; } else { -var227 = varonce226; -varonce226 = NULL; +var299 = varonce298; +varonce298 = NULL; } { -var232 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass); +var308 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass); } -((struct instance_core__NativeArray*)var227)->values[1]=var232; +((struct instance_core__NativeArray*)var299)->values[1]=var308; { -var233 = ((val*(*)(val* self))(var227->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var227); /* native_to_s on */ +var309 = ((val*(*)(val* self))(var299->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var299); /* native_to_s on */ } -varonce226 = var227; +varonce298 = var299; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var233); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var309); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce234==NULL)) { -var235 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce236!=NULL)) { -var237 = varonce236; +if (unlikely(varonce310==NULL)) { +var311 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce312!=NULL)) { +var313 = varonce312; } else { -var238 = "class_"; -var239 = core__flat___NativeString___to_s_full(var238, 6l, 6l); -var237 = var239; -varonce236 = var237; +var314 = "class_"; +var316 = (val*)(6l<<2|1); +var317 = (val*)(6l<<2|1); +var318 = (val*)((long)(0)<<2|3); +var319 = (val*)((long)(0)<<2|3); +var315 = core__flat___CString___to_s_unsafe(var314, var316, var317, var318, var319); +var313 = var315; +varonce312 = var313; } -((struct instance_core__NativeArray*)var235)->values[0]=var237; -if (likely(varonce240!=NULL)) { -var241 = varonce240; +((struct instance_core__NativeArray*)var311)->values[0]=var313; +if (likely(varonce320!=NULL)) { +var321 = varonce320; } else { -var242 = "."; -var243 = core__flat___NativeString___to_s_full(var242, 1l, 1l); -var241 = var243; -varonce240 = var241; +var322 = "."; +var324 = (val*)(1l<<2|1); +var325 = (val*)(1l<<2|1); +var326 = (val*)((long)(0)<<2|3); +var327 = (val*)((long)(0)<<2|3); +var323 = core__flat___CString___to_s_unsafe(var322, var324, var325, var326, var327); +var321 = var323; +varonce320 = var321; } -((struct instance_core__NativeArray*)var235)->values[2]=var241; +((struct instance_core__NativeArray*)var311)->values[2]=var321; } else { -var235 = varonce234; -varonce234 = NULL; +var311 = varonce310; +varonce310 = NULL; } { -var244 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass); +var328 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass); } -((struct instance_core__NativeArray*)var235)->values[1]=var244; +((struct instance_core__NativeArray*)var311)->values[1]=var328; { -var245 = ((val*(*)(val* self))(var235->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var235); /* native_to_s on */ +var329 = ((val*(*)(val* self))(var311->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var311); /* native_to_s on */ } -varonce234 = var235; -var_class_ptr = var245; +varonce310 = var311; +var_class_ptr = var329; } /* isa MClassType */ -cltype247 = type_nitc__MClassType.color; -idtype248 = type_nitc__MClassType.id; -if(cltype247 >= var_mtype->type->table_size) { -var246 = 0; +cltype331 = type_nitc__MClassType.color; +idtype332 = type_nitc__MClassType.id; +if(cltype331 >= var_mtype->type->table_size) { +var330 = 0; } else { -var246 = var_mtype->type->type_table[cltype247] == idtype248; +var330 = var_mtype->type->type_table[cltype331] == idtype332; } -if (var246){ -if (unlikely(varonce249==NULL)) { -var250 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce251!=NULL)) { -var252 = varonce251; +if (var330){ +if (unlikely(varonce333==NULL)) { +var334 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce335!=NULL)) { +var336 = varonce335; } else { -var253 = "class_"; -var254 = core__flat___NativeString___to_s_full(var253, 6l, 6l); -var252 = var254; -varonce251 = var252; +var337 = "class_"; +var339 = (val*)(6l<<2|1); +var340 = (val*)(6l<<2|1); +var341 = (val*)((long)(0)<<2|3); +var342 = (val*)((long)(0)<<2|3); +var338 = core__flat___CString___to_s_unsafe(var337, var339, var340, var341, var342); +var336 = var338; +varonce335 = var336; } -((struct instance_core__NativeArray*)var250)->values[0]=var252; +((struct instance_core__NativeArray*)var334)->values[0]=var336; } else { -var250 = varonce249; -varonce249 = NULL; +var334 = varonce333; +varonce333 = NULL; } { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var257 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var257 == NULL)) { +{ /* Inline model$MClassType$mclass (var_mtype) on */ +var345 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var345 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } -var255 = var257; -RET_LABEL256:(void)0; +var343 = var345; +RET_LABEL344:(void)0; } } { -var258 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var255); +var346 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var343); } -((struct instance_core__NativeArray*)var250)->values[1]=var258; +((struct instance_core__NativeArray*)var334)->values[1]=var346; { -var259 = ((val*(*)(val* self))(var250->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var250); /* native_to_s on */ +var347 = ((val*(*)(val* self))(var334->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var334); /* native_to_s on */ } -varonce249 = var250; +varonce333 = var334; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var259); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var347); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce260==NULL)) { -var261 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce262!=NULL)) { -var263 = varonce262; +if (unlikely(varonce348==NULL)) { +var349 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce350!=NULL)) { +var351 = varonce350; } else { -var264 = " = class_"; -var265 = core__flat___NativeString___to_s_full(var264, 9l, 9l); -var263 = var265; -varonce262 = var263; +var352 = " = class_"; +var354 = (val*)(9l<<2|1); +var355 = (val*)(9l<<2|1); +var356 = (val*)((long)(0)<<2|3); +var357 = (val*)((long)(0)<<2|3); +var353 = core__flat___CString___to_s_unsafe(var352, var354, var355, var356, var357); +var351 = var353; +varonce350 = var351; } -((struct instance_core__NativeArray*)var261)->values[1]=var263; -if (likely(varonce266!=NULL)) { -var267 = varonce266; +((struct instance_core__NativeArray*)var349)->values[1]=var351; +if (likely(varonce358!=NULL)) { +var359 = varonce358; } else { -var268 = ".color;"; -var269 = core__flat___NativeString___to_s_full(var268, 7l, 7l); -var267 = var269; -varonce266 = var267; +var360 = ".color;"; +var362 = (val*)(7l<<2|1); +var363 = (val*)(7l<<2|1); +var364 = (val*)((long)(0)<<2|3); +var365 = (val*)((long)(0)<<2|3); +var361 = core__flat___CString___to_s_unsafe(var360, var362, var363, var364, var365); +var359 = var361; +varonce358 = var359; } -((struct instance_core__NativeArray*)var261)->values[3]=var267; +((struct instance_core__NativeArray*)var349)->values[3]=var359; } else { -var261 = varonce260; -varonce260 = NULL; +var349 = varonce348; +varonce348 = NULL; } -((struct instance_core__NativeArray*)var261)->values[0]=var_cltype; +((struct instance_core__NativeArray*)var349)->values[0]=var_cltype; { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var272 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var272 == NULL)) { +{ /* Inline model$MClassType$mclass (var_mtype) on */ +var368 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var368 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } -var270 = var272; -RET_LABEL271:(void)0; +var366 = var368; +RET_LABEL367:(void)0; } } { -var273 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var270); +var369 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var366); } -((struct instance_core__NativeArray*)var261)->values[2]=var273; +((struct instance_core__NativeArray*)var349)->values[2]=var369; { -var274 = ((val*(*)(val* self))(var261->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var261); /* native_to_s on */ +var370 = ((val*(*)(val* self))(var349->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var349); /* native_to_s on */ } -varonce260 = var261; +varonce348 = var349; { -nitc___nitc__AbstractCompilerVisitor___add(self, var274); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var370); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce275==NULL)) { -var276 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce277!=NULL)) { -var278 = varonce277; +if (unlikely(varonce371==NULL)) { +var372 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce373!=NULL)) { +var374 = varonce373; } else { -var279 = " = class_"; -var280 = core__flat___NativeString___to_s_full(var279, 9l, 9l); -var278 = var280; -varonce277 = var278; +var375 = " = class_"; +var377 = (val*)(9l<<2|1); +var378 = (val*)(9l<<2|1); +var379 = (val*)((long)(0)<<2|3); +var380 = (val*)((long)(0)<<2|3); +var376 = core__flat___CString___to_s_unsafe(var375, var377, var378, var379, var380); +var374 = var376; +varonce373 = var374; } -((struct instance_core__NativeArray*)var276)->values[1]=var278; -if (likely(varonce281!=NULL)) { -var282 = varonce281; +((struct instance_core__NativeArray*)var372)->values[1]=var374; +if (likely(varonce381!=NULL)) { +var382 = varonce381; } else { -var283 = ".id;"; -var284 = core__flat___NativeString___to_s_full(var283, 4l, 4l); -var282 = var284; -varonce281 = var282; +var383 = ".id;"; +var385 = (val*)(4l<<2|1); +var386 = (val*)(4l<<2|1); +var387 = (val*)((long)(0)<<2|3); +var388 = (val*)((long)(0)<<2|3); +var384 = core__flat___CString___to_s_unsafe(var383, var385, var386, var387, var388); +var382 = var384; +varonce381 = var382; } -((struct instance_core__NativeArray*)var276)->values[3]=var282; +((struct instance_core__NativeArray*)var372)->values[3]=var382; } else { -var276 = varonce275; -varonce275 = NULL; +var372 = varonce371; +varonce371 = NULL; } -((struct instance_core__NativeArray*)var276)->values[0]=var_idtype; +((struct instance_core__NativeArray*)var372)->values[0]=var_idtype; { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var287 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var287 == NULL)) { +{ /* Inline model$MClassType$mclass (var_mtype) on */ +var391 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var391 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } -var285 = var287; -RET_LABEL286:(void)0; +var389 = var391; +RET_LABEL390:(void)0; } } { -var288 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var285); +var392 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var389); } -((struct instance_core__NativeArray*)var276)->values[2]=var288; +((struct instance_core__NativeArray*)var372)->values[2]=var392; { -var289 = ((val*(*)(val* self))(var276->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var276); /* native_to_s on */ +var393 = ((val*(*)(val* self))(var372->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var372); /* native_to_s on */ } -varonce275 = var276; +varonce371 = var372; { -nitc___nitc__AbstractCompilerVisitor___add(self, var289); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var393); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var292 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var292 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var396 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var396 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var290 = var292; -RET_LABEL291:(void)0; +var394 = var396; +RET_LABEL395:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var290) on */ -var295 = var290->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var295 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$modelbuilder (var394) on */ +var399 = var394->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var399 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 552); fatal_exit(1); } -var293 = var295; -RET_LABEL294:(void)0; +var397 = var399; +RET_LABEL398:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var293) on */ -var298 = var293->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var298 == NULL)) { +{ /* Inline modelbuilder_base$ModelBuilder$toolcontext (var397) on */ +var402 = var397->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var402 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47); fatal_exit(1); } -var296 = var298; -RET_LABEL297:(void)0; +var400 = var402; +RET_LABEL401:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var296) on */ -var301 = var296->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var301 == NULL)) { +{ /* Inline abstract_compiler$ToolContext$opt_typing_test_metrics (var400) on */ +var405 = var400->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var405 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 60); fatal_exit(1); } -var299 = var301; -RET_LABEL300:(void)0; +var403 = var405; +RET_LABEL404:(void)0; } } { -{ /* Inline opts#Option#value (var299) on */ -var304 = var299->attrs[COLOR_opts__Option___value].val; /* _value on */ -var302 = var304; -RET_LABEL303:(void)0; +{ /* Inline opts$Option$value (var403) on */ +var408 = var403->attrs[COLOR_opts__Option___value].val; /* _value on */ +var406 = var408; +RET_LABEL407:(void)0; } } -var305 = (short int)((long)(var302)>>2); -if (var305){ +var409 = (short int)((long)(var406)>>2); +if (var409){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var308 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var308 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var412 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var412 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var306 = var308; -RET_LABEL307:(void)0; +var410 = var412; +RET_LABEL411:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_resolved (var306) on */ -var311 = var306->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_resolved].val; /* _count_type_test_resolved on */ -if (unlikely(var311 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$count_type_test_resolved (var410) on */ +var415 = var410->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_resolved].val; /* _count_type_test_resolved on */ +if (unlikely(var415 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_resolved"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1046); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1111); fatal_exit(1); } -var309 = var311; -RET_LABEL310:(void)0; +var413 = var415; +RET_LABEL414:(void)0; } } -var_312 = var309; -var_313 = var_tag; +var_416 = var413; +var_417 = var_tag; { -var314 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_312, var_313); +var418 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_416, var_417); } { -{ /* Inline kernel#Int#+ (var314,1l) on */ +{ /* Inline kernel$Int$+ (var418,1l) on */ /* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ /* <1l:Int> isa OTHER */ -var317 = 1; /* easy <1l:Int> isa OTHER*/ -if (unlikely(!var317)) { -var_class_name320 = type_core__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name320); -PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +var421 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var421)) { +var_class_name424 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name424); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); fatal_exit(1); } -var321 = (long)(var314)>>2; -var322 = var321 + 1l; -var315 = var322; -goto RET_LABEL316; -RET_LABEL316:(void)0; +var425 = (long)(var418)>>2; +var426 = var425 + 1l; +var419 = var426; +goto RET_LABEL420; +RET_LABEL420:(void)0; } } { -var323 = (val*)(var315<<2|1); -core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_312, var_313, var323); /* Direct call hash_collection#HashMap#[]= on */ +var427 = (val*)(var419<<2|1); +core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_416, var_417, var427); /* Direct call hash_collection$HashMap$[]= on */ } -if (unlikely(varonce324==NULL)) { -var325 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce326!=NULL)) { -var327 = varonce326; +if (unlikely(varonce428==NULL)) { +var429 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce430!=NULL)) { +var431 = varonce430; } else { -var328 = "count_type_test_resolved_"; -var329 = core__flat___NativeString___to_s_full(var328, 25l, 25l); -var327 = var329; -varonce326 = var327; +var432 = "count_type_test_resolved_"; +var434 = (val*)(25l<<2|1); +var435 = (val*)(25l<<2|1); +var436 = (val*)((long)(0)<<2|3); +var437 = (val*)((long)(0)<<2|3); +var433 = core__flat___CString___to_s_unsafe(var432, var434, var435, var436, var437); +var431 = var433; +varonce430 = var431; } -((struct instance_core__NativeArray*)var325)->values[0]=var327; -if (likely(varonce330!=NULL)) { -var331 = varonce330; +((struct instance_core__NativeArray*)var429)->values[0]=var431; +if (likely(varonce438!=NULL)) { +var439 = varonce438; } else { -var332 = "++;"; -var333 = core__flat___NativeString___to_s_full(var332, 3l, 3l); -var331 = var333; -varonce330 = var331; +var440 = "++;"; +var442 = (val*)(3l<<2|1); +var443 = (val*)(3l<<2|1); +var444 = (val*)((long)(0)<<2|3); +var445 = (val*)((long)(0)<<2|3); +var441 = core__flat___CString___to_s_unsafe(var440, var442, var443, var444, var445); +var439 = var441; +varonce438 = var439; } -((struct instance_core__NativeArray*)var325)->values[2]=var331; +((struct instance_core__NativeArray*)var429)->values[2]=var439; } else { -var325 = varonce324; -varonce324 = NULL; +var429 = varonce428; +varonce428 = NULL; } -((struct instance_core__NativeArray*)var325)->values[1]=var_tag; +((struct instance_core__NativeArray*)var429)->values[1]=var_tag; { -var334 = ((val*(*)(val* self))(var325->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var325); /* native_to_s on */ +var446 = ((val*(*)(val* self))(var429->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var429); /* native_to_s on */ } -varonce324 = var325; +varonce428 = var429; { -nitc___nitc__AbstractCompilerVisitor___add(self, var334); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var446); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { } } else { /* isa MVirtualType */ -cltype336 = type_nitc__MVirtualType.color; -idtype337 = type_nitc__MVirtualType.id; -if(cltype336 >= var_mtype->type->table_size) { -var335 = 0; +cltype448 = type_nitc__MVirtualType.color; +idtype449 = type_nitc__MVirtualType.id; +if(cltype448 >= var_mtype->type->table_size) { +var447 = 0; } else { -var335 = var_mtype->type->type_table[cltype336] == idtype337; +var447 = var_mtype->type->type_table[cltype448] == idtype449; } -if (var335){ +if (var447){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var340 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var338 = var340; -RET_LABEL339:(void)0; +{ /* Inline abstract_compiler$AbstractCompilerVisitor$frame (self) on */ +var452 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var450 = var452; +RET_LABEL451:(void)0; +} } +if (var450 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); } -if (var338 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 555); fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#arguments (var338) on */ -if (unlikely(var338 == NULL)) { +{ /* Inline abstract_compiler$StaticFrame$arguments (var450) on */ +if (unlikely(var450 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1921); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2034); fatal_exit(1); } -var343 = var338->attrs[COLOR_nitc__abstract_compiler__StaticFrame___arguments].val; /* _arguments on */ -if (unlikely(var343 == NULL)) { +var455 = var450->attrs[COLOR_nitc__abstract_compiler__StaticFrame___arguments].val; /* _arguments on */ +if (unlikely(var455 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _arguments"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1921); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 2034); fatal_exit(1); } -var341 = var343; -RET_LABEL342:(void)0; +var453 = var455; +RET_LABEL454:(void)0; } } { -var344 = core___core__SequenceRead___Collection__first(var341); +var456 = core___core__SequenceRead___Collection__first(var453); } -var_recv = var344; +var_recv = var456; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ -var347 = var_recv->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var347 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_recv) on */ +var459 = var_recv->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var459 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var345 = var347; -RET_LABEL346:(void)0; +var457 = var459; +RET_LABEL458:(void)0; } } { -var348 = ((short int(*)(val* self))(var345->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var345); /* is_c_primitive on */ +var460 = ((short int(*)(val* self))(var457->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var457); /* is_c_primitive on */ } -var349 = !var348; -if (var349){ -if (unlikely(varonce350==NULL)) { -var351 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce352!=NULL)) { -var353 = varonce352; +var461 = !var460; +if (var461){ +if (unlikely(varonce462==NULL)) { +var463 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce464!=NULL)) { +var465 = varonce464; } else { -var354 = "->class->"; -var355 = core__flat___NativeString___to_s_full(var354, 9l, 9l); -var353 = var355; -varonce352 = var353; +var466 = "->class->"; +var468 = (val*)(9l<<2|1); +var469 = (val*)(9l<<2|1); +var470 = (val*)((long)(0)<<2|3); +var471 = (val*)((long)(0)<<2|3); +var467 = core__flat___CString___to_s_unsafe(var466, var468, var469, var470, var471); +var465 = var467; +varonce464 = var465; } -((struct instance_core__NativeArray*)var351)->values[1]=var353; +((struct instance_core__NativeArray*)var463)->values[1]=var465; } else { -var351 = varonce350; -varonce350 = NULL; +var463 = varonce462; +varonce462 = NULL; } { -var356 = ((val*(*)(val* self))(var_recv->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_recv); /* to_s on */ +var472 = ((val*(*)(val* self))(var_recv->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_recv); /* to_s on */ } -((struct instance_core__NativeArray*)var351)->values[0]=var356; +((struct instance_core__NativeArray*)var463)->values[0]=var472; { -var357 = ((val*(*)(val* self))(var351->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var351); /* native_to_s on */ +var473 = ((val*(*)(val* self))(var463->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var463); /* native_to_s on */ } -varonce350 = var351; -var_recv_ptr = var357; +varonce462 = var463; +var_recv_ptr = var473; } else { { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ -var360 = var_recv->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var360 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_recv) on */ +var476 = var_recv->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var476 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var358 = var360; -RET_LABEL359:(void)0; +var474 = var476; +RET_LABEL475:(void)0; } } -/* isa MClassType */ -cltype362 = type_nitc__MClassType.color; -idtype363 = type_nitc__MClassType.id; -if(cltype362 >= var358->type->table_size) { -var361 = 0; +/* isa MClassType */ +cltype478 = type_nitc__MClassType.color; +idtype479 = type_nitc__MClassType.id; +if(cltype478 >= var474->type->table_size) { +var477 = 0; } else { -var361 = var358->type->type_table[cltype362] == idtype363; +var477 = var474->type->type_table[cltype478] == idtype479; } -if (unlikely(!var361)) { -var_class_name364 = var358 == NULL ? "null" : var358->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name364); +if (unlikely(!var477)) { +var_class_name480 = var474 == NULL ? "null" : var474->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name480); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 560); fatal_exit(1); } { -{ /* Inline model#MClassType#mclass (var358) on */ -var367 = var358->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var367 == NULL)) { +{ /* Inline model$MClassType$mclass (var474) on */ +var483 = var474->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var483 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } -var365 = var367; -RET_LABEL366:(void)0; +var481 = var483; +RET_LABEL482:(void)0; } } -var_mclass368 = var365; -if (unlikely(varonce369==NULL)) { -var370 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce371!=NULL)) { -var372 = varonce371; +var_mclass484 = var481; +if (unlikely(varonce485==NULL)) { +var486 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce487!=NULL)) { +var488 = varonce487; } else { -var373 = "class_"; -var374 = core__flat___NativeString___to_s_full(var373, 6l, 6l); -var372 = var374; -varonce371 = var372; +var489 = "class_"; +var491 = (val*)(6l<<2|1); +var492 = (val*)(6l<<2|1); +var493 = (val*)((long)(0)<<2|3); +var494 = (val*)((long)(0)<<2|3); +var490 = core__flat___CString___to_s_unsafe(var489, var491, var492, var493, var494); +var488 = var490; +varonce487 = var488; } -((struct instance_core__NativeArray*)var370)->values[0]=var372; +((struct instance_core__NativeArray*)var486)->values[0]=var488; } else { -var370 = varonce369; -varonce369 = NULL; +var486 = varonce485; +varonce485 = NULL; } { -var375 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass368); +var495 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass484); } -((struct instance_core__NativeArray*)var370)->values[1]=var375; +((struct instance_core__NativeArray*)var486)->values[1]=var495; { -var376 = ((val*(*)(val* self))(var370->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var370); /* native_to_s on */ +var496 = ((val*(*)(val* self))(var486->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var486); /* native_to_s on */ } -varonce369 = var370; +varonce485 = var486; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var376); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var496); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce377==NULL)) { -var378 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce379!=NULL)) { -var380 = varonce379; +if (unlikely(varonce497==NULL)) { +var498 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce499!=NULL)) { +var500 = varonce499; } else { -var381 = "class_"; -var382 = core__flat___NativeString___to_s_full(var381, 6l, 6l); -var380 = var382; -varonce379 = var380; +var501 = "class_"; +var503 = (val*)(6l<<2|1); +var504 = (val*)(6l<<2|1); +var505 = (val*)((long)(0)<<2|3); +var506 = (val*)((long)(0)<<2|3); +var502 = core__flat___CString___to_s_unsafe(var501, var503, var504, var505, var506); +var500 = var502; +varonce499 = var500; } -((struct instance_core__NativeArray*)var378)->values[0]=var380; -if (likely(varonce383!=NULL)) { -var384 = varonce383; +((struct instance_core__NativeArray*)var498)->values[0]=var500; +if (likely(varonce507!=NULL)) { +var508 = varonce507; } else { -var385 = "."; -var386 = core__flat___NativeString___to_s_full(var385, 1l, 1l); -var384 = var386; -varonce383 = var384; +var509 = "."; +var511 = (val*)(1l<<2|1); +var512 = (val*)(1l<<2|1); +var513 = (val*)((long)(0)<<2|3); +var514 = (val*)((long)(0)<<2|3); +var510 = core__flat___CString___to_s_unsafe(var509, var511, var512, var513, var514); +var508 = var510; +varonce507 = var508; } -((struct instance_core__NativeArray*)var378)->values[2]=var384; +((struct instance_core__NativeArray*)var498)->values[2]=var508; } else { -var378 = varonce377; -varonce377 = NULL; +var498 = varonce497; +varonce497 = NULL; } { -var387 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass368); +var515 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_mclass484); } -((struct instance_core__NativeArray*)var378)->values[1]=var387; +((struct instance_core__NativeArray*)var498)->values[1]=var515; { -var388 = ((val*(*)(val* self))(var378->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var378); /* native_to_s on */ +var516 = ((val*(*)(val* self))(var498->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var498); /* native_to_s on */ } -varonce377 = var378; -var_recv_ptr = var388; +varonce497 = var498; +var_recv_ptr = var516; } -if (likely(varonce389!=NULL)) { -var390 = varonce389; +if (likely(varonce517!=NULL)) { +var518 = varonce517; } else { -var391 = "entry"; -var392 = core__flat___NativeString___to_s_full(var391, 5l, 5l); -var390 = var392; -varonce389 = var390; +var519 = "entry"; +var521 = (val*)(5l<<2|1); +var522 = (val*)(5l<<2|1); +var523 = (val*)((long)(0)<<2|3); +var524 = (val*)((long)(0)<<2|3); +var520 = core__flat___CString___to_s_unsafe(var519, var521, var522, var523, var524); +var518 = var520; +varonce517 = var518; } { -var393 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var390); +var525 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var518); } -var_entry = var393; -if (unlikely(varonce394==NULL)) { -var395 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce396!=NULL)) { -var397 = varonce396; +var_entry = var525; +if (unlikely(varonce526==NULL)) { +var527 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce528!=NULL)) { +var529 = varonce528; } else { -var398 = "struct vts_entry "; -var399 = core__flat___NativeString___to_s_full(var398, 17l, 17l); -var397 = var399; -varonce396 = var397; +var530 = "struct vts_entry "; +var532 = (val*)(17l<<2|1); +var533 = (val*)(17l<<2|1); +var534 = (val*)((long)(0)<<2|3); +var535 = (val*)((long)(0)<<2|3); +var531 = core__flat___CString___to_s_unsafe(var530, var532, var533, var534, var535); +var529 = var531; +varonce528 = var529; } -((struct instance_core__NativeArray*)var395)->values[0]=var397; -if (likely(varonce400!=NULL)) { -var401 = varonce400; +((struct instance_core__NativeArray*)var527)->values[0]=var529; +if (likely(varonce536!=NULL)) { +var537 = varonce536; } else { -var402 = ";"; -var403 = core__flat___NativeString___to_s_full(var402, 1l, 1l); -var401 = var403; -varonce400 = var401; +var538 = ";"; +var540 = (val*)(1l<<2|1); +var541 = (val*)(1l<<2|1); +var542 = (val*)((long)(0)<<2|3); +var543 = (val*)((long)(0)<<2|3); +var539 = core__flat___CString___to_s_unsafe(var538, var540, var541, var542, var543); +var537 = var539; +varonce536 = var537; } -((struct instance_core__NativeArray*)var395)->values[2]=var401; +((struct instance_core__NativeArray*)var527)->values[2]=var537; } else { -var395 = varonce394; -varonce394 = NULL; +var527 = varonce526; +varonce526 = NULL; } -((struct instance_core__NativeArray*)var395)->values[1]=var_entry; +((struct instance_core__NativeArray*)var527)->values[1]=var_entry; { -var404 = ((val*(*)(val* self))(var395->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var395); /* native_to_s on */ +var544 = ((val*(*)(val* self))(var527->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var527); /* native_to_s on */ } -varonce394 = var395; +varonce526 = var527; { -nitc___nitc__AbstractCompilerVisitor___add(self, var404); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var544); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } { -{ /* Inline model#MVirtualType#mproperty (var_mtype) on */ -var407 = var_mtype->attrs[COLOR_nitc__model__MVirtualType___mproperty].val; /* _mproperty on */ -if (unlikely(var407 == NULL)) { +{ /* Inline model$MVirtualType$mproperty (var_mtype) on */ +var547 = var_mtype->attrs[COLOR_nitc__model__MVirtualType___mproperty].val; /* _mproperty on */ +if (unlikely(var547 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1369); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1423); fatal_exit(1); } -var405 = var407; -RET_LABEL406:(void)0; +var545 = var547; +RET_LABEL546:(void)0; } } { -var408 = nitc__separate_compiler___MEntity___const_color(var405); +var548 = nitc__separate_compiler___MEntity___const_color(var545); } { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var408); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var548); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce409==NULL)) { -var410 = NEW_core__NativeArray(6l, &type_core__NativeArray__core__String); -if (likely(varonce411!=NULL)) { -var412 = varonce411; +if (unlikely(varonce549==NULL)) { +var550 = NEW_core__NativeArray((int)6l, &type_core__NativeArray__core__String); +if (likely(varonce551!=NULL)) { +var552 = varonce551; } else { -var413 = " = "; -var414 = core__flat___NativeString___to_s_full(var413, 3l, 3l); -var412 = var414; -varonce411 = var412; +var553 = " = "; +var555 = (val*)(3l<<2|1); +var556 = (val*)(3l<<2|1); +var557 = (val*)((long)(0)<<2|3); +var558 = (val*)((long)(0)<<2|3); +var554 = core__flat___CString___to_s_unsafe(var553, var555, var556, var557, var558); +var552 = var554; +varonce551 = var552; } -((struct instance_core__NativeArray*)var410)->values[1]=var412; -if (likely(varonce415!=NULL)) { -var416 = varonce415; +((struct instance_core__NativeArray*)var550)->values[1]=var552; +if (likely(varonce559!=NULL)) { +var560 = varonce559; } else { -var417 = "vts_table->vts["; -var418 = core__flat___NativeString___to_s_full(var417, 15l, 15l); -var416 = var418; -varonce415 = var416; +var561 = "vts_table->vts["; +var563 = (val*)(15l<<2|1); +var564 = (val*)(15l<<2|1); +var565 = (val*)((long)(0)<<2|3); +var566 = (val*)((long)(0)<<2|3); +var562 = core__flat___CString___to_s_unsafe(var561, var563, var564, var565, var566); +var560 = var562; +varonce559 = var560; } -((struct instance_core__NativeArray*)var410)->values[3]=var416; -if (likely(varonce419!=NULL)) { -var420 = varonce419; +((struct instance_core__NativeArray*)var550)->values[3]=var560; +if (likely(varonce567!=NULL)) { +var568 = varonce567; } else { -var421 = "];"; -var422 = core__flat___NativeString___to_s_full(var421, 2l, 2l); -var420 = var422; -varonce419 = var420; +var569 = "];"; +var571 = (val*)(2l<<2|1); +var572 = (val*)(2l<<2|1); +var573 = (val*)((long)(0)<<2|3); +var574 = (val*)((long)(0)<<2|3); +var570 = core__flat___CString___to_s_unsafe(var569, var571, var572, var573, var574); +var568 = var570; +varonce567 = var568; } -((struct instance_core__NativeArray*)var410)->values[5]=var420; +((struct instance_core__NativeArray*)var550)->values[5]=var568; } else { -var410 = varonce409; -varonce409 = NULL; +var550 = varonce549; +varonce549 = NULL; } -((struct instance_core__NativeArray*)var410)->values[0]=var_entry; -((struct instance_core__NativeArray*)var410)->values[2]=var_recv_ptr; +((struct instance_core__NativeArray*)var550)->values[0]=var_entry; +((struct instance_core__NativeArray*)var550)->values[2]=var_recv_ptr; { -{ /* Inline model#MVirtualType#mproperty (var_mtype) on */ -var425 = var_mtype->attrs[COLOR_nitc__model__MVirtualType___mproperty].val; /* _mproperty on */ -if (unlikely(var425 == NULL)) { +{ /* Inline model$MVirtualType$mproperty (var_mtype) on */ +var577 = var_mtype->attrs[COLOR_nitc__model__MVirtualType___mproperty].val; /* _mproperty on */ +if (unlikely(var577 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1369); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1423); fatal_exit(1); } -var423 = var425; -RET_LABEL424:(void)0; +var575 = var577; +RET_LABEL576:(void)0; } } { -var426 = nitc__separate_compiler___MEntity___const_color(var423); +var578 = nitc__separate_compiler___MEntity___const_color(var575); } -((struct instance_core__NativeArray*)var410)->values[4]=var426; +((struct instance_core__NativeArray*)var550)->values[4]=var578; { -var427 = ((val*(*)(val* self))(var410->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var410); /* native_to_s on */ +var579 = ((val*(*)(val* self))(var550->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var550); /* native_to_s on */ } -varonce409 = var410; +varonce549 = var550; { -nitc___nitc__AbstractCompilerVisitor___add(self, var427); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var579); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce428==NULL)) { -var429 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce430!=NULL)) { -var431 = varonce430; +if (unlikely(varonce580==NULL)) { +var581 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce582!=NULL)) { +var583 = varonce582; } else { -var432 = " = "; -var433 = core__flat___NativeString___to_s_full(var432, 3l, 3l); -var431 = var433; -varonce430 = var431; +var584 = " = "; +var586 = (val*)(3l<<2|1); +var587 = (val*)(3l<<2|1); +var588 = (val*)((long)(0)<<2|3); +var589 = (val*)((long)(0)<<2|3); +var585 = core__flat___CString___to_s_unsafe(var584, var586, var587, var588, var589); +var583 = var585; +varonce582 = var583; } -((struct instance_core__NativeArray*)var429)->values[1]=var431; -if (likely(varonce434!=NULL)) { -var435 = varonce434; +((struct instance_core__NativeArray*)var581)->values[1]=var583; +if (likely(varonce590!=NULL)) { +var591 = varonce590; } else { -var436 = ".class->color;"; -var437 = core__flat___NativeString___to_s_full(var436, 14l, 14l); -var435 = var437; -varonce434 = var435; +var592 = ".class->color;"; +var594 = (val*)(14l<<2|1); +var595 = (val*)(14l<<2|1); +var596 = (val*)((long)(0)<<2|3); +var597 = (val*)((long)(0)<<2|3); +var593 = core__flat___CString___to_s_unsafe(var592, var594, var595, var596, var597); +var591 = var593; +varonce590 = var591; } -((struct instance_core__NativeArray*)var429)->values[3]=var435; +((struct instance_core__NativeArray*)var581)->values[3]=var591; } else { -var429 = varonce428; -varonce428 = NULL; +var581 = varonce580; +varonce580 = NULL; } -((struct instance_core__NativeArray*)var429)->values[0]=var_cltype; -((struct instance_core__NativeArray*)var429)->values[2]=var_entry; +((struct instance_core__NativeArray*)var581)->values[0]=var_cltype; +((struct instance_core__NativeArray*)var581)->values[2]=var_entry; { -var438 = ((val*(*)(val* self))(var429->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var429); /* native_to_s on */ +var598 = ((val*(*)(val* self))(var581->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var581); /* native_to_s on */ } -varonce428 = var429; +varonce580 = var581; { -nitc___nitc__AbstractCompilerVisitor___add(self, var438); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var598); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce439==NULL)) { -var440 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce441!=NULL)) { -var442 = varonce441; +if (unlikely(varonce599==NULL)) { +var600 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce601!=NULL)) { +var602 = varonce601; } else { -var443 = " = "; -var444 = core__flat___NativeString___to_s_full(var443, 3l, 3l); -var442 = var444; -varonce441 = var442; +var603 = " = "; +var605 = (val*)(3l<<2|1); +var606 = (val*)(3l<<2|1); +var607 = (val*)((long)(0)<<2|3); +var608 = (val*)((long)(0)<<2|3); +var604 = core__flat___CString___to_s_unsafe(var603, var605, var606, var607, var608); +var602 = var604; +varonce601 = var602; } -((struct instance_core__NativeArray*)var440)->values[1]=var442; -if (likely(varonce445!=NULL)) { -var446 = varonce445; +((struct instance_core__NativeArray*)var600)->values[1]=var602; +if (likely(varonce609!=NULL)) { +var610 = varonce609; } else { -var447 = ".class->id;"; -var448 = core__flat___NativeString___to_s_full(var447, 11l, 11l); -var446 = var448; -varonce445 = var446; +var611 = ".class->id;"; +var613 = (val*)(11l<<2|1); +var614 = (val*)(11l<<2|1); +var615 = (val*)((long)(0)<<2|3); +var616 = (val*)((long)(0)<<2|3); +var612 = core__flat___CString___to_s_unsafe(var611, var613, var614, var615, var616); +var610 = var612; +varonce609 = var610; } -((struct instance_core__NativeArray*)var440)->values[3]=var446; +((struct instance_core__NativeArray*)var600)->values[3]=var610; } else { -var440 = varonce439; -varonce439 = NULL; +var600 = varonce599; +varonce599 = NULL; } -((struct instance_core__NativeArray*)var440)->values[0]=var_idtype; -((struct instance_core__NativeArray*)var440)->values[2]=var_entry; +((struct instance_core__NativeArray*)var600)->values[0]=var_idtype; +((struct instance_core__NativeArray*)var600)->values[2]=var_entry; { -var449 = ((val*(*)(val* self))(var440->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var440); /* native_to_s on */ +var617 = ((val*(*)(val* self))(var600->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var600); /* native_to_s on */ } -varonce439 = var440; +varonce599 = var600; { -nitc___nitc__AbstractCompilerVisitor___add(self, var449); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var617); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -var_451 = var_maybe_null; +var_619 = var_maybe_null; if (var_maybe_null){ -if (likely(varonce452!=NULL)) { -var453 = varonce452; -} else { -var454 = "0"; -var455 = core__flat___NativeString___to_s_full(var454, 1l, 1l); -var453 = var455; -varonce452 = var453; -} +if (likely(varonce620!=NULL)) { +var621 = varonce620; +} else { +var622 = "0"; +var624 = (val*)(1l<<2|1); +var625 = (val*)(1l<<2|1); +var626 = (val*)((long)(0)<<2|3); +var627 = (val*)((long)(0)<<2|3); +var623 = core__flat___CString___to_s_unsafe(var622, var624, var625, var626, var627); +var621 = var623; +varonce620 = var621; +} { -var456 = ((short int(*)(val* self, val* p0))(var_accept_null->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_accept_null, var453); /* == on */ +var628 = ((short int(*)(val* self, val* p0))(var_accept_null->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_accept_null, var621); /* == on */ } -var450 = var456; +var618 = var628; } else { -var450 = var_451; +var618 = var_619; } -if (var450){ -if (likely(varonce457!=NULL)) { -var458 = varonce457; +if (var618){ +if (likely(varonce629!=NULL)) { +var630 = varonce629; } else { -var459 = "is_nullable"; -var460 = core__flat___NativeString___to_s_full(var459, 11l, 11l); -var458 = var460; -varonce457 = var458; +var631 = "is_nullable"; +var633 = (val*)(11l<<2|1); +var634 = (val*)(11l<<2|1); +var635 = (val*)((long)(0)<<2|3); +var636 = (val*)((long)(0)<<2|3); +var632 = core__flat___CString___to_s_unsafe(var631, var633, var634, var635, var636); +var630 = var632; +varonce629 = var630; } { -var461 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var458); +var637 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var630); } -var_is_nullable = var461; -if (unlikely(varonce462==NULL)) { -var463 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce464!=NULL)) { -var465 = varonce464; +var_is_nullable = var637; +if (unlikely(varonce638==NULL)) { +var639 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce640!=NULL)) { +var641 = varonce640; } else { -var466 = "short int "; -var467 = core__flat___NativeString___to_s_full(var466, 10l, 10l); -var465 = var467; -varonce464 = var465; +var642 = "short int "; +var644 = (val*)(10l<<2|1); +var645 = (val*)(10l<<2|1); +var646 = (val*)((long)(0)<<2|3); +var647 = (val*)((long)(0)<<2|3); +var643 = core__flat___CString___to_s_unsafe(var642, var644, var645, var646, var647); +var641 = var643; +varonce640 = var641; } -((struct instance_core__NativeArray*)var463)->values[0]=var465; -if (likely(varonce468!=NULL)) { -var469 = varonce468; +((struct instance_core__NativeArray*)var639)->values[0]=var641; +if (likely(varonce648!=NULL)) { +var649 = varonce648; } else { -var470 = ";"; -var471 = core__flat___NativeString___to_s_full(var470, 1l, 1l); -var469 = var471; -varonce468 = var469; +var650 = ";"; +var652 = (val*)(1l<<2|1); +var653 = (val*)(1l<<2|1); +var654 = (val*)((long)(0)<<2|3); +var655 = (val*)((long)(0)<<2|3); +var651 = core__flat___CString___to_s_unsafe(var650, var652, var653, var654, var655); +var649 = var651; +varonce648 = var649; } -((struct instance_core__NativeArray*)var463)->values[2]=var469; +((struct instance_core__NativeArray*)var639)->values[2]=var649; } else { -var463 = varonce462; -varonce462 = NULL; +var639 = varonce638; +varonce638 = NULL; } -((struct instance_core__NativeArray*)var463)->values[1]=var_is_nullable; +((struct instance_core__NativeArray*)var639)->values[1]=var_is_nullable; { -var472 = ((val*(*)(val* self))(var463->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var463); /* native_to_s on */ +var656 = ((val*(*)(val* self))(var639->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var639); /* native_to_s on */ } -varonce462 = var463; +varonce638 = var639; { -nitc___nitc__AbstractCompilerVisitor___add_decl(self, var472); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nitc___nitc__AbstractCompilerVisitor___add_decl(self, var656); /* Direct call abstract_compiler$AbstractCompilerVisitor$add_decl on */ } -if (unlikely(varonce473==NULL)) { -var474 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce475!=NULL)) { -var476 = varonce475; +if (unlikely(varonce657==NULL)) { +var658 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce659!=NULL)) { +var660 = varonce659; } else { -var477 = " = "; -var478 = core__flat___NativeString___to_s_full(var477, 3l, 3l); -var476 = var478; -varonce475 = var476; +var661 = " = "; +var663 = (val*)(3l<<2|1); +var664 = (val*)(3l<<2|1); +var665 = (val*)((long)(0)<<2|3); +var666 = (val*)((long)(0)<<2|3); +var662 = core__flat___CString___to_s_unsafe(var661, var663, var664, var665, var666); +var660 = var662; +varonce659 = var660; } -((struct instance_core__NativeArray*)var474)->values[1]=var476; -if (likely(varonce479!=NULL)) { -var480 = varonce479; +((struct instance_core__NativeArray*)var658)->values[1]=var660; +if (likely(varonce667!=NULL)) { +var668 = varonce667; } else { -var481 = ".is_nullable;"; -var482 = core__flat___NativeString___to_s_full(var481, 13l, 13l); -var480 = var482; -varonce479 = var480; +var669 = ".is_nullable;"; +var671 = (val*)(13l<<2|1); +var672 = (val*)(13l<<2|1); +var673 = (val*)((long)(0)<<2|3); +var674 = (val*)((long)(0)<<2|3); +var670 = core__flat___CString___to_s_unsafe(var669, var671, var672, var673, var674); +var668 = var670; +varonce667 = var668; } -((struct instance_core__NativeArray*)var474)->values[3]=var480; +((struct instance_core__NativeArray*)var658)->values[3]=var668; } else { -var474 = varonce473; -varonce473 = NULL; +var658 = varonce657; +varonce657 = NULL; } -((struct instance_core__NativeArray*)var474)->values[0]=var_is_nullable; -((struct instance_core__NativeArray*)var474)->values[2]=var_entry; +((struct instance_core__NativeArray*)var658)->values[0]=var_is_nullable; +((struct instance_core__NativeArray*)var658)->values[2]=var_entry; { -var483 = ((val*(*)(val* self))(var474->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var474); /* native_to_s on */ +var675 = ((val*(*)(val* self))(var658->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var658); /* native_to_s on */ } -varonce473 = var474; +varonce657 = var658; { -nitc___nitc__AbstractCompilerVisitor___add(self, var483); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var675); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } { -var484 = core___core__String___Object__to_s(var_is_nullable); +var676 = core___core__String___Object__to_s(var_is_nullable); } -var_accept_null = var484; +var_accept_null = var676; } else { } { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var487 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var487 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var679 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var679 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var485 = var487; -RET_LABEL486:(void)0; +var677 = var679; +RET_LABEL678:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var485) on */ -var490 = var485->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var490 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$modelbuilder (var677) on */ +var682 = var677->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var682 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 538); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 552); fatal_exit(1); } -var488 = var490; -RET_LABEL489:(void)0; +var680 = var682; +RET_LABEL681:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var488) on */ -var493 = var488->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var493 == NULL)) { +{ /* Inline modelbuilder_base$ModelBuilder$toolcontext (var680) on */ +var685 = var680->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var685 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47); fatal_exit(1); } -var491 = var493; -RET_LABEL492:(void)0; +var683 = var685; +RET_LABEL684:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var491) on */ -var496 = var491->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var496 == NULL)) { +{ /* Inline abstract_compiler$ToolContext$opt_typing_test_metrics (var683) on */ +var688 = var683->attrs[COLOR_nitc__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var688 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 60); fatal_exit(1); } -var494 = var496; -RET_LABEL495:(void)0; +var686 = var688; +RET_LABEL687:(void)0; } } { -{ /* Inline opts#Option#value (var494) on */ -var499 = var494->attrs[COLOR_opts__Option___value].val; /* _value on */ -var497 = var499; -RET_LABEL498:(void)0; +{ /* Inline opts$Option$value (var686) on */ +var691 = var686->attrs[COLOR_opts__Option___value].val; /* _value on */ +var689 = var691; +RET_LABEL690:(void)0; } } -var500 = (short int)((long)(var497)>>2); -if (var500){ +var692 = (short int)((long)(var689)>>2); +if (var692){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var503 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var503 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var695 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var695 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var501 = var503; -RET_LABEL502:(void)0; +var693 = var695; +RET_LABEL694:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_unresolved (var501) on */ -var506 = var501->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_unresolved].val; /* _count_type_test_unresolved on */ -if (unlikely(var506 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$count_type_test_unresolved (var693) on */ +var698 = var693->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___count_type_test_unresolved].val; /* _count_type_test_unresolved on */ +if (unlikely(var698 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_unresolved"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1047); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1112); fatal_exit(1); } -var504 = var506; -RET_LABEL505:(void)0; +var696 = var698; +RET_LABEL697:(void)0; } } -var_507 = var504; -var_508 = var_tag; +var_699 = var696; +var_700 = var_tag; { -var509 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_507, var_508); +var701 = core___core__HashMap___core__abstract_collection__MapRead___91d_93d(var_699, var_700); } { -{ /* Inline kernel#Int#+ (var509,1l) on */ +{ /* Inline kernel$Int$+ (var701,1l) on */ /* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ /* <1l:Int> isa OTHER */ -var512 = 1; /* easy <1l:Int> isa OTHER*/ -if (unlikely(!var512)) { -var_class_name515 = type_core__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name515); -PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 731); +var704 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var704)) { +var_class_name707 = type_core__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name707); +PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 728); fatal_exit(1); } -var516 = (long)(var509)>>2; -var517 = var516 + 1l; -var510 = var517; -goto RET_LABEL511; -RET_LABEL511:(void)0; +var708 = (long)(var701)>>2; +var709 = var708 + 1l; +var702 = var709; +goto RET_LABEL703; +RET_LABEL703:(void)0; } } { -var518 = (val*)(var510<<2|1); -core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_507, var_508, var518); /* Direct call hash_collection#HashMap#[]= on */ +var710 = (val*)(var702<<2|1); +core___core__HashMap___core__abstract_collection__Map___91d_93d_61d(var_699, var_700, var710); /* Direct call hash_collection$HashMap$[]= on */ } -if (unlikely(varonce519==NULL)) { -var520 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce521!=NULL)) { -var522 = varonce521; +if (unlikely(varonce711==NULL)) { +var712 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce713!=NULL)) { +var714 = varonce713; } else { -var523 = "count_type_test_unresolved_"; -var524 = core__flat___NativeString___to_s_full(var523, 27l, 27l); -var522 = var524; -varonce521 = var522; +var715 = "count_type_test_unresolved_"; +var717 = (val*)(27l<<2|1); +var718 = (val*)(27l<<2|1); +var719 = (val*)((long)(0)<<2|3); +var720 = (val*)((long)(0)<<2|3); +var716 = core__flat___CString___to_s_unsafe(var715, var717, var718, var719, var720); +var714 = var716; +varonce713 = var714; } -((struct instance_core__NativeArray*)var520)->values[0]=var522; -if (likely(varonce525!=NULL)) { -var526 = varonce525; +((struct instance_core__NativeArray*)var712)->values[0]=var714; +if (likely(varonce721!=NULL)) { +var722 = varonce721; } else { -var527 = "++;"; -var528 = core__flat___NativeString___to_s_full(var527, 3l, 3l); -var526 = var528; -varonce525 = var526; +var723 = "++;"; +var725 = (val*)(3l<<2|1); +var726 = (val*)(3l<<2|1); +var727 = (val*)((long)(0)<<2|3); +var728 = (val*)((long)(0)<<2|3); +var724 = core__flat___CString___to_s_unsafe(var723, var725, var726, var727, var728); +var722 = var724; +varonce721 = var722; } -((struct instance_core__NativeArray*)var520)->values[2]=var526; +((struct instance_core__NativeArray*)var712)->values[2]=var722; } else { -var520 = varonce519; -varonce519 = NULL; +var712 = varonce711; +varonce711 = NULL; } -((struct instance_core__NativeArray*)var520)->values[1]=var_tag; +((struct instance_core__NativeArray*)var712)->values[1]=var_tag; { -var529 = ((val*(*)(val* self))(var520->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var520); /* native_to_s on */ +var729 = ((val*(*)(val* self))(var712->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var712); /* native_to_s on */ } -varonce519 = var520; +varonce711 = var712; { -nitc___nitc__AbstractCompilerVisitor___add(self, var529); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var729); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { } } else { -if (unlikely(varonce530==NULL)) { -var531 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); -if (likely(varonce532!=NULL)) { -var533 = varonce532; +if (unlikely(varonce730==NULL)) { +var731 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String); +if (likely(varonce732!=NULL)) { +var733 = varonce732; } else { -var534 = "type_test("; -var535 = core__flat___NativeString___to_s_full(var534, 10l, 10l); -var533 = var535; -varonce532 = var533; +var734 = "type_test("; +var736 = (val*)(10l<<2|1); +var737 = (val*)(10l<<2|1); +var738 = (val*)((long)(0)<<2|3); +var739 = (val*)((long)(0)<<2|3); +var735 = core__flat___CString___to_s_unsafe(var734, var736, var737, var738, var739); +var733 = var735; +varonce732 = var733; } -((struct instance_core__NativeArray*)var531)->values[0]=var533; -if (likely(varonce536!=NULL)) { -var537 = varonce536; +((struct instance_core__NativeArray*)var731)->values[0]=var733; +if (likely(varonce740!=NULL)) { +var741 = varonce740; } else { -var538 = ", "; -var539 = core__flat___NativeString___to_s_full(var538, 2l, 2l); -var537 = var539; -varonce536 = var537; +var742 = ", "; +var744 = (val*)(2l<<2|1); +var745 = (val*)(2l<<2|1); +var746 = (val*)((long)(0)<<2|3); +var747 = (val*)((long)(0)<<2|3); +var743 = core__flat___CString___to_s_unsafe(var742, var744, var745, var746, var747); +var741 = var743; +varonce740 = var741; } -((struct instance_core__NativeArray*)var531)->values[2]=var537; -if (likely(varonce540!=NULL)) { -var541 = varonce540; +((struct instance_core__NativeArray*)var731)->values[2]=var741; +if (likely(varonce748!=NULL)) { +var749 = varonce748; } else { -var542 = ")"; -var543 = core__flat___NativeString___to_s_full(var542, 1l, 1l); -var541 = var543; -varonce540 = var541; +var750 = ")"; +var752 = (val*)(1l<<2|1); +var753 = (val*)(1l<<2|1); +var754 = (val*)((long)(0)<<2|3); +var755 = (val*)((long)(0)<<2|3); +var751 = core__flat___CString___to_s_unsafe(var750, var752, var753, var754, var755); +var749 = var751; +varonce748 = var749; } -((struct instance_core__NativeArray*)var531)->values[4]=var541; +((struct instance_core__NativeArray*)var731)->values[4]=var749; } else { -var531 = varonce530; -varonce530 = NULL; +var731 = varonce730; +varonce730 = NULL; } { -var544 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); +var756 = nitc___nitc__RuntimeVariable___core__abstract_text__Object__inspect(var_value); } -((struct instance_core__NativeArray*)var531)->values[1]=var544; +((struct instance_core__NativeArray*)var731)->values[1]=var756; { -var545 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ +var757 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on */ } -((struct instance_core__NativeArray*)var531)->values[3]=var545; +((struct instance_core__NativeArray*)var731)->values[3]=var757; { -var546 = ((val*(*)(val* self))(var531->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var531); /* native_to_s on */ +var758 = ((val*(*)(val* self))(var731->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var731); /* native_to_s on */ } -varonce530 = var531; +varonce730 = var731; { -nitc___nitc__AbstractCompilerVisitor___debug(self, var546); /* Direct call abstract_compiler#AbstractCompilerVisitor#debug on */ +nitc___nitc__AbstractCompilerVisitor___debug(self, var758); /* Direct call abstract_compiler$AbstractCompilerVisitor$debug on */ +} +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); } PRINT_ERROR("Runtime error: %s", "Aborted"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 582); @@ -2397,247 +4839,311 @@ fatal_exit(1); } } if (var_maybe_null){ -if (unlikely(varonce547==NULL)) { -var548 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce549!=NULL)) { -var550 = varonce549; +if (unlikely(varonce759==NULL)) { +var760 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); +if (likely(varonce761!=NULL)) { +var762 = varonce761; } else { -var551 = "if("; -var552 = core__flat___NativeString___to_s_full(var551, 3l, 3l); -var550 = var552; -varonce549 = var550; +var763 = "if("; +var765 = (val*)(3l<<2|1); +var766 = (val*)(3l<<2|1); +var767 = (val*)((long)(0)<<2|3); +var768 = (val*)((long)(0)<<2|3); +var764 = core__flat___CString___to_s_unsafe(var763, var765, var766, var767, var768); +var762 = var764; +varonce761 = var762; } -((struct instance_core__NativeArray*)var548)->values[0]=var550; -if (likely(varonce553!=NULL)) { -var554 = varonce553; +((struct instance_core__NativeArray*)var760)->values[0]=var762; +if (likely(varonce769!=NULL)) { +var770 = varonce769; } else { -var555 = " == NULL) {"; -var556 = core__flat___NativeString___to_s_full(var555, 11l, 11l); -var554 = var556; -varonce553 = var554; +var771 = " == NULL) {"; +var773 = (val*)(11l<<2|1); +var774 = (val*)(11l<<2|1); +var775 = (val*)((long)(0)<<2|3); +var776 = (val*)((long)(0)<<2|3); +var772 = core__flat___CString___to_s_unsafe(var771, var773, var774, var775, var776); +var770 = var772; +varonce769 = var770; } -((struct instance_core__NativeArray*)var548)->values[2]=var554; +((struct instance_core__NativeArray*)var760)->values[2]=var770; } else { -var548 = varonce547; -varonce547 = NULL; +var760 = varonce759; +varonce759 = NULL; } { -var557 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var777 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var548)->values[1]=var557; +((struct instance_core__NativeArray*)var760)->values[1]=var777; { -var558 = ((val*(*)(val* self))(var548->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var548); /* native_to_s on */ +var778 = ((val*(*)(val* self))(var760->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var760); /* native_to_s on */ } -varonce547 = var548; +varonce759 = var760; { -nitc___nitc__AbstractCompilerVisitor___add(self, var558); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var778); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce559==NULL)) { -var560 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce561!=NULL)) { -var562 = varonce561; +if (unlikely(varonce779==NULL)) { +var780 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce781!=NULL)) { +var782 = varonce781; } else { -var563 = " = "; -var564 = core__flat___NativeString___to_s_full(var563, 3l, 3l); -var562 = var564; -varonce561 = var562; +var783 = " = "; +var785 = (val*)(3l<<2|1); +var786 = (val*)(3l<<2|1); +var787 = (val*)((long)(0)<<2|3); +var788 = (val*)((long)(0)<<2|3); +var784 = core__flat___CString___to_s_unsafe(var783, var785, var786, var787, var788); +var782 = var784; +varonce781 = var782; } -((struct instance_core__NativeArray*)var560)->values[1]=var562; -if (likely(varonce565!=NULL)) { -var566 = varonce565; +((struct instance_core__NativeArray*)var780)->values[1]=var782; +if (likely(varonce789!=NULL)) { +var790 = varonce789; } else { -var567 = ";"; -var568 = core__flat___NativeString___to_s_full(var567, 1l, 1l); -var566 = var568; -varonce565 = var566; +var791 = ";"; +var793 = (val*)(1l<<2|1); +var794 = (val*)(1l<<2|1); +var795 = (val*)((long)(0)<<2|3); +var796 = (val*)((long)(0)<<2|3); +var792 = core__flat___CString___to_s_unsafe(var791, var793, var794, var795, var796); +var790 = var792; +varonce789 = var790; } -((struct instance_core__NativeArray*)var560)->values[3]=var566; +((struct instance_core__NativeArray*)var780)->values[3]=var790; } else { -var560 = varonce559; -varonce559 = NULL; +var780 = varonce779; +varonce779 = NULL; } { -var569 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var797 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var560)->values[0]=var569; -((struct instance_core__NativeArray*)var560)->values[2]=var_accept_null; +((struct instance_core__NativeArray*)var780)->values[0]=var797; +((struct instance_core__NativeArray*)var780)->values[2]=var_accept_null; { -var570 = ((val*(*)(val* self))(var560->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var560); /* native_to_s on */ +var798 = ((val*(*)(val* self))(var780->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var780); /* native_to_s on */ } -varonce559 = var560; +varonce779 = var780; { -nitc___nitc__AbstractCompilerVisitor___add(self, var570); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var798); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (likely(varonce571!=NULL)) { -var572 = varonce571; +if (likely(varonce799!=NULL)) { +var800 = varonce799; } else { -var573 = "} else {"; -var574 = core__flat___NativeString___to_s_full(var573, 8l, 8l); -var572 = var574; -varonce571 = var572; +var801 = "} else {"; +var803 = (val*)(8l<<2|1); +var804 = (val*)(8l<<2|1); +var805 = (val*)((long)(0)<<2|3); +var806 = (val*)((long)(0)<<2|3); +var802 = core__flat___CString___to_s_unsafe(var801, var803, var804, var805, var806); +var800 = var802; +varonce799 = var800; } { -nitc___nitc__AbstractCompilerVisitor___add(self, var572); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var800); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { } -if (unlikely(varonce575==NULL)) { -var576 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); -if (likely(varonce577!=NULL)) { -var578 = varonce577; +if (unlikely(varonce807==NULL)) { +var808 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String); +if (likely(varonce809!=NULL)) { +var810 = varonce809; } else { -var579 = "if("; -var580 = core__flat___NativeString___to_s_full(var579, 3l, 3l); -var578 = var580; -varonce577 = var578; +var811 = "if("; +var813 = (val*)(3l<<2|1); +var814 = (val*)(3l<<2|1); +var815 = (val*)((long)(0)<<2|3); +var816 = (val*)((long)(0)<<2|3); +var812 = core__flat___CString___to_s_unsafe(var811, var813, var814, var815, var816); +var810 = var812; +varonce809 = var810; } -((struct instance_core__NativeArray*)var576)->values[0]=var578; -if (likely(varonce581!=NULL)) { -var582 = varonce581; +((struct instance_core__NativeArray*)var808)->values[0]=var810; +if (likely(varonce817!=NULL)) { +var818 = varonce817; } else { -var583 = " >= "; -var584 = core__flat___NativeString___to_s_full(var583, 4l, 4l); -var582 = var584; -varonce581 = var582; +var819 = " >= "; +var821 = (val*)(4l<<2|1); +var822 = (val*)(4l<<2|1); +var823 = (val*)((long)(0)<<2|3); +var824 = (val*)((long)(0)<<2|3); +var820 = core__flat___CString___to_s_unsafe(var819, var821, var822, var823, var824); +var818 = var820; +varonce817 = var818; } -((struct instance_core__NativeArray*)var576)->values[2]=var582; -if (likely(varonce585!=NULL)) { -var586 = varonce585; +((struct instance_core__NativeArray*)var808)->values[2]=var818; +if (likely(varonce825!=NULL)) { +var826 = varonce825; } else { -var587 = "type_table->size) {"; -var588 = core__flat___NativeString___to_s_full(var587, 19l, 19l); -var586 = var588; -varonce585 = var586; +var827 = "type_table->size) {"; +var829 = (val*)(19l<<2|1); +var830 = (val*)(19l<<2|1); +var831 = (val*)((long)(0)<<2|3); +var832 = (val*)((long)(0)<<2|3); +var828 = core__flat___CString___to_s_unsafe(var827, var829, var830, var831, var832); +var826 = var828; +varonce825 = var826; } -((struct instance_core__NativeArray*)var576)->values[4]=var586; +((struct instance_core__NativeArray*)var808)->values[4]=var826; } else { -var576 = varonce575; -varonce575 = NULL; +var808 = varonce807; +varonce807 = NULL; } -((struct instance_core__NativeArray*)var576)->values[1]=var_cltype; -((struct instance_core__NativeArray*)var576)->values[3]=var_class_ptr; +((struct instance_core__NativeArray*)var808)->values[1]=var_cltype; +((struct instance_core__NativeArray*)var808)->values[3]=var_class_ptr; { -var589 = ((val*(*)(val* self))(var576->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var576); /* native_to_s on */ +var833 = ((val*(*)(val* self))(var808->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var808); /* native_to_s on */ } -varonce575 = var576; +varonce807 = var808; { -nitc___nitc__AbstractCompilerVisitor___add(self, var589); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var833); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce590==NULL)) { -var591 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce592!=NULL)) { -var593 = varonce592; +if (unlikely(varonce834==NULL)) { +var835 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce836!=NULL)) { +var837 = varonce836; } else { -var594 = " = 0;"; -var595 = core__flat___NativeString___to_s_full(var594, 5l, 5l); -var593 = var595; -varonce592 = var593; +var838 = " = 0;"; +var840 = (val*)(5l<<2|1); +var841 = (val*)(5l<<2|1); +var842 = (val*)((long)(0)<<2|3); +var843 = (val*)((long)(0)<<2|3); +var839 = core__flat___CString___to_s_unsafe(var838, var840, var841, var842, var843); +var837 = var839; +varonce836 = var837; } -((struct instance_core__NativeArray*)var591)->values[1]=var593; +((struct instance_core__NativeArray*)var835)->values[1]=var837; } else { -var591 = varonce590; -varonce590 = NULL; +var835 = varonce834; +varonce834 = NULL; } { -var596 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var844 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var591)->values[0]=var596; +((struct instance_core__NativeArray*)var835)->values[0]=var844; { -var597 = ((val*(*)(val* self))(var591->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var591); /* native_to_s on */ +var845 = ((val*(*)(val* self))(var835->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var835); /* native_to_s on */ } -varonce590 = var591; +varonce834 = var835; { -nitc___nitc__AbstractCompilerVisitor___add(self, var597); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var845); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (likely(varonce598!=NULL)) { -var599 = varonce598; +if (likely(varonce846!=NULL)) { +var847 = varonce846; } else { -var600 = "} else {"; -var601 = core__flat___NativeString___to_s_full(var600, 8l, 8l); -var599 = var601; -varonce598 = var599; +var848 = "} else {"; +var850 = (val*)(8l<<2|1); +var851 = (val*)(8l<<2|1); +var852 = (val*)((long)(0)<<2|3); +var853 = (val*)((long)(0)<<2|3); +var849 = core__flat___CString___to_s_unsafe(var848, var850, var851, var852, var853); +var847 = var849; +varonce846 = var847; } { -nitc___nitc__AbstractCompilerVisitor___add(self, var599); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var847); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce602==NULL)) { -var603 = NEW_core__NativeArray(8l, &type_core__NativeArray__core__String); -if (likely(varonce604!=NULL)) { -var605 = varonce604; +if (unlikely(varonce854==NULL)) { +var855 = NEW_core__NativeArray((int)8l, &type_core__NativeArray__core__String); +if (likely(varonce856!=NULL)) { +var857 = varonce856; } else { -var606 = " = "; -var607 = core__flat___NativeString___to_s_full(var606, 3l, 3l); -var605 = var607; -varonce604 = var605; +var858 = " = "; +var860 = (val*)(3l<<2|1); +var861 = (val*)(3l<<2|1); +var862 = (val*)((long)(0)<<2|3); +var863 = (val*)((long)(0)<<2|3); +var859 = core__flat___CString___to_s_unsafe(var858, var860, var861, var862, var863); +var857 = var859; +varonce856 = var857; } -((struct instance_core__NativeArray*)var603)->values[1]=var605; -if (likely(varonce608!=NULL)) { -var609 = varonce608; +((struct instance_core__NativeArray*)var855)->values[1]=var857; +if (likely(varonce864!=NULL)) { +var865 = varonce864; } else { -var610 = "type_table->table["; -var611 = core__flat___NativeString___to_s_full(var610, 18l, 18l); -var609 = var611; -varonce608 = var609; +var866 = "type_table->table["; +var868 = (val*)(18l<<2|1); +var869 = (val*)(18l<<2|1); +var870 = (val*)((long)(0)<<2|3); +var871 = (val*)((long)(0)<<2|3); +var867 = core__flat___CString___to_s_unsafe(var866, var868, var869, var870, var871); +var865 = var867; +varonce864 = var865; } -((struct instance_core__NativeArray*)var603)->values[3]=var609; -if (likely(varonce612!=NULL)) { -var613 = varonce612; +((struct instance_core__NativeArray*)var855)->values[3]=var865; +if (likely(varonce872!=NULL)) { +var873 = varonce872; } else { -var614 = "] == "; -var615 = core__flat___NativeString___to_s_full(var614, 5l, 5l); -var613 = var615; -varonce612 = var613; +var874 = "] == "; +var876 = (val*)(5l<<2|1); +var877 = (val*)(5l<<2|1); +var878 = (val*)((long)(0)<<2|3); +var879 = (val*)((long)(0)<<2|3); +var875 = core__flat___CString___to_s_unsafe(var874, var876, var877, var878, var879); +var873 = var875; +varonce872 = var873; } -((struct instance_core__NativeArray*)var603)->values[5]=var613; -if (likely(varonce616!=NULL)) { -var617 = varonce616; +((struct instance_core__NativeArray*)var855)->values[5]=var873; +if (likely(varonce880!=NULL)) { +var881 = varonce880; } else { -var618 = ";"; -var619 = core__flat___NativeString___to_s_full(var618, 1l, 1l); -var617 = var619; -varonce616 = var617; +var882 = ";"; +var884 = (val*)(1l<<2|1); +var885 = (val*)(1l<<2|1); +var886 = (val*)((long)(0)<<2|3); +var887 = (val*)((long)(0)<<2|3); +var883 = core__flat___CString___to_s_unsafe(var882, var884, var885, var886, var887); +var881 = var883; +varonce880 = var881; } -((struct instance_core__NativeArray*)var603)->values[7]=var617; +((struct instance_core__NativeArray*)var855)->values[7]=var881; } else { -var603 = varonce602; -varonce602 = NULL; +var855 = varonce854; +varonce854 = NULL; } { -var620 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var888 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var603)->values[0]=var620; -((struct instance_core__NativeArray*)var603)->values[2]=var_class_ptr; -((struct instance_core__NativeArray*)var603)->values[4]=var_cltype; -((struct instance_core__NativeArray*)var603)->values[6]=var_idtype; +((struct instance_core__NativeArray*)var855)->values[0]=var888; +((struct instance_core__NativeArray*)var855)->values[2]=var_class_ptr; +((struct instance_core__NativeArray*)var855)->values[4]=var_cltype; +((struct instance_core__NativeArray*)var855)->values[6]=var_idtype; { -var621 = ((val*(*)(val* self))(var603->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var603); /* native_to_s on */ +var889 = ((val*(*)(val* self))(var855->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var855); /* native_to_s on */ } -varonce602 = var603; +varonce854 = var855; { -nitc___nitc__AbstractCompilerVisitor___add(self, var621); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var889); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (likely(varonce622!=NULL)) { -var623 = varonce622; +if (likely(varonce890!=NULL)) { +var891 = varonce890; } else { -var624 = "}"; -var625 = core__flat___NativeString___to_s_full(var624, 1l, 1l); -var623 = var625; -varonce622 = var623; -} +var892 = "}"; +var894 = (val*)(1l<<2|1); +var895 = (val*)(1l<<2|1); +var896 = (val*)((long)(0)<<2|3); +var897 = (val*)((long)(0)<<2|3); +var893 = core__flat___CString___to_s_unsafe(var892, var894, var895, var896, var897); +var891 = var893; +varonce890 = var891; +} { -nitc___nitc__AbstractCompilerVisitor___add(self, var623); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var891); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } if (var_maybe_null){ -if (likely(varonce626!=NULL)) { -var627 = varonce626; +if (likely(varonce898!=NULL)) { +var899 = varonce898; } else { -var628 = "}"; -var629 = core__flat___NativeString___to_s_full(var628, 1l, 1l); -var627 = var629; -varonce626 = var627; +var900 = "}"; +var902 = (val*)(1l<<2|1); +var903 = (val*)(1l<<2|1); +var904 = (val*)((long)(0)<<2|3); +var905 = (val*)((long)(0)<<2|3); +var901 = core__flat___CString___to_s_unsafe(var900, var902, var903, var904, var905); +var899 = var901; +varonce898 = var899; } { -nitc___nitc__AbstractCompilerVisitor___add(self, var627); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var899); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { } @@ -2646,7 +5152,7 @@ goto RET_LABEL; RET_LABEL:; return var; } -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#unbox_extern for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$unbox_extern for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__unbox_extern(val* self, val* p0, val* p1) { val* var /* : RuntimeVariable */; val* var_value /* var value: RuntimeVariable */; @@ -2674,45 +5180,65 @@ val* var21 /* : String */; val* var23 /* : String */; static val* varonce; val* var24 /* : String */; -char* var25 /* : NativeString */; +char* var25 /* : CString */; val* var26 /* : String */; -short int var27 /* : Bool */; -val* var_other29 /* var other: nullable Object */; -short int var30 /* : Bool */; +val* var27 /* : nullable Int */; +val* var28 /* : nullable Int */; +val* var29 /* : nullable Bool */; +val* var30 /* : nullable Bool */; short int var31 /* : Bool */; -val* var32 /* : AbstractCompiler */; -val* var34 /* : AbstractCompiler */; -val* var35 /* : MModule */; -val* var37 /* : MModule */; -val* var38 /* : MClassType */; +val* var_other33 /* var other: nullable Object */; +short int var34 /* : Bool */; +short int var35 /* : Bool */; +val* var36 /* : AbstractCompiler */; +val* var38 /* : AbstractCompiler */; +val* var39 /* : MModule */; +val* var41 /* : MModule */; +val* var42 /* : MClassType */; val* var_pointer_type /* var pointer_type: MClassType */; -val* var39 /* : RuntimeVariable */; +val* var43 /* : RuntimeVariable */; val* var_res /* var res: RuntimeVariable */; -val* var41 /* : NativeArray[String] */; -static val* varonce40; -static val* varonce42; -val* var43 /* : String */; -char* var44 /* : NativeString */; -val* var45 /* : String */; +val* var45 /* : NativeArray[String] */; +static val* varonce44; static val* varonce46; val* var47 /* : String */; -char* var48 /* : NativeString */; +char* var48 /* : CString */; val* var49 /* : String */; -static val* varonce50; -val* var51 /* : String */; -char* var52 /* : NativeString */; -val* var53 /* : String */; +val* var50 /* : nullable Int */; +val* var51 /* : nullable Int */; +val* var52 /* : nullable Bool */; +val* var53 /* : nullable Bool */; static val* varonce54; val* var55 /* : String */; -char* var56 /* : NativeString */; +char* var56 /* : CString */; val* var57 /* : String */; -val* var58 /* : String */; -val* var59 /* : String */; -val* var60 /* : String */; -val* var61 /* : MType */; -val* var63 /* : MType */; -val* var64 /* : String */; +val* var58 /* : nullable Int */; +val* var59 /* : nullable Int */; +val* var60 /* : nullable Bool */; +val* var61 /* : nullable Bool */; +static val* varonce62; +val* var63 /* : String */; +char* var64 /* : CString */; val* var65 /* : String */; +val* var66 /* : nullable Int */; +val* var67 /* : nullable Int */; +val* var68 /* : nullable Bool */; +val* var69 /* : nullable Bool */; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : CString */; +val* var73 /* : String */; +val* var74 /* : nullable Int */; +val* var75 /* : nullable Int */; +val* var76 /* : nullable Bool */; +val* var77 /* : nullable Bool */; +val* var78 /* : String */; +val* var79 /* : String */; +val* var80 /* : String */; +val* var81 /* : MType */; +val* var83 /* : MType */; +val* var84 /* : String */; +val* var85 /* : String */; var_value = p0; var_mtype = p1; /* isa MClassType */ @@ -2726,11 +5252,14 @@ var3 = var_mtype->type->type_table[cltype] == idtype; var_ = var3; if (var3){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ +{ /* Inline model$MClassType$mclass (var_mtype) on */ var6 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var6 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } var4 = var6; @@ -2738,11 +5267,14 @@ RET_LABEL5:(void)0; } } { -{ /* Inline model#MClass#kind (var4) on */ +{ /* Inline model$MClass$kind (var4) on */ var9 = var4->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on */ if (unlikely(var9 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 459); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 472); fatal_exit(1); } var7 = var9; @@ -2754,10 +5286,10 @@ var10 = glob_sys; var11 = nitc__model___core__Sys___extern_kind(var10); } { -{ /* Inline kernel#Object#== (var7,var11) on */ +{ /* Inline kernel$Object$== (var7,var11) on */ var_other = var11; { -{ /* Inline kernel#Object#is_same_instance (var7,var_other) on */ +{ /* Inline kernel$Object$is_same_instance (var7,var_other) on */ var16 = var7 == var_other; var14 = var16; goto RET_LABEL15; @@ -2776,11 +5308,14 @@ var2 = var_; var_17 = var2; if (var2){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ +{ /* Inline model$MClassType$mclass (var_mtype) on */ var20 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var20 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } var18 = var20; @@ -2788,11 +5323,14 @@ RET_LABEL19:(void)0; } } { -{ /* Inline model#MClass#name (var18) on */ +{ /* Inline model$MClass$name (var18) on */ var23 = var18->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ if (unlikely(var23 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 396); fatal_exit(1); } var21 = var23; @@ -2802,136 +5340,165 @@ RET_LABEL22:(void)0; if (likely(varonce!=NULL)) { var24 = varonce; } else { -var25 = "NativeString"; -var26 = core__flat___NativeString___to_s_full(var25, 12l, 12l); +var25 = "CString"; +var27 = (val*)(7l<<2|1); +var28 = (val*)(7l<<2|1); +var29 = (val*)((long)(0)<<2|3); +var30 = (val*)((long)(0)<<2|3); +var26 = core__flat___CString___to_s_unsafe(var25, var27, var28, var29, var30); var24 = var26; varonce = var24; } { -{ /* Inline kernel#Object#!= (var21,var24) on */ -var_other29 = var24; +{ /* Inline kernel$Object$!= (var21,var24) on */ +var_other33 = var24; { -var30 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_core__kernel__Object___61d_61d]))(var21, var_other29); /* == on */ +var34 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_core__kernel__Object___61d_61d]))(var21, var_other33); /* == on */ } -var31 = !var30; -var27 = var31; -goto RET_LABEL28; -RET_LABEL28:(void)0; +var35 = !var34; +var31 = var35; +goto RET_LABEL32; +RET_LABEL32:(void)0; } } -var1 = var27; +var1 = var31; } else { var1 = var_17; } if (var1){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var34 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var34 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var38 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var38 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var32 = var34; -RET_LABEL33:(void)0; +var36 = var38; +RET_LABEL37:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (var32) on */ -var37 = var32->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var37 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$mainmodule (var36) on */ +var41 = var36->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var41 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 531); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 545); fatal_exit(1); } -var35 = var37; -RET_LABEL36:(void)0; +var39 = var41; +RET_LABEL40:(void)0; } } { -var38 = nitc__model___MModule___pointer_type(var35); +var42 = nitc__model___MModule___pointer_type(var39); } -var_pointer_type = var38; +var_pointer_type = var42; { -var39 = nitc___nitc__AbstractCompilerVisitor___new_var_extern(self, var_mtype); -} -var_res = var39; -if (unlikely(varonce40==NULL)) { -var41 = NEW_core__NativeArray(8l, &type_core__NativeArray__core__String); -if (likely(varonce42!=NULL)) { -var43 = varonce42; -} else { -var44 = " = ((struct instance_"; -var45 = core__flat___NativeString___to_s_full(var44, 21l, 21l); -var43 = var45; -varonce42 = var43; +var43 = nitc___nitc__AbstractCompilerVisitor___new_var_extern(self, var_mtype); } -((struct instance_core__NativeArray*)var41)->values[1]=var43; +var_res = var43; +if (unlikely(varonce44==NULL)) { +var45 = NEW_core__NativeArray((int)8l, &type_core__NativeArray__core__String); if (likely(varonce46!=NULL)) { var47 = varonce46; } else { -var48 = "*)"; -var49 = core__flat___NativeString___to_s_full(var48, 2l, 2l); +var48 = " = ((struct instance_"; +var50 = (val*)(21l<<2|1); +var51 = (val*)(21l<<2|1); +var52 = (val*)((long)(0)<<2|3); +var53 = (val*)((long)(0)<<2|3); +var49 = core__flat___CString___to_s_unsafe(var48, var50, var51, var52, var53); var47 = var49; varonce46 = var47; } -((struct instance_core__NativeArray*)var41)->values[3]=var47; -if (likely(varonce50!=NULL)) { -var51 = varonce50; -} else { -var52 = ")->value; /* unboxing "; -var53 = core__flat___NativeString___to_s_full(var52, 22l, 22l); -var51 = var53; -varonce50 = var51; -} -((struct instance_core__NativeArray*)var41)->values[5]=var51; +((struct instance_core__NativeArray*)var45)->values[1]=var47; if (likely(varonce54!=NULL)) { var55 = varonce54; } else { -var56 = " */"; -var57 = core__flat___NativeString___to_s_full(var56, 3l, 3l); +var56 = "*)"; +var58 = (val*)(2l<<2|1); +var59 = (val*)(2l<<2|1); +var60 = (val*)((long)(0)<<2|3); +var61 = (val*)((long)(0)<<2|3); +var57 = core__flat___CString___to_s_unsafe(var56, var58, var59, var60, var61); var55 = var57; varonce54 = var55; } -((struct instance_core__NativeArray*)var41)->values[7]=var55; +((struct instance_core__NativeArray*)var45)->values[3]=var55; +if (likely(varonce62!=NULL)) { +var63 = varonce62; +} else { +var64 = ")->value; /* unboxing "; +var66 = (val*)(22l<<2|1); +var67 = (val*)(22l<<2|1); +var68 = (val*)((long)(0)<<2|3); +var69 = (val*)((long)(0)<<2|3); +var65 = core__flat___CString___to_s_unsafe(var64, var66, var67, var68, var69); +var63 = var65; +varonce62 = var63; +} +((struct instance_core__NativeArray*)var45)->values[5]=var63; +if (likely(varonce70!=NULL)) { +var71 = varonce70; } else { -var41 = varonce40; -varonce40 = NULL; +var72 = " */"; +var74 = (val*)(3l<<2|1); +var75 = (val*)(3l<<2|1); +var76 = (val*)((long)(0)<<2|3); +var77 = (val*)((long)(0)<<2|3); +var73 = core__flat___CString___to_s_unsafe(var72, var74, var75, var76, var77); +var71 = var73; +varonce70 = var71; +} +((struct instance_core__NativeArray*)var45)->values[7]=var71; +} else { +var45 = varonce44; +varonce44 = NULL; } { -var58 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var78 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var41)->values[0]=var58; +((struct instance_core__NativeArray*)var45)->values[0]=var78; { -var59 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ +var79 = ((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*)var41)->values[2]=var59; +((struct instance_core__NativeArray*)var45)->values[2]=var79; { -var60 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var80 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var41)->values[4]=var60; +((struct instance_core__NativeArray*)var45)->values[4]=var80; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var63 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var63 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var83 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var83 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var61 = var63; -RET_LABEL62:(void)0; +var81 = var83; +RET_LABEL82:(void)0; } } { -var64 = ((val*(*)(val* self))(var61->class->vft[COLOR_core__abstract_text__Object__to_s]))(var61); /* to_s on */ +var84 = ((val*(*)(val* self))(var81->class->vft[COLOR_core__abstract_text__Object__to_s]))(var81); /* to_s on */ } -((struct instance_core__NativeArray*)var41)->values[6]=var64; +((struct instance_core__NativeArray*)var45)->values[6]=var84; { -var65 = ((val*(*)(val* self))(var41->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var41); /* native_to_s on */ +var85 = ((val*(*)(val* self))(var45->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var45); /* native_to_s on */ } -varonce40 = var41; +varonce44 = var45; { -nitc___nitc__AbstractCompilerVisitor___add(self, var65); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var85); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } var = var_res; goto RET_LABEL; @@ -2942,7 +5509,7 @@ goto RET_LABEL; RET_LABEL:; return var; } -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#box_extern for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$box_extern for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__box_extern(val* self, val* p0, val* p1) { val* var /* : RuntimeVariable */; val* var_value /* var value: RuntimeVariable */; @@ -2970,123 +5537,175 @@ val* var21 /* : String */; val* var23 /* : String */; static val* varonce; val* var24 /* : String */; -char* var25 /* : NativeString */; +char* var25 /* : CString */; val* var26 /* : String */; -short int var27 /* : Bool */; -val* var_other29 /* var other: nullable Object */; -short int var30 /* : Bool */; +val* var27 /* : nullable Int */; +val* var28 /* : nullable Int */; +val* var29 /* : nullable Bool */; +val* var30 /* : nullable Bool */; short int var31 /* : Bool */; -val* var32 /* : AbstractCompiler */; -val* var34 /* : AbstractCompiler */; -val* var35 /* : MModule */; -val* var37 /* : MModule */; -val* var38 /* : MClassType */; +val* var_other33 /* var other: nullable Object */; +short int var34 /* : Bool */; +short int var35 /* : Bool */; +val* var36 /* : AbstractCompiler */; +val* var38 /* : AbstractCompiler */; +val* var39 /* : MModule */; +val* var41 /* : MModule */; +val* var42 /* : MClassType */; val* var_valtype /* var valtype: MClassType */; -val* var39 /* : RuntimeVariable */; +val* var43 /* : RuntimeVariable */; val* var_res /* var res: RuntimeVariable */; -short int var40 /* : Bool */; -val* var41 /* : AbstractCompiler */; -val* var43 /* : AbstractCompiler */; -val* var44 /* : nullable RapidTypeAnalysis */; -val* var46 /* : nullable RapidTypeAnalysis */; -short int var47 /* : Bool */; -short int var48 /* : Bool */; -short int var50 /* : Bool */; +short int var44 /* : Bool */; +val* var45 /* : AbstractCompiler */; +val* var47 /* : AbstractCompiler */; +val* var48 /* : nullable RapidTypeAnalysis */; +val* var50 /* : nullable RapidTypeAnalysis */; short int var51 /* : Bool */; -short int var_52 /* var : Bool */; -val* var53 /* : AbstractCompiler */; -val* var55 /* : AbstractCompiler */; -val* var56 /* : nullable RapidTypeAnalysis */; -val* var58 /* : nullable RapidTypeAnalysis */; -val* var59 /* : HashSet[MClassType] */; -val* var61 /* : HashSet[MClassType] */; -val* var62 /* : MType */; -val* var64 /* : MType */; -short int var65 /* : Bool */; -int cltype66; -int idtype67; -const char* var_class_name; -short int var68 /* : Bool */; +short int var52 /* : Bool */; +short int var54 /* : Bool */; +short int var55 /* : Bool */; +short int var_56 /* var : Bool */; +val* var57 /* : AbstractCompiler */; +val* var59 /* : AbstractCompiler */; +val* var60 /* : nullable RapidTypeAnalysis */; +val* var62 /* : nullable RapidTypeAnalysis */; +val* var63 /* : HashSet[MClassType] */; +val* var65 /* : HashSet[MClassType] */; +val* var66 /* : MType */; +val* var68 /* : MType */; short int var69 /* : Bool */; -val* var71 /* : NativeArray[String] */; -static val* varonce70; -static val* varonce72; -val* var73 /* : String */; -char* var74 /* : NativeString */; -val* var75 /* : String */; +int cltype70; +int idtype71; +const char* var_class_name; +short int var72 /* : Bool */; +short int var73 /* : Bool */; +val* var75 /* : NativeArray[String] */; +static val* varonce74; static val* varonce76; val* var77 /* : String */; -char* var78 /* : NativeString */; +char* var78 /* : CString */; val* var79 /* : String */; -static val* varonce80; -val* var81 /* : String */; -char* var82 /* : NativeString */; -val* var83 /* : String */; -val* var84 /* : MType */; -val* var86 /* : MType */; +val* var80 /* : nullable Int */; +val* var81 /* : nullable Int */; +val* var82 /* : nullable Bool */; +val* var83 /* : nullable Bool */; +static val* varonce84; +val* var85 /* : String */; +char* var86 /* : CString */; val* var87 /* : String */; -val* var88 /* : MType */; -val* var90 /* : MType */; -val* var91 /* : String */; -val* var92 /* : String */; -static val* varonce93; -val* var94 /* : String */; -char* var95 /* : NativeString */; -val* var96 /* : String */; -val* var98 /* : NativeArray[String] */; -static val* varonce97; -static val* varonce99; -val* var100 /* : String */; -char* var101 /* : NativeString */; -val* var102 /* : String */; +val* var88 /* : nullable Int */; +val* var89 /* : nullable Int */; +val* var90 /* : nullable Bool */; +val* var91 /* : nullable Bool */; +static val* varonce92; +val* var93 /* : String */; +char* var94 /* : CString */; +val* var95 /* : String */; +val* var96 /* : nullable Int */; +val* var97 /* : nullable Int */; +val* var98 /* : nullable Bool */; +val* var99 /* : nullable Bool */; +val* var100 /* : MType */; +val* var102 /* : MType */; val* var103 /* : String */; -val* var104 /* : String */; -val* var106 /* : NativeArray[String] */; -static val* varonce105; -static val* varonce107; +val* var104 /* : MType */; +val* var106 /* : MType */; +val* var107 /* : String */; val* var108 /* : String */; -char* var109 /* : NativeString */; +static val* varonce109; val* var110 /* : String */; -static val* varonce111; +char* var111 /* : CString */; val* var112 /* : String */; -char* var113 /* : NativeString */; -val* var114 /* : String */; -static val* varonce115; -val* var116 /* : String */; -char* var117 /* : NativeString */; -val* var118 /* : String */; +val* var113 /* : nullable Int */; +val* var114 /* : nullable Int */; +val* var115 /* : nullable Bool */; +val* var116 /* : nullable Bool */; +val* var118 /* : NativeArray[String] */; +static val* varonce117; static val* varonce119; val* var120 /* : String */; -char* var121 /* : NativeString */; +char* var121 /* : CString */; val* var122 /* : String */; -val* var123 /* : String */; -val* var124 /* : String */; -val* var125 /* : String */; -val* var126 /* : MType */; -val* var128 /* : MType */; -val* var129 /* : String */; -val* var130 /* : String */; -val* var132 /* : NativeArray[String] */; +val* var123 /* : nullable Int */; +val* var124 /* : nullable Int */; +val* var125 /* : nullable Bool */; +val* var126 /* : nullable Bool */; +val* var127 /* : String */; +val* var128 /* : String */; +val* var130 /* : NativeArray[String] */; +static val* varonce129; static val* varonce131; -static val* varonce133; +val* var132 /* : String */; +char* var133 /* : CString */; val* var134 /* : String */; -char* var135 /* : NativeString */; -val* var136 /* : String */; -val* var137 /* : String */; -val* var138 /* : String */; -val* var140 /* : NativeArray[String] */; +val* var135 /* : nullable Int */; +val* var136 /* : nullable Int */; +val* var137 /* : nullable Bool */; +val* var138 /* : nullable Bool */; static val* varonce139; -static val* varonce141; +val* var140 /* : String */; +char* var141 /* : CString */; val* var142 /* : String */; -char* var143 /* : NativeString */; -val* var144 /* : String */; -static val* varonce145; -val* var146 /* : String */; -char* var147 /* : NativeString */; +val* var143 /* : nullable Int */; +val* var144 /* : nullable Int */; +val* var145 /* : nullable Bool */; +val* var146 /* : nullable Bool */; +static val* varonce147; val* var148 /* : String */; -val* var149 /* : String */; +char* var149 /* : CString */; val* var150 /* : String */; -val* var151 /* : String */; +val* var151 /* : nullable Int */; +val* var152 /* : nullable Int */; +val* var153 /* : nullable Bool */; +val* var154 /* : nullable Bool */; +static val* varonce155; +val* var156 /* : String */; +char* var157 /* : CString */; +val* var158 /* : String */; +val* var159 /* : nullable Int */; +val* var160 /* : nullable Int */; +val* var161 /* : nullable Bool */; +val* var162 /* : nullable Bool */; +val* var163 /* : String */; +val* var164 /* : String */; +val* var165 /* : String */; +val* var166 /* : MType */; +val* var168 /* : MType */; +val* var169 /* : String */; +val* var170 /* : String */; +val* var172 /* : NativeArray[String] */; +static val* varonce171; +static val* varonce173; +val* var174 /* : String */; +char* var175 /* : CString */; +val* var176 /* : String */; +val* var177 /* : nullable Int */; +val* var178 /* : nullable Int */; +val* var179 /* : nullable Bool */; +val* var180 /* : nullable Bool */; +val* var181 /* : String */; +val* var182 /* : String */; +val* var184 /* : NativeArray[String] */; +static val* varonce183; +static val* varonce185; +val* var186 /* : String */; +char* var187 /* : CString */; +val* var188 /* : String */; +val* var189 /* : nullable Int */; +val* var190 /* : nullable Int */; +val* var191 /* : nullable Bool */; +val* var192 /* : nullable Bool */; +static val* varonce193; +val* var194 /* : String */; +char* var195 /* : CString */; +val* var196 /* : String */; +val* var197 /* : nullable Int */; +val* var198 /* : nullable Int */; +val* var199 /* : nullable Bool */; +val* var200 /* : nullable Bool */; +val* var201 /* : String */; +val* var202 /* : String */; +val* var203 /* : String */; var_value = p0; var_mtype = p1; /* isa MClassType */ @@ -3100,11 +5719,14 @@ var3 = var_mtype->type->type_table[cltype] == idtype; var_ = var3; if (var3){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ +{ /* Inline model$MClassType$mclass (var_mtype) on */ var6 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var6 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } var4 = var6; @@ -3112,11 +5734,14 @@ RET_LABEL5:(void)0; } } { -{ /* Inline model#MClass#kind (var4) on */ +{ /* Inline model$MClass$kind (var4) on */ var9 = var4->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on */ if (unlikely(var9 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 459); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 472); fatal_exit(1); } var7 = var9; @@ -3128,10 +5753,10 @@ var10 = glob_sys; var11 = nitc__model___core__Sys___extern_kind(var10); } { -{ /* Inline kernel#Object#== (var7,var11) on */ +{ /* Inline kernel$Object$== (var7,var11) on */ var_other = var11; { -{ /* Inline kernel#Object#is_same_instance (var7,var_other) on */ +{ /* Inline kernel$Object$is_same_instance (var7,var_other) on */ var16 = var7 == var_other; var14 = var16; goto RET_LABEL15; @@ -3150,11 +5775,14 @@ var2 = var_; var_17 = var2; if (var2){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ +{ /* Inline model$MClassType$mclass (var_mtype) on */ var20 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var20 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197); fatal_exit(1); } var18 = var20; @@ -3162,11 +5790,14 @@ RET_LABEL19:(void)0; } } { -{ /* Inline model#MClass#name (var18) on */ +{ /* Inline model$MClass$name (var18) on */ var23 = var18->attrs[COLOR_nitc__model__MClass___name].val; /* _name on */ if (unlikely(var23 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 385); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 396); fatal_exit(1); } var21 = var23; @@ -3176,428 +5807,513 @@ RET_LABEL22:(void)0; if (likely(varonce!=NULL)) { var24 = varonce; } else { -var25 = "NativeString"; -var26 = core__flat___NativeString___to_s_full(var25, 12l, 12l); +var25 = "CString"; +var27 = (val*)(7l<<2|1); +var28 = (val*)(7l<<2|1); +var29 = (val*)((long)(0)<<2|3); +var30 = (val*)((long)(0)<<2|3); +var26 = core__flat___CString___to_s_unsafe(var25, var27, var28, var29, var30); var24 = var26; varonce = var24; } { -{ /* Inline kernel#Object#!= (var21,var24) on */ -var_other29 = var24; +{ /* Inline kernel$Object$!= (var21,var24) on */ +var_other33 = var24; { -var30 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_core__kernel__Object___61d_61d]))(var21, var_other29); /* == on */ +var34 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_core__kernel__Object___61d_61d]))(var21, var_other33); /* == on */ } -var31 = !var30; -var27 = var31; -goto RET_LABEL28; -RET_LABEL28:(void)0; +var35 = !var34; +var31 = var35; +goto RET_LABEL32; +RET_LABEL32:(void)0; } } -var1 = var27; +var1 = var31; } else { var1 = var_17; } if (var1){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var34 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var34 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var38 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var38 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var32 = var34; -RET_LABEL33:(void)0; +var36 = var38; +RET_LABEL37:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (var32) on */ -var37 = var32->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var37 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompiler$mainmodule (var36) on */ +var41 = var36->attrs[COLOR_nitc__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var41 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 531); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 545); fatal_exit(1); } -var35 = var37; -RET_LABEL36:(void)0; +var39 = var41; +RET_LABEL40:(void)0; } } { -var38 = nitc__model___MModule___pointer_type(var35); +var42 = nitc__model___MModule___pointer_type(var39); } -var_valtype = var38; +var_valtype = var42; { -var39 = nitc___nitc__AbstractCompilerVisitor___new_var(self, var_mtype); +var43 = nitc___nitc__AbstractCompilerVisitor___new_var(self, var_mtype); } -var_res = var39; +var_res = var43; { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var43 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var43 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var47 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var47 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var41 = var43; -RET_LABEL42:(void)0; +var45 = var47; +RET_LABEL46:(void)0; } } { -{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var41) on */ -var46 = var41->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var44 = var46; -RET_LABEL45:(void)0; +{ /* Inline separate_compiler$SeparateCompiler$runtime_type_analysis (var45) on */ +var50 = var45->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var48 = var50; +RET_LABEL49:(void)0; } } -if (var44 == NULL) { -var47 = 0; /* is null */ +if (var48 == NULL) { +var51 = 0; /* is null */ } else { -var47 = 1; /* arg is null and recv is not */ +var51 = 1; /* arg is null and recv is not */ } if (0) { -{ /* Inline kernel#Object#!= (var44,((val*)NULL)) on */ -var_other29 = ((val*)NULL); +{ /* Inline kernel$Object$!= (var48,((val*)NULL)) on */ +var_other33 = ((val*)NULL); { -var50 = ((short int(*)(val* self, val* p0))(var44->class->vft[COLOR_core__kernel__Object___61d_61d]))(var44, var_other29); /* == on */ +var54 = ((short int(*)(val* self, val* p0))(var48->class->vft[COLOR_core__kernel__Object___61d_61d]))(var48, var_other33); /* == on */ } -var51 = !var50; -var48 = var51; -goto RET_LABEL49; -RET_LABEL49:(void)0; +var55 = !var54; +var52 = var55; +goto RET_LABEL53; +RET_LABEL53:(void)0; } -var47 = var48; +var51 = var52; } -var_52 = var47; -if (var47){ +var_56 = var51; +if (var51){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var55 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var55 == NULL)) { +{ /* Inline abstract_compiler$AbstractCompilerVisitor$compiler (self) on */ +var59 = self->attrs[COLOR_nitc__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var59 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1133); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1214); fatal_exit(1); } -var53 = var55; -RET_LABEL54:(void)0; +var57 = var59; +RET_LABEL58:(void)0; } } { -{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var53) on */ -var58 = var53->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var56 = var58; -RET_LABEL57:(void)0; +{ /* Inline separate_compiler$SeparateCompiler$runtime_type_analysis (var57) on */ +var62 = var57->attrs[COLOR_nitc__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var60 = var62; +RET_LABEL61:(void)0; +} } +if (var60 == NULL) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); } -if (var56 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 622); fatal_exit(1); } else { -{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var56) on */ -if (unlikely(var56 == NULL)) { +{ /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (var60) on */ +if (unlikely(var60 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Receiver is null"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60); fatal_exit(1); } -var61 = var56->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ -if (unlikely(var61 == NULL)) { +var65 = var60->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var65 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60); fatal_exit(1); } -var59 = var61; -RET_LABEL60:(void)0; +var63 = var65; +RET_LABEL64:(void)0; } } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var64 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var64 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var68 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var68 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var62 = var64; -RET_LABEL63:(void)0; +var66 = var68; +RET_LABEL67:(void)0; } } -/* isa MClassType */ -cltype66 = type_nitc__MClassType.color; -idtype67 = type_nitc__MClassType.id; -if(cltype66 >= var62->type->table_size) { -var65 = 0; +/* isa MClassType */ +cltype70 = type_nitc__MClassType.color; +idtype71 = type_nitc__MClassType.id; +if(cltype70 >= var66->type->table_size) { +var69 = 0; } else { -var65 = var62->type->type_table[cltype66] == idtype67; +var69 = var66->type->type_table[cltype70] == idtype71; } -if (unlikely(!var65)) { -var_class_name = var62 == NULL ? "null" : var62->type->name; +if (unlikely(!var69)) { +var_class_name = var66 == NULL ? "null" : var66->type->name; PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 622); fatal_exit(1); } { -var68 = core___core__HashSet___core__abstract_collection__Collection__has(var59, var62); -} -var69 = !var68; -var40 = var69; -} else { -var40 = var_52; +var72 = core___core__HashSet___core__abstract_collection__Collection__has(var63, var66); } -if (var40){ -if (unlikely(varonce70==NULL)) { -var71 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); -if (likely(varonce72!=NULL)) { -var73 = varonce72; +var73 = !var72; +var44 = var73; } else { -var74 = "/*no boxing of "; -var75 = core__flat___NativeString___to_s_full(var74, 15l, 15l); -var73 = var75; -varonce72 = var73; +var44 = var_56; } -((struct instance_core__NativeArray*)var71)->values[0]=var73; +if (var44){ +if (unlikely(varonce74==NULL)) { +var75 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String); if (likely(varonce76!=NULL)) { var77 = varonce76; } else { -var78 = ": "; -var79 = core__flat___NativeString___to_s_full(var78, 2l, 2l); +var78 = "/*no boxing of "; +var80 = (val*)(15l<<2|1); +var81 = (val*)(15l<<2|1); +var82 = (val*)((long)(0)<<2|3); +var83 = (val*)((long)(0)<<2|3); +var79 = core__flat___CString___to_s_unsafe(var78, var80, var81, var82, var83); var77 = var79; varonce76 = var77; } -((struct instance_core__NativeArray*)var71)->values[2]=var77; -if (likely(varonce80!=NULL)) { -var81 = varonce80; +((struct instance_core__NativeArray*)var75)->values[0]=var77; +if (likely(varonce84!=NULL)) { +var85 = varonce84; } else { -var82 = " is not live! */"; -var83 = core__flat___NativeString___to_s_full(var82, 16l, 16l); -var81 = var83; -varonce80 = var81; +var86 = ": "; +var88 = (val*)(2l<<2|1); +var89 = (val*)(2l<<2|1); +var90 = (val*)((long)(0)<<2|3); +var91 = (val*)((long)(0)<<2|3); +var87 = core__flat___CString___to_s_unsafe(var86, var88, var89, var90, var91); +var85 = var87; +varonce84 = var85; } -((struct instance_core__NativeArray*)var71)->values[4]=var81; +((struct instance_core__NativeArray*)var75)->values[2]=var85; +if (likely(varonce92!=NULL)) { +var93 = varonce92; } else { -var71 = varonce70; -varonce70 = NULL; +var94 = " is not live! */"; +var96 = (val*)(16l<<2|1); +var97 = (val*)(16l<<2|1); +var98 = (val*)((long)(0)<<2|3); +var99 = (val*)((long)(0)<<2|3); +var95 = core__flat___CString___to_s_unsafe(var94, var96, var97, var98, var99); +var93 = var95; +varonce92 = var93; +} +((struct instance_core__NativeArray*)var75)->values[4]=var93; +} else { +var75 = varonce74; +varonce74 = NULL; } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var86 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var86 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var102 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var102 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var84 = var86; -RET_LABEL85:(void)0; +var100 = var102; +RET_LABEL101:(void)0; } } { -var87 = ((val*(*)(val* self))(var84->class->vft[COLOR_core__abstract_text__Object__to_s]))(var84); /* to_s on */ +var103 = ((val*(*)(val* self))(var100->class->vft[COLOR_core__abstract_text__Object__to_s]))(var100); /* to_s on */ } -((struct instance_core__NativeArray*)var71)->values[1]=var87; +((struct instance_core__NativeArray*)var75)->values[1]=var103; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var90 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var90 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var106 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var106 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var88 = var90; -RET_LABEL89:(void)0; +var104 = var106; +RET_LABEL105:(void)0; } } { -var91 = ((val*(*)(val* self))(var88->class->vft[COLOR_core__abstract_text__Object__to_s]))(var88); /* to_s on */ +var107 = ((val*(*)(val* self))(var104->class->vft[COLOR_core__abstract_text__Object__to_s]))(var104); /* to_s on */ } -((struct instance_core__NativeArray*)var71)->values[3]=var91; +((struct instance_core__NativeArray*)var75)->values[3]=var107; { -var92 = ((val*(*)(val* self))(var71->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var71); /* native_to_s on */ +var108 = ((val*(*)(val* self))(var75->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var75); /* native_to_s on */ } -varonce70 = var71; +varonce74 = var75; { -nitc___nitc__AbstractCompilerVisitor___add(self, var92); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var108); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (likely(varonce93!=NULL)) { -var94 = varonce93; +if (likely(varonce109!=NULL)) { +var110 = varonce109; } else { -var95 = "PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);"; -var96 = core__flat___NativeString___to_s_full(var95, 52l, 52l); -var94 = var96; -varonce93 = var94; +var111 = "PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);"; +var113 = (val*)(52l<<2|1); +var114 = (val*)(52l<<2|1); +var115 = (val*)((long)(0)<<2|3); +var116 = (val*)((long)(0)<<2|3); +var112 = core__flat___CString___to_s_unsafe(var111, var113, var114, var115, var116); +var110 = var112; +varonce109 = var110; } { -nitc___nitc__AbstractCompilerVisitor___add(self, var94); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var110); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } var = var_res; goto RET_LABEL; } else { } -if (unlikely(varonce97==NULL)) { -var98 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce99!=NULL)) { -var100 = varonce99; +if (unlikely(varonce117==NULL)) { +var118 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce119!=NULL)) { +var120 = varonce119; } else { -var101 = "BOX_"; -var102 = core__flat___NativeString___to_s_full(var101, 4l, 4l); -var100 = var102; -varonce99 = var100; +var121 = "BOX_"; +var123 = (val*)(4l<<2|1); +var124 = (val*)(4l<<2|1); +var125 = (val*)((long)(0)<<2|3); +var126 = (val*)((long)(0)<<2|3); +var122 = core__flat___CString___to_s_unsafe(var121, var123, var124, var125, var126); +var120 = var122; +varonce119 = var120; } -((struct instance_core__NativeArray*)var98)->values[0]=var100; +((struct instance_core__NativeArray*)var118)->values[0]=var120; } else { -var98 = varonce97; -varonce97 = NULL; +var118 = varonce117; +varonce117 = NULL; } { -var103 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ +var127 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ } -((struct instance_core__NativeArray*)var98)->values[1]=var103; +((struct instance_core__NativeArray*)var118)->values[1]=var127; { -var104 = ((val*(*)(val* self))(var98->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var98); /* native_to_s on */ +var128 = ((val*(*)(val* self))(var118->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var118); /* native_to_s on */ } -varonce97 = var98; +varonce117 = var118; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var104); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var128); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce105==NULL)) { -var106 = NEW_core__NativeArray(8l, &type_core__NativeArray__core__String); -if (likely(varonce107!=NULL)) { -var108 = varonce107; +if (unlikely(varonce129==NULL)) { +var130 = NEW_core__NativeArray((int)8l, &type_core__NativeArray__core__String); +if (likely(varonce131!=NULL)) { +var132 = varonce131; } else { -var109 = " = BOX_"; -var110 = core__flat___NativeString___to_s_full(var109, 7l, 7l); -var108 = var110; -varonce107 = var108; +var133 = " = BOX_"; +var135 = (val*)(7l<<2|1); +var136 = (val*)(7l<<2|1); +var137 = (val*)((long)(0)<<2|3); +var138 = (val*)((long)(0)<<2|3); +var134 = core__flat___CString___to_s_unsafe(var133, var135, var136, var137, var138); +var132 = var134; +varonce131 = var132; } -((struct instance_core__NativeArray*)var106)->values[1]=var108; -if (likely(varonce111!=NULL)) { -var112 = varonce111; +((struct instance_core__NativeArray*)var130)->values[1]=var132; +if (likely(varonce139!=NULL)) { +var140 = varonce139; } else { -var113 = "("; -var114 = core__flat___NativeString___to_s_full(var113, 1l, 1l); -var112 = var114; -varonce111 = var112; +var141 = "("; +var143 = (val*)(1l<<2|1); +var144 = (val*)(1l<<2|1); +var145 = (val*)((long)(0)<<2|3); +var146 = (val*)((long)(0)<<2|3); +var142 = core__flat___CString___to_s_unsafe(var141, var143, var144, var145, var146); +var140 = var142; +varonce139 = var140; } -((struct instance_core__NativeArray*)var106)->values[3]=var112; -if (likely(varonce115!=NULL)) { -var116 = varonce115; +((struct instance_core__NativeArray*)var130)->values[3]=var140; +if (likely(varonce147!=NULL)) { +var148 = varonce147; } else { -var117 = "); /* boxing "; -var118 = core__flat___NativeString___to_s_full(var117, 13l, 13l); -var116 = var118; -varonce115 = var116; +var149 = "); /* boxing "; +var151 = (val*)(13l<<2|1); +var152 = (val*)(13l<<2|1); +var153 = (val*)((long)(0)<<2|3); +var154 = (val*)((long)(0)<<2|3); +var150 = core__flat___CString___to_s_unsafe(var149, var151, var152, var153, var154); +var148 = var150; +varonce147 = var148; } -((struct instance_core__NativeArray*)var106)->values[5]=var116; -if (likely(varonce119!=NULL)) { -var120 = varonce119; +((struct instance_core__NativeArray*)var130)->values[5]=var148; +if (likely(varonce155!=NULL)) { +var156 = varonce155; } else { -var121 = " */"; -var122 = core__flat___NativeString___to_s_full(var121, 3l, 3l); -var120 = var122; -varonce119 = var120; +var157 = " */"; +var159 = (val*)(3l<<2|1); +var160 = (val*)(3l<<2|1); +var161 = (val*)((long)(0)<<2|3); +var162 = (val*)((long)(0)<<2|3); +var158 = core__flat___CString___to_s_unsafe(var157, var159, var160, var161, var162); +var156 = var158; +varonce155 = var156; } -((struct instance_core__NativeArray*)var106)->values[7]=var120; +((struct instance_core__NativeArray*)var130)->values[7]=var156; } else { -var106 = varonce105; -varonce105 = NULL; +var130 = varonce129; +varonce129 = NULL; } { -var123 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var163 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var106)->values[0]=var123; +((struct instance_core__NativeArray*)var130)->values[0]=var163; { -var124 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ +var164 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ } -((struct instance_core__NativeArray*)var106)->values[2]=var124; +((struct instance_core__NativeArray*)var130)->values[2]=var164; { -var125 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var165 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var106)->values[4]=var125; +((struct instance_core__NativeArray*)var130)->values[4]=var165; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var128 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var128 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var168 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var168 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var126 = var128; -RET_LABEL127:(void)0; +var166 = var168; +RET_LABEL167:(void)0; } } { -var129 = ((val*(*)(val* self))(var126->class->vft[COLOR_core__abstract_text__Object__to_s]))(var126); /* to_s on */ +var169 = ((val*(*)(val* self))(var166->class->vft[COLOR_core__abstract_text__Object__to_s]))(var166); /* to_s on */ } -((struct instance_core__NativeArray*)var106)->values[6]=var129; +((struct instance_core__NativeArray*)var130)->values[6]=var169; { -var130 = ((val*(*)(val* self))(var106->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var106); /* native_to_s on */ +var170 = ((val*(*)(val* self))(var130->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var130); /* native_to_s on */ } -varonce105 = var106; +varonce129 = var130; { -nitc___nitc__AbstractCompilerVisitor___add(self, var130); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var170); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } -if (unlikely(varonce131==NULL)) { -var132 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce133!=NULL)) { -var134 = varonce133; +if (unlikely(varonce171==NULL)) { +var172 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce173!=NULL)) { +var174 = varonce173; } else { -var135 = "class_"; -var136 = core__flat___NativeString___to_s_full(var135, 6l, 6l); -var134 = var136; -varonce133 = var134; +var175 = "class_"; +var177 = (val*)(6l<<2|1); +var178 = (val*)(6l<<2|1); +var179 = (val*)((long)(0)<<2|3); +var180 = (val*)((long)(0)<<2|3); +var176 = core__flat___CString___to_s_unsafe(var175, var177, var178, var179, var180); +var174 = var176; +varonce173 = var174; } -((struct instance_core__NativeArray*)var132)->values[0]=var134; +((struct instance_core__NativeArray*)var172)->values[0]=var174; } else { -var132 = varonce131; -varonce131 = NULL; +var172 = varonce171; +varonce171 = NULL; } { -var137 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +var181 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } -((struct instance_core__NativeArray*)var132)->values[1]=var137; +((struct instance_core__NativeArray*)var172)->values[1]=var181; { -var138 = ((val*(*)(val* self))(var132->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var132); /* native_to_s on */ +var182 = ((val*(*)(val* self))(var172->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var172); /* native_to_s on */ } -varonce131 = var132; +varonce171 = var172; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var138); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var182); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce139==NULL)) { -var140 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce141!=NULL)) { -var142 = varonce141; +if (unlikely(varonce183==NULL)) { +var184 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce185!=NULL)) { +var186 = varonce185; } else { -var143 = "->class = &class_"; -var144 = core__flat___NativeString___to_s_full(var143, 17l, 17l); -var142 = var144; -varonce141 = var142; +var187 = "->class = &class_"; +var189 = (val*)(17l<<2|1); +var190 = (val*)(17l<<2|1); +var191 = (val*)((long)(0)<<2|3); +var192 = (val*)((long)(0)<<2|3); +var188 = core__flat___CString___to_s_unsafe(var187, var189, var190, var191, var192); +var186 = var188; +varonce185 = var186; } -((struct instance_core__NativeArray*)var140)->values[1]=var142; -if (likely(varonce145!=NULL)) { -var146 = varonce145; +((struct instance_core__NativeArray*)var184)->values[1]=var186; +if (likely(varonce193!=NULL)) { +var194 = varonce193; } else { -var147 = ";"; -var148 = core__flat___NativeString___to_s_full(var147, 1l, 1l); -var146 = var148; -varonce145 = var146; +var195 = ";"; +var197 = (val*)(1l<<2|1); +var198 = (val*)(1l<<2|1); +var199 = (val*)((long)(0)<<2|3); +var200 = (val*)((long)(0)<<2|3); +var196 = core__flat___CString___to_s_unsafe(var195, var197, var198, var199, var200); +var194 = var196; +varonce193 = var194; } -((struct instance_core__NativeArray*)var140)->values[3]=var146; +((struct instance_core__NativeArray*)var184)->values[3]=var194; } else { -var140 = varonce139; -varonce139 = NULL; +var184 = varonce183; +varonce183 = NULL; } { -var149 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var201 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var140)->values[0]=var149; +((struct instance_core__NativeArray*)var184)->values[0]=var201; { -var150 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +var202 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } -((struct instance_core__NativeArray*)var140)->values[2]=var150; +((struct instance_core__NativeArray*)var184)->values[2]=var202; { -var151 = ((val*(*)(val* self))(var140->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var140); /* native_to_s on */ +var203 = ((val*(*)(val* self))(var184->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var184); /* native_to_s on */ } -varonce139 = var140; +varonce183 = var184; { -nitc___nitc__AbstractCompilerVisitor___add(self, var151); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var203); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } var = var_res; goto RET_LABEL; @@ -3608,269 +6324,350 @@ goto RET_LABEL; RET_LABEL:; return var; } -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#class_name_string for (self: SeparateErasureCompilerVisitor, RuntimeVariable): String */ +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$class_name_string for (self: SeparateErasureCompilerVisitor, RuntimeVariable): String */ val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__class_name_string(val* self, val* p0) { val* var /* : String */; val* var_value /* var value: RuntimeVariable */; static val* varonce; val* var1 /* : String */; -char* var2 /* : NativeString */; +char* var2 /* : CString */; val* var3 /* : String */; -val* var4 /* : String */; -val* var_res /* var res: String */; -val* var6 /* : NativeArray[String] */; -static val* varonce5; -static val* varonce7; +val* var4 /* : nullable Int */; +val* var5 /* : nullable Int */; +val* var6 /* : nullable Bool */; +val* var7 /* : nullable Bool */; val* var8 /* : String */; -char* var9 /* : NativeString */; -val* var10 /* : String */; +val* var_res /* var res: String */; +val* var10 /* : NativeArray[String] */; +static val* varonce9; static val* varonce11; val* var12 /* : String */; -char* var13 /* : NativeString */; +char* var13 /* : CString */; val* var14 /* : String */; -val* var15 /* : String */; -val* var16 /* : MType */; -val* var18 /* : MType */; -short int var19 /* : Bool */; -short int var20 /* : Bool */; -val* var22 /* : NativeArray[String] */; -static val* varonce21; -static val* varonce23; -val* var24 /* : String */; -char* var25 /* : NativeString */; -val* var26 /* : String */; -static val* varonce27; -val* var28 /* : String */; -char* var29 /* : NativeString */; -val* var30 /* : String */; -static val* varonce31; -val* var32 /* : String */; -char* var33 /* : NativeString */; -val* var34 /* : String */; -val* var35 /* : String */; +val* var15 /* : nullable Int */; +val* var16 /* : nullable Int */; +val* var17 /* : nullable Bool */; +val* var18 /* : nullable Bool */; +static val* varonce19; +val* var20 /* : String */; +char* var21 /* : CString */; +val* var22 /* : String */; +val* var23 /* : nullable Int */; +val* var24 /* : nullable Int */; +val* var25 /* : nullable Bool */; +val* var26 /* : nullable Bool */; +val* var27 /* : String */; +val* var28 /* : MType */; +val* var30 /* : MType */; +short int var31 /* : Bool */; +short int var32 /* : Bool */; +val* var34 /* : NativeArray[String] */; +static val* varonce33; +static val* varonce35; val* var36 /* : String */; -val* var37 /* : String */; -val* var39 /* : NativeArray[String] */; -static val* varonce38; -static val* varonce40; -val* var41 /* : String */; -char* var42 /* : NativeString */; -val* var43 /* : String */; -val* var44 /* : MType */; -val* var46 /* : MType */; -val* var47 /* : String */; -val* var48 /* : String */; -val* var50 /* : NativeArray[String] */; -static val* varonce49; +char* var37 /* : CString */; +val* var38 /* : String */; +val* var39 /* : nullable Int */; +val* var40 /* : nullable Int */; +val* var41 /* : nullable Bool */; +val* var42 /* : nullable Bool */; +static val* varonce43; +val* var44 /* : String */; +char* var45 /* : CString */; +val* var46 /* : String */; +val* var47 /* : nullable Int */; +val* var48 /* : nullable Int */; +val* var49 /* : nullable Bool */; +val* var50 /* : nullable Bool */; static val* varonce51; val* var52 /* : String */; -char* var53 /* : NativeString */; +char* var53 /* : CString */; val* var54 /* : String */; -static val* varonce55; -val* var56 /* : String */; -char* var57 /* : NativeString */; -val* var58 /* : String */; -val* var59 /* : MType */; -val* var61 /* : MType */; -val* var62 /* : String */; -val* var63 /* : String */; +val* var55 /* : nullable Int */; +val* var56 /* : nullable Int */; +val* var57 /* : nullable Bool */; +val* var58 /* : nullable Bool */; +val* var59 /* : String */; +val* var60 /* : String */; +val* var61 /* : String */; +val* var63 /* : NativeArray[String] */; +static val* varonce62; +static val* varonce64; +val* var65 /* : String */; +char* var66 /* : CString */; +val* var67 /* : String */; +val* var68 /* : nullable Int */; +val* var69 /* : nullable Int */; +val* var70 /* : nullable Bool */; +val* var71 /* : nullable Bool */; +val* var72 /* : MType */; +val* var74 /* : MType */; +val* var75 /* : String */; +val* var76 /* : String */; +val* var78 /* : NativeArray[String] */; +static val* varonce77; +static val* varonce79; +val* var80 /* : String */; +char* var81 /* : CString */; +val* var82 /* : String */; +val* var83 /* : nullable Int */; +val* var84 /* : nullable Int */; +val* var85 /* : nullable Bool */; +val* var86 /* : nullable Bool */; +static val* varonce87; +val* var88 /* : String */; +char* var89 /* : CString */; +val* var90 /* : String */; +val* var91 /* : nullable Int */; +val* var92 /* : nullable Int */; +val* var93 /* : nullable Bool */; +val* var94 /* : nullable Bool */; +val* var95 /* : MType */; +val* var97 /* : MType */; +val* var98 /* : String */; +val* var99 /* : String */; var_value = p0; if (likely(varonce!=NULL)) { var1 = varonce; } else { var2 = "var_class_name"; -var3 = core__flat___NativeString___to_s_full(var2, 14l, 14l); +var4 = (val*)(14l<<2|1); +var5 = (val*)(14l<<2|1); +var6 = (val*)((long)(0)<<2|3); +var7 = (val*)((long)(0)<<2|3); +var3 = core__flat___CString___to_s_unsafe(var2, var4, var5, var6, var7); var1 = var3; varonce = var1; } { -var4 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var1); -} -var_res = var4; -if (unlikely(varonce5==NULL)) { -var6 = NEW_core__NativeArray(3l, &type_core__NativeArray__core__String); -if (likely(varonce7!=NULL)) { -var8 = varonce7; -} else { -var9 = "const char* "; -var10 = core__flat___NativeString___to_s_full(var9, 12l, 12l); -var8 = var10; -varonce7 = var8; +var8 = nitc___nitc__AbstractCompilerVisitor___get_name(self, var1); } -((struct instance_core__NativeArray*)var6)->values[0]=var8; +var_res = var8; +if (unlikely(varonce9==NULL)) { +var10 = NEW_core__NativeArray((int)3l, &type_core__NativeArray__core__String); if (likely(varonce11!=NULL)) { var12 = varonce11; } else { -var13 = ";"; -var14 = core__flat___NativeString___to_s_full(var13, 1l, 1l); +var13 = "const char* "; +var15 = (val*)(12l<<2|1); +var16 = (val*)(12l<<2|1); +var17 = (val*)((long)(0)<<2|3); +var18 = (val*)((long)(0)<<2|3); +var14 = core__flat___CString___to_s_unsafe(var13, var15, var16, var17, var18); var12 = var14; varonce11 = var12; } -((struct instance_core__NativeArray*)var6)->values[2]=var12; +((struct instance_core__NativeArray*)var10)->values[0]=var12; +if (likely(varonce19!=NULL)) { +var20 = varonce19; +} else { +var21 = ";"; +var23 = (val*)(1l<<2|1); +var24 = (val*)(1l<<2|1); +var25 = (val*)((long)(0)<<2|3); +var26 = (val*)((long)(0)<<2|3); +var22 = core__flat___CString___to_s_unsafe(var21, var23, var24, var25, var26); +var20 = var22; +varonce19 = var20; +} +((struct instance_core__NativeArray*)var10)->values[2]=var20; } else { -var6 = varonce5; -varonce5 = NULL; +var10 = varonce9; +varonce9 = NULL; } -((struct instance_core__NativeArray*)var6)->values[1]=var_res; +((struct instance_core__NativeArray*)var10)->values[1]=var_res; { -var15 = ((val*(*)(val* self))(var6->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var6); /* native_to_s on */ +var27 = ((val*(*)(val* self))(var10->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var10); /* native_to_s on */ } -varonce5 = var6; +varonce9 = var10; { -nitc___nitc__AbstractCompilerVisitor___add_decl(self, var15); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nitc___nitc__AbstractCompilerVisitor___add_decl(self, var27); /* Direct call abstract_compiler$AbstractCompilerVisitor$add_decl on */ } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var18 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var18 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var30 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var30 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var16 = var18; -RET_LABEL17:(void)0; +var28 = var30; +RET_LABEL29:(void)0; } } { -var19 = ((short int(*)(val* self))(var16->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var16); /* is_c_primitive on */ +var31 = ((short int(*)(val* self))(var28->class->vft[COLOR_nitc__abstract_compiler__MType__is_c_primitive]))(var28); /* is_c_primitive on */ } -var20 = !var19; -if (var20){ -if (unlikely(varonce21==NULL)) { -var22 = NEW_core__NativeArray(6l, &type_core__NativeArray__core__String); -if (likely(varonce23!=NULL)) { -var24 = varonce23; +var32 = !var31; +if (var32){ +if (unlikely(varonce33==NULL)) { +var34 = NEW_core__NativeArray((int)6l, &type_core__NativeArray__core__String); +if (likely(varonce35!=NULL)) { +var36 = varonce35; } else { -var25 = " = "; -var26 = core__flat___NativeString___to_s_full(var25, 3l, 3l); -var24 = var26; -varonce23 = var24; +var37 = " = "; +var39 = (val*)(3l<<2|1); +var40 = (val*)(3l<<2|1); +var41 = (val*)((long)(0)<<2|3); +var42 = (val*)((long)(0)<<2|3); +var38 = core__flat___CString___to_s_unsafe(var37, var39, var40, var41, var42); +var36 = var38; +varonce35 = var36; } -((struct instance_core__NativeArray*)var22)->values[1]=var24; -if (likely(varonce27!=NULL)) { -var28 = varonce27; +((struct instance_core__NativeArray*)var34)->values[1]=var36; +if (likely(varonce43!=NULL)) { +var44 = varonce43; } else { -var29 = " == NULL ? \"null\" : "; -var30 = core__flat___NativeString___to_s_full(var29, 20l, 20l); -var28 = var30; -varonce27 = var28; +var45 = " == NULL ? \"null\" : "; +var47 = (val*)(20l<<2|1); +var48 = (val*)(20l<<2|1); +var49 = (val*)((long)(0)<<2|3); +var50 = (val*)((long)(0)<<2|3); +var46 = core__flat___CString___to_s_unsafe(var45, var47, var48, var49, var50); +var44 = var46; +varonce43 = var44; } -((struct instance_core__NativeArray*)var22)->values[3]=var28; -if (likely(varonce31!=NULL)) { -var32 = varonce31; +((struct instance_core__NativeArray*)var34)->values[3]=var44; +if (likely(varonce51!=NULL)) { +var52 = varonce51; } else { -var33 = "->class->name;"; -var34 = core__flat___NativeString___to_s_full(var33, 14l, 14l); -var32 = var34; -varonce31 = var32; +var53 = "->class->name;"; +var55 = (val*)(14l<<2|1); +var56 = (val*)(14l<<2|1); +var57 = (val*)((long)(0)<<2|3); +var58 = (val*)((long)(0)<<2|3); +var54 = core__flat___CString___to_s_unsafe(var53, var55, var56, var57, var58); +var52 = var54; +varonce51 = var52; } -((struct instance_core__NativeArray*)var22)->values[5]=var32; +((struct instance_core__NativeArray*)var34)->values[5]=var52; } else { -var22 = varonce21; -varonce21 = NULL; +var34 = varonce33; +varonce33 = NULL; } -((struct instance_core__NativeArray*)var22)->values[0]=var_res; +((struct instance_core__NativeArray*)var34)->values[0]=var_res; { -var35 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var59 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var22)->values[2]=var35; +((struct instance_core__NativeArray*)var34)->values[2]=var59; { -var36 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ +var60 = ((val*(*)(val* self))(var_value->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_value); /* to_s on */ } -((struct instance_core__NativeArray*)var22)->values[4]=var36; +((struct instance_core__NativeArray*)var34)->values[4]=var60; { -var37 = ((val*(*)(val* self))(var22->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var22); /* native_to_s on */ +var61 = ((val*(*)(val* self))(var34->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var34); /* native_to_s on */ } -varonce21 = var22; +varonce33 = var34; { -nitc___nitc__AbstractCompilerVisitor___add(self, var37); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var61); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } else { -if (unlikely(varonce38==NULL)) { -var39 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce40!=NULL)) { -var41 = varonce40; +if (unlikely(varonce62==NULL)) { +var63 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); +if (likely(varonce64!=NULL)) { +var65 = varonce64; } else { -var42 = "class_"; -var43 = core__flat___NativeString___to_s_full(var42, 6l, 6l); -var41 = var43; -varonce40 = var41; +var66 = "class_"; +var68 = (val*)(6l<<2|1); +var69 = (val*)(6l<<2|1); +var70 = (val*)((long)(0)<<2|3); +var71 = (val*)((long)(0)<<2|3); +var67 = core__flat___CString___to_s_unsafe(var66, var68, var69, var70, var71); +var65 = var67; +varonce64 = var65; } -((struct instance_core__NativeArray*)var39)->values[0]=var41; +((struct instance_core__NativeArray*)var63)->values[0]=var65; } else { -var39 = varonce38; -varonce38 = NULL; +var63 = varonce62; +varonce62 = NULL; } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var46 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var46 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var74 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var74 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var44 = var46; -RET_LABEL45:(void)0; +var72 = var74; +RET_LABEL73:(void)0; } } { -var47 = ((val*(*)(val* self))(var44->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var44); /* c_name on */ +var75 = ((val*(*)(val* self))(var72->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var72); /* c_name on */ } -((struct instance_core__NativeArray*)var39)->values[1]=var47; +((struct instance_core__NativeArray*)var63)->values[1]=var75; { -var48 = ((val*(*)(val* self))(var39->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var39); /* native_to_s on */ +var76 = ((val*(*)(val* self))(var63->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var63); /* native_to_s on */ } -varonce38 = var39; +varonce62 = var63; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var48); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var76); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -if (unlikely(varonce49==NULL)) { -var50 = NEW_core__NativeArray(4l, &type_core__NativeArray__core__String); -if (likely(varonce51!=NULL)) { -var52 = varonce51; +if (unlikely(varonce77==NULL)) { +var78 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__String); +if (likely(varonce79!=NULL)) { +var80 = varonce79; } else { -var53 = " = class_"; -var54 = core__flat___NativeString___to_s_full(var53, 9l, 9l); -var52 = var54; -varonce51 = var52; +var81 = " = class_"; +var83 = (val*)(9l<<2|1); +var84 = (val*)(9l<<2|1); +var85 = (val*)((long)(0)<<2|3); +var86 = (val*)((long)(0)<<2|3); +var82 = core__flat___CString___to_s_unsafe(var81, var83, var84, var85, var86); +var80 = var82; +varonce79 = var80; } -((struct instance_core__NativeArray*)var50)->values[1]=var52; -if (likely(varonce55!=NULL)) { -var56 = varonce55; +((struct instance_core__NativeArray*)var78)->values[1]=var80; +if (likely(varonce87!=NULL)) { +var88 = varonce87; } else { -var57 = ".name;"; -var58 = core__flat___NativeString___to_s_full(var57, 6l, 6l); -var56 = var58; -varonce55 = var56; +var89 = ".name;"; +var91 = (val*)(6l<<2|1); +var92 = (val*)(6l<<2|1); +var93 = (val*)((long)(0)<<2|3); +var94 = (val*)((long)(0)<<2|3); +var90 = core__flat___CString___to_s_unsafe(var89, var91, var92, var93, var94); +var88 = var90; +varonce87 = var88; } -((struct instance_core__NativeArray*)var50)->values[3]=var56; +((struct instance_core__NativeArray*)var78)->values[3]=var88; } else { -var50 = varonce49; -varonce49 = NULL; +var78 = varonce77; +varonce77 = NULL; } -((struct instance_core__NativeArray*)var50)->values[0]=var_res; +((struct instance_core__NativeArray*)var78)->values[0]=var_res; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var61 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var61 == NULL)) { +{ /* Inline abstract_compiler$RuntimeVariable$mtype (var_value) on */ +var97 = var_value->attrs[COLOR_nitc__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var97 == NULL)) { +if(catchStack.cursor >= 0){ +longjmp(catchStack.envs[catchStack.cursor], 1); +} PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1870); +PRINT_ERROR(" (%s:%d)\n", FILE_nitc__abstract_compiler, 1983); fatal_exit(1); } -var59 = var61; -RET_LABEL60:(void)0; +var95 = var97; +RET_LABEL96:(void)0; } } { -var62 = ((val*(*)(val* self))(var59->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var59); /* c_name on */ +var98 = ((val*(*)(val* self))(var95->class->vft[COLOR_nitc__model_base__MEntity__c_name]))(var95); /* c_name on */ } -((struct instance_core__NativeArray*)var50)->values[2]=var62; +((struct instance_core__NativeArray*)var78)->values[2]=var98; { -var63 = ((val*(*)(val* self))(var50->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var50); /* native_to_s on */ +var99 = ((val*(*)(val* self))(var78->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var78); /* native_to_s on */ } -varonce49 = var50; +varonce77 = var78; { -nitc___nitc__AbstractCompilerVisitor___add(self, var63); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var99); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } } var = var_res; @@ -3878,7 +6675,7 @@ goto RET_LABEL; RET_LABEL:; return var; } -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#native_array_instance for (self: SeparateErasureCompilerVisitor, MType, RuntimeVariable): RuntimeVariable */ +/* method separate_erasure_compiler$SeparateErasureCompilerVisitor$native_array_instance for (self: SeparateErasureCompilerVisitor, MType, RuntimeVariable): RuntimeVariable */ val* nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__native_array_instance(val* self, val* p0, val* p1) { val* var /* : RuntimeVariable */; val* var_elttype /* var elttype: MType */; @@ -3896,28 +6693,44 @@ val* var7 /* : NativeArray[String] */; static val* varonce; static val* varonce8; val* var9 /* : String */; -char* var10 /* : NativeString */; +char* var10 /* : CString */; val* var11 /* : String */; -val* var12 /* : String */; -val* var13 /* : String */; -val* var15 /* : NativeArray[String] */; -static val* varonce14; -static val* varonce16; +val* var12 /* : nullable Int */; +val* var13 /* : nullable Int */; +val* var14 /* : nullable Bool */; +val* var15 /* : nullable Bool */; +val* var16 /* : String */; val* var17 /* : String */; -char* var18 /* : NativeString */; -val* var19 /* : String */; +val* var19 /* : NativeArray[String] */; +static val* varonce18; static val* varonce20; val* var21 /* : String */; -char* var22 /* : NativeString */; +char* var22 /* : CString */; val* var23 /* : String */; -static val* varonce24; -val* var25 /* : String */; -char* var26 /* : NativeString */; -val* var27 /* : String */; -val* var28 /* : String */; +val* var24 /* : nullable Int */; +val* var25 /* : nullable Int */; +val* var26 /* : nullable Bool */; +val* var27 /* : nullable Bool */; +static val* varonce28; val* var29 /* : String */; -val* var30 /* : String */; +char* var30 /* : CString */; val* var31 /* : String */; +val* var32 /* : nullable Int */; +val* var33 /* : nullable Int */; +val* var34 /* : nullable Bool */; +val* var35 /* : nullable Bool */; +static val* varonce36; +val* var37 /* : String */; +char* var38 /* : CString */; +val* var39 /* : String */; +val* var40 /* : nullable Int */; +val* var41 /* : nullable Int */; +val* var42 /* : nullable Bool */; +val* var43 /* : nullable Bool */; +val* var44 /* : String */; +val* var45 /* : String */; +val* var46 /* : String */; +val* var47 /* : String */; var_elttype = p0; var_length = p1; { @@ -3929,11 +6742,11 @@ var2 = nitc__model___MModule___native_array_class(var1); var_nclass = var2; var3 = NEW_core__Array(&type_core__Array__nitc__MType); { -core___core__Array___with_capacity(var3, 1l); /* Direct call array#Array#with_capacity on */ +core___core__Array___with_capacity(var3, 1l); /* Direct call array$Array$with_capacity on */ } var_ = var3; { -core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var_elttype); /* Direct call array#AbstractArray#push on */ +core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var_elttype); /* Direct call array$AbstractArray$push on */ } { var4 = nitc___nitc__MClass___get_mtype(var_nclass, var_); @@ -3944,18 +6757,22 @@ var5 = nitc___nitc__AbstractCompilerVisitor___new_var(self, var_mtype); } var_res = var5; { -{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,1) on */ +{ /* 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_LABEL6:(void)0; } } if (unlikely(varonce==NULL)) { -var7 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); +var7 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String); if (likely(varonce8!=NULL)) { var9 = varonce8; } else { var10 = "NEW_"; -var11 = core__flat___NativeString___to_s_full(var10, 4l, 4l); +var12 = (val*)(4l<<2|1); +var13 = (val*)(4l<<2|1); +var14 = (val*)((long)(0)<<2|3); +var15 = (val*)((long)(0)<<2|3); +var11 = core__flat___CString___to_s_unsafe(var10, var12, var13, var14, var15); var9 = var11; varonce8 = var9; } @@ -3965,233 +6782,82 @@ var7 = varonce; varonce = NULL; } { -var12 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_nclass); +var16 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_nclass); } -((struct instance_core__NativeArray*)var7)->values[1]=var12; +((struct instance_core__NativeArray*)var7)->values[1]=var16; { -var13 = ((val*(*)(val* self))(var7->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var7); /* native_to_s on */ +var17 = ((val*(*)(val* self))(var7->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var7); /* native_to_s on */ } varonce = var7; { -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var13); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ -} -if (unlikely(varonce14==NULL)) { -var15 = NEW_core__NativeArray(6l, &type_core__NativeArray__core__String); -if (likely(varonce16!=NULL)) { -var17 = varonce16; -} else { -var18 = " = NEW_"; -var19 = core__flat___NativeString___to_s_full(var18, 7l, 7l); -var17 = var19; -varonce16 = var17; +nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var17); /* Direct call abstract_compiler$AbstractCompilerVisitor$require_declaration on */ } -((struct instance_core__NativeArray*)var15)->values[1]=var17; +if (unlikely(varonce18==NULL)) { +var19 = NEW_core__NativeArray((int)6l, &type_core__NativeArray__core__String); if (likely(varonce20!=NULL)) { var21 = varonce20; } else { -var22 = "("; -var23 = core__flat___NativeString___to_s_full(var22, 1l, 1l); +var22 = " = NEW_"; +var24 = (val*)(7l<<2|1); +var25 = (val*)(7l<<2|1); +var26 = (val*)((long)(0)<<2|3); +var27 = (val*)((long)(0)<<2|3); +var23 = core__flat___CString___to_s_unsafe(var22, var24, var25, var26, var27); var21 = var23; varonce20 = var21; } -((struct instance_core__NativeArray*)var15)->values[3]=var21; -if (likely(varonce24!=NULL)) { -var25 = varonce24; +((struct instance_core__NativeArray*)var19)->values[1]=var21; +if (likely(varonce28!=NULL)) { +var29 = varonce28; } else { -var26 = ");"; -var27 = core__flat___NativeString___to_s_full(var26, 2l, 2l); -var25 = var27; -varonce24 = var25; +var30 = "("; +var32 = (val*)(1l<<2|1); +var33 = (val*)(1l<<2|1); +var34 = (val*)((long)(0)<<2|3); +var35 = (val*)((long)(0)<<2|3); +var31 = core__flat___CString___to_s_unsafe(var30, var32, var33, var34, var35); +var29 = var31; +varonce28 = var29; +} +((struct instance_core__NativeArray*)var19)->values[3]=var29; +if (likely(varonce36!=NULL)) { +var37 = varonce36; +} else { +var38 = ");"; +var40 = (val*)(2l<<2|1); +var41 = (val*)(2l<<2|1); +var42 = (val*)((long)(0)<<2|3); +var43 = (val*)((long)(0)<<2|3); +var39 = core__flat___CString___to_s_unsafe(var38, var40, var41, var42, var43); +var37 = var39; +varonce36 = var37; } -((struct instance_core__NativeArray*)var15)->values[5]=var25; +((struct instance_core__NativeArray*)var19)->values[5]=var37; } else { -var15 = varonce14; -varonce14 = NULL; +var19 = varonce18; +varonce18 = NULL; } { -var28 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ +var44 = ((val*(*)(val* self))(var_res->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_res); /* to_s on */ } -((struct instance_core__NativeArray*)var15)->values[0]=var28; +((struct instance_core__NativeArray*)var19)->values[0]=var44; { -var29 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_nclass); +var45 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var_nclass); } -((struct instance_core__NativeArray*)var15)->values[2]=var29; +((struct instance_core__NativeArray*)var19)->values[2]=var45; { -var30 = ((val*(*)(val* self))(var_length->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_length); /* to_s on */ +var46 = ((val*(*)(val* self))(var_length->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_length); /* to_s on */ } -((struct instance_core__NativeArray*)var15)->values[4]=var30; +((struct instance_core__NativeArray*)var19)->values[4]=var46; { -var31 = ((val*(*)(val* self))(var15->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var15); /* native_to_s on */ +var47 = ((val*(*)(val* self))(var19->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var19); /* native_to_s on */ } -varonce14 = var15; +varonce18 = var19; { -nitc___nitc__AbstractCompilerVisitor___add(self, var31); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nitc___nitc__AbstractCompilerVisitor___add(self, var47); /* Direct call abstract_compiler$AbstractCompilerVisitor$add on */ } var = var_res; goto RET_LABEL; RET_LABEL:; return var; } -/* method separate_erasure_compiler#SeparateErasureCompilerVisitor#calloc_array for (self: SeparateErasureCompilerVisitor, MType, Array[RuntimeVariable]) */ -void nitc___nitc__SeparateErasureCompilerVisitor___nitc__abstract_compiler__AbstractCompilerVisitor__calloc_array(val* self, val* p0, val* p1) { -val* var_ret_type /* var ret_type: MType */; -val* var_arguments /* var arguments: Array[RuntimeVariable] */; -short int var /* : Bool */; -int cltype; -int idtype; -const char* var_class_name; -val* var_ret /* var ret: MClassType */; -val* var1 /* : NativeArray[String] */; -static val* varonce; -static val* varonce2; -val* var3 /* : String */; -char* var4 /* : NativeString */; -val* var5 /* : String */; -val* var6 /* : MClass */; -val* var8 /* : MClass */; -val* var9 /* : String */; -val* var10 /* : String */; -val* var12 /* : NativeArray[String] */; -static val* varonce11; -static val* varonce13; -val* var14 /* : String */; -char* var15 /* : NativeString */; -val* var16 /* : String */; -static val* varonce17; -val* var18 /* : String */; -char* var19 /* : NativeString */; -val* var20 /* : String */; -static val* varonce21; -val* var22 /* : String */; -char* var23 /* : NativeString */; -val* var24 /* : String */; -val* var25 /* : MClass */; -val* var27 /* : MClass */; -val* var28 /* : String */; -val* var29 /* : nullable Object */; -val* var30 /* : String */; -val* var31 /* : String */; -val* var32 /* : RuntimeVariable */; -var_ret_type = p0; -var_arguments = p1; -/* isa MClassType */ -cltype = type_nitc__MClassType.color; -idtype = type_nitc__MClassType.id; -if(cltype >= var_ret_type->type->table_size) { -var = 0; -} else { -var = var_ret_type->type->type_table[cltype] == idtype; -} -if (unlikely(!var)) { -var_class_name = var_ret_type == NULL ? "null" : var_ret_type->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__separate_erasure_compiler, 663); -fatal_exit(1); -} -var_ret = var_ret_type; -if (unlikely(varonce==NULL)) { -var1 = NEW_core__NativeArray(2l, &type_core__NativeArray__core__String); -if (likely(varonce2!=NULL)) { -var3 = varonce2; -} else { -var4 = "NEW_"; -var5 = core__flat___NativeString___to_s_full(var4, 4l, 4l); -var3 = var5; -varonce2 = var3; -} -((struct instance_core__NativeArray*)var1)->values[0]=var3; -} else { -var1 = varonce; -varonce = NULL; -} -{ -{ /* Inline model#MClassType#mclass (var_ret) on */ -var8 = var_ret->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var8 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); -fatal_exit(1); -} -var6 = var8; -RET_LABEL7:(void)0; -} -} -{ -var9 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var6); -} -((struct instance_core__NativeArray*)var1)->values[1]=var9; -{ -var10 = ((val*(*)(val* self))(var1->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var1); /* native_to_s on */ -} -varonce = var1; -{ -nitc___nitc__AbstractCompilerVisitor___require_declaration(self, var10); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ -} -if (unlikely(varonce11==NULL)) { -var12 = NEW_core__NativeArray(5l, &type_core__NativeArray__core__String); -if (likely(varonce13!=NULL)) { -var14 = varonce13; -} else { -var15 = "NEW_"; -var16 = core__flat___NativeString___to_s_full(var15, 4l, 4l); -var14 = var16; -varonce13 = var14; -} -((struct instance_core__NativeArray*)var12)->values[0]=var14; -if (likely(varonce17!=NULL)) { -var18 = varonce17; -} else { -var19 = "("; -var20 = core__flat___NativeString___to_s_full(var19, 1l, 1l); -var18 = var20; -varonce17 = var18; -} -((struct instance_core__NativeArray*)var12)->values[2]=var18; -if (likely(varonce21!=NULL)) { -var22 = varonce21; -} else { -var23 = ")"; -var24 = core__flat___NativeString___to_s_full(var23, 1l, 1l); -var22 = var24; -varonce21 = var22; -} -((struct instance_core__NativeArray*)var12)->values[4]=var22; -} else { -var12 = varonce11; -varonce11 = NULL; -} -{ -{ /* Inline model#MClassType#mclass (var_ret) on */ -var27 = var_ret->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var27 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1163); -fatal_exit(1); -} -var25 = var27; -RET_LABEL26:(void)0; -} -} -{ -var28 = nitc___nitc__MClass___nitc__model_base__MEntity__c_name(var25); -} -((struct instance_core__NativeArray*)var12)->values[1]=var28; -{ -var29 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var_arguments, 1l); -} -{ -var30 = ((val*(*)(val* self))(var29->class->vft[COLOR_core__abstract_text__Object__to_s]))(var29); /* to_s on */ -} -((struct instance_core__NativeArray*)var12)->values[3]=var30; -{ -var31 = ((val*(*)(val* self))(var12->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var12); /* native_to_s on */ -} -varonce11 = var12; -{ -var32 = nitc___nitc__AbstractCompilerVisitor___new_expr(self, var31, var_ret_type); -} -{ -nitc___nitc__AbstractCompilerVisitor___ret(self, var32); /* Direct call abstract_compiler#AbstractCompilerVisitor#ret on */ -} -RET_LABEL:; -}