From 444f04890e3f2920e10fc4ca3549a89a3d6e77ca Mon Sep 17 00:00:00 2001 From: Kristian Larsson Date: Tue, 11 Apr 2023 17:04:16 +0200 Subject: [PATCH] Add GC descriptors for builtin etc This adds GC descriptors for most of the C code we have checked in, like builtins and RTS. Mallocs have been turned into GC_MALLOC_EXPLICITLY_TYPED with a corresponding GC descriptor stored in the method table of the associated class. The GC descriptor is in turn based on a GC bitmap, which is of varying length and thus not suitable for placing directly in the method table. There are instead separate global variables, one per class. We initialize these structures a bit differently, so where there are static initializations the bitmap is currently initialized to 0, which is usually wrong as it indicates that the GC should not scan the object. For classes initialized with a method table, as the current code generated by actonc, we currently set it to 0xFF, as to indicate all bits should be scanned. The goal right now is just to add in the GC descriptors and start using them for allocations without breaking anything. We will start fiddling with the bits later on to speed things up. --- builtin/__builtin__.c | 1314 ++++++++++++++++------- builtin/__builtin__.h | 619 ++++++++--- builtin/atom.c | 1 + builtin/bool.h | 1 + builtin/builtin_functions.c | 15 +- builtin/builtin_functions.h | 20 +- builtin/class_hierarchy.c | 7 +- builtin/class_hierarchy.h | 12 +- builtin/complex.c | 5 + builtin/complx.h | 1 + builtin/dict.c | 11 +- builtin/dict.h | 13 +- builtin/env.c | 43 +- builtin/env.h | 20 +- builtin/float.c | 5 + builtin/float.h | 1 + builtin/function.c | 5 + builtin/function.h | 28 +- builtin/i16.h | 1 + builtin/i32.h | 1 + builtin/i64.h | 1 + builtin/int.c | 5 + builtin/int.h | 1 + builtin/list.c | 4 +- builtin/list.h | 5 +- builtin/none.c | 3 +- builtin/none.h | 4 +- builtin/range.c | 1 + builtin/range.h | 5 +- builtin/serialization_tests/ActorRing.c | 8 +- builtin/serialization_tests/ActorRing.h | 24 +- builtin/serialization_tests/graph.c | 12 +- builtin/serialization_tests/graph.h | 16 +- builtin/serialize.c | 1 + builtin/serialize.h | 8 +- builtin/set.c | 3 +- builtin/set.h | 5 +- builtin/slice.h | 1 + builtin/str.c | 9 +- builtin/str.h | 15 +- builtin/tests/Pingpong.c | 5 +- builtin/tests/Pingpong.h | 12 +- builtin/tuple.c | 7 +- builtin/tuple.h | 20 +- builtin/u16.h | 1 + builtin/u32.h | 1 + builtin/u64.h | 1 + rts/pingpong.c | 4 + rts/pingpong.h | 16 +- rts/rts.c | 43 +- rts/rts.h | 16 +- stdlib/c_src/numpy/ndarray.c | 4 +- stdlib/c_src/numpy/ndselect.c | 3 + stdlib/c_src/numpy/primitive.c | 6 +- stdlib/c_src/numpy/protocol_impls.c | 10 + stdlib/src/json.ext.c | 2 +- stdlib/src/math.c | 14 +- stdlib/src/math.h | 8 +- stdlib/src/numpy.h | 72 +- 59 files changed, 1758 insertions(+), 741 deletions(-) diff --git a/builtin/__builtin__.c b/builtin/__builtin__.c index 969e22fd3..bdcb37ee5 100644 --- a/builtin/__builtin__.c +++ b/builtin/__builtin__.c @@ -1,3 +1,4 @@ +#include "gc/gc_typed.h" /* Building project in /Users/sydow/acton/builtin/ty Compiling __builtin__.act for release in stub mode @@ -15,7 +16,7 @@ void B_valueD___serialize__ (B_value self, $Serial$state state) { B_value B_valueD___deserialize__ (B_value self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_value)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_value), B_valueG_methods.$GCdescr); self->$class = &B_valueG_methods; return self; } @@ -24,18 +25,19 @@ B_value B_valueD___deserialize__ (B_value self, $Serial$state state) { return self; } B_value B_valueG_new() { - B_value $tmp = malloc(sizeof(struct B_value)); + B_value $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_value), B_valueG_methods.$GCdescr); $tmp->$class = &B_valueG_methods; B_valueG_methods.__init__($tmp); return $tmp; } struct B_valueG_class B_valueG_methods; +GC_word B_valueD_gcbm[GC_BITMAP_SIZE(struct B_value)]; void B_objectD___serialize__ (B_object self, $Serial$state state) { } B_object B_objectD___deserialize__ (B_object self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_object)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_object), B_objectG_methods.$GCdescr); self->$class = &B_objectG_methods; return self; } @@ -44,18 +46,19 @@ B_object B_objectD___deserialize__ (B_object self, $Serial$state state) { return self; } B_object B_objectG_new() { - B_object $tmp = malloc(sizeof(struct B_object)); + B_object $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_object), B_objectG_methods.$GCdescr); $tmp->$class = &B_objectG_methods; B_objectG_methods.__init__($tmp); return $tmp; } struct B_objectG_class B_objectG_methods; +GC_word B_objectD_gcbm[GC_BITMAP_SIZE(struct B_object)]; void B_atomD___serialize__ (B_atom self, $Serial$state state) { } B_atom B_atomD___deserialize__ (B_atom self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_atom)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_atom), B_atomG_methods.$GCdescr); self->$class = &B_atomG_methods; return self; } @@ -65,13 +68,14 @@ B_atom B_atomD___deserialize__ (B_atom self, $Serial$state state) { } /* B_atom B_atomG_new() { - B_atom $tmp = malloc(sizeof(struct B_atom)); + B_atom $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_atom), B_atomG_methods.$GCdescr); $tmp->$class = &B_atomG_methods; B_atomG_methods.__init__($tmp); return $tmp; } */ struct B_atomG_class B_atomG_methods; +GC_word B_atomD_gcbm[GC_BITMAP_SIZE(struct B_atom)]; /* B_NoneType B_intD___init__ (B_int self, B_atom val); void B_intD___serialize__ (B_int self, $Serial$state state) { @@ -79,7 +83,7 @@ void B_intD___serialize__ (B_int self, $Serial$state state) { B_int B_intD___deserialize__ (B_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_int), B_intG_methods.$GCdescr); self->$class = &B_intG_methods; return self; } @@ -88,13 +92,14 @@ B_int B_intD___deserialize__ (B_int self, $Serial$state state) { return self; } B_int B_intG_new(B_atom G_1) { - B_int $tmp = malloc(sizeof(struct B_int)); + B_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_int), B_intG_methods.$GCdescr); $tmp->$class = &B_intG_methods; B_intG_methods.__init__($tmp, G_1); return $tmp; } */ struct B_intG_class B_intG_methods; +GC_word B_intD_gcbm[GC_BITMAP_SIZE(struct B_int)]; /* B_NoneType B_i64D___init__ (B_i64 self, B_atom val); void B_i64D___serialize__ (B_i64 self, $Serial$state state){ @@ -102,7 +107,7 @@ void B_i64D___serialize__ (B_i64 self, $Serial$state state){ B_i64 B_i64D___deserialize__ (B_i64 self, $Serial$state state); { if (!self) { if (!state) { - self = malloc(sizeof(struct B_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_i64), B_i64G_methods.$GCdescr); self->$class = &B_i64G_methods; return self; } @@ -111,18 +116,24 @@ B_i64 B_i64D___deserialize__ (B_i64 self, $Serial$state state); { return self; } B_i64 B_i64G_new(B_atom G_1) { - B_i64 $tmp = malloc(sizeof(struct B_i64)); + B_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_i64), B_i64G_methods.$GCdescr); $tmp->$class = &B_i64G_methods; B_i64G_methods.__init__($tmp, G_1); return $tmp; } */ struct B_i64G_class B_i64G_methods; +GC_word B_i64D_gcbm[GC_BITMAP_SIZE(struct B_i64)]; struct B_i32G_class B_i32G_methods; +GC_word B_i32D_gcbm[GC_BITMAP_SIZE(struct B_i32)]; struct B_i16G_class B_i16G_methods; +GC_word B_i16D_gcbm[GC_BITMAP_SIZE(struct B_i16)]; struct B_u64G_class B_u64G_methods; +GC_word B_u64D_gcbm[GC_BITMAP_SIZE(struct B_u64)]; struct B_u32G_class B_u32G_methods; +GC_word B_u32D_gcbm[GC_BITMAP_SIZE(struct B_u32)]; struct B_u16G_class B_u16G_methods; +GC_word B_u16D_gcbm[GC_BITMAP_SIZE(struct B_u16)]; /* B_NoneType B_floatD___init__ (B_float self, B_atom val); void B_floatD___serialize__ (B_float self, $Serial$state state) { @@ -130,7 +141,7 @@ void B_floatD___serialize__ (B_float self, $Serial$state state) { B_float B_floatD___deserialize__ (B_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_float), B_floatG_methods.$GCdescr); self->$class = &B_floatG_methods; return self; } @@ -139,13 +150,14 @@ B_float B_floatD___deserialize__ (B_float self, $Serial$state state) { return self; } B_float B_floatG_new(B_atom G_1) { - B_float $tmp = malloc(sizeof(struct B_float)); + B_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_float), B_floatG_methods.$GCdescr); $tmp->$class = &B_floatG_methods; B_floatG_methods.__init__($tmp, G_1); return $tmp; } */ struct B_floatG_class B_floatG_methods; +GC_word B_floatD_gcbm[GC_BITMAP_SIZE(struct B_float)]; /* B_NoneType B_boolD___init__ (B_bool self, B_value val); void B_boolD___serialize__ (B_bool self, $Serial$state state) { @@ -153,7 +165,7 @@ void B_boolD___serialize__ (B_bool self, $Serial$state state) { B_bool B_boolD___deserialize__ (B_bool self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_bool)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bool), B_boolG_methods.$GCdescr); self->$class = &B_boolG_methods; return self; } @@ -162,13 +174,14 @@ B_bool B_boolD___deserialize__ (B_bool self, $Serial$state state) { return self; } B_bool B_boolG_new(B_value G_1) { - B_bool $tmp = malloc(sizeof(struct B_bool)); + B_bool $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bool), B_boolG_methods.$GCdescr); $tmp->$class = &B_boolG_methods; B_boolG_methods.__init__($tmp, G_1); return $tmp; } */ struct B_boolG_class B_boolG_methods; +GC_word B_boolD_gcbm[GC_BITMAP_SIZE(struct B_bool)]; /* B_NoneType B_sliceD___init__ (B_slice self, B_int start, B_int stop, B_int step); void B_sliceD___serialize__ (B_slice self, $Serial$state state) { @@ -176,7 +189,7 @@ void B_sliceD___serialize__ (B_slice self, $Serial$state state) { B_slice B_sliceD___deserialize__ (B_slice self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_slice)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_slice), B_sliceG_methods.$GCdescr); self->$class = &B_sliceG_methods; return self; } @@ -185,13 +198,14 @@ B_slice B_sliceD___deserialize__ (B_slice self, $Serial$state state) { return self; } B_slice B_sliceG_new(B_int G_1, B_int G_2, B_int G_3) { - B_slice $tmp = malloc(sizeof(struct B_slice)); + B_slice $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_slice), B_sliceG_methods.$GCdescr); $tmp->$class = &B_sliceG_methods; B_sliceG_methods.__init__($tmp, G_1, G_2, G_3); return $tmp; } */ struct B_sliceG_class B_sliceG_methods; +GC_word B_sliceD_gcbm[GC_BITMAP_SIZE(struct B_slice)]; /* B_NoneType B_listD___init__ (B_list self, B_Iterable W_IterableE_62, $WORD val); B_list B_listD_copy (B_list self); @@ -200,7 +214,7 @@ void B_listD___serialize__ (B_list self, $Serial$state state) { B_list B_listD___deserialize__ (B_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_list), B_listG_methods.$GCdescr); self->$class = &B_listG_methods; return self; } @@ -209,13 +223,14 @@ B_list B_listD___deserialize__ (B_list self, $Serial$state state) { return self; } B_list B_listG_new(B_Iterable G_1, $WORD G_2) { - B_list $tmp = malloc(sizeof(struct B_list)); + B_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_list), B_listG_methods.$GCdescr); $tmp->$class = &B_listG_methods; B_listG_methods.__init__($tmp, G_1, G_2); return $tmp; } */ struct B_listG_class B_listG_methods; +GC_word B_listD_gcbm[GC_BITMAP_SIZE(struct B_list)]; /* B_NoneType B_rangeD___init__ (B_range self, B_int start, B_int stop, B_int step); void B_rangeD___serialize__ (B_range self, $Serial$state state) { @@ -223,7 +238,7 @@ void B_rangeD___serialize__ (B_range self, $Serial$state state) { B_range B_rangeD___deserialize__ (B_range self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_range)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_range), B_rangeG_methods.$GCdescr); self->$class = &B_rangeG_methods; return self; } @@ -232,19 +247,20 @@ B_range B_rangeD___deserialize__ (B_range self, $Serial$state state) { return self; } B_range B_rangeG_new(B_int G_1, B_int G_2, B_int G_3) { - B_range $tmp = malloc(sizeof(struct B_range)); + B_range $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_range), B_rangeG_methods.$GCdescr); $tmp->$class = &B_rangeG_methods; B_rangeG_methods.__init__($tmp, G_1, G_2, G_3); return $tmp; } */ struct B_rangeG_class B_rangeG_methods; +GC_word B_rangeD_gcbm[GC_BITMAP_SIZE(struct B_range)]; void B_IteratorD___serialize__ (B_Iterator self, $Serial$state state) { } B_Iterator B_IteratorD___deserialize__ (B_Iterator self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Iterator)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Iterator), B_IteratorG_methods.$GCdescr); self->$class = &B_IteratorG_methods; return self; } @@ -253,6 +269,7 @@ B_Iterator B_IteratorD___deserialize__ (B_Iterator self, $Serial$state state) { return self; } struct B_IteratorG_class B_IteratorG_methods; +GC_word B_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_Iterator)]; B_NoneType B_IterableD___init__ (B_Iterable W_self) { return B_None; } @@ -261,7 +278,7 @@ void B_IterableD___serialize__ (B_Iterable self, $Serial$state state) { B_Iterable B_IterableD___deserialize__ (B_Iterable self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Iterable)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Iterable), B_IterableG_methods.$GCdescr); self->$class = &B_IterableG_methods; return self; } @@ -270,6 +287,7 @@ B_Iterable B_IterableD___deserialize__ (B_Iterable self, $Serial$state state) { return self; } struct B_IterableG_class B_IterableG_methods; +GC_word B_IterableD_gcbm[GC_BITMAP_SIZE(struct B_Iterable)]; B_NoneType B_strD___init__ (B_str self, B_value val); B_str B_strD_capitalize (B_str self); B_str B_strD_center (B_str self, B_int width, B_str fillchar); @@ -311,7 +329,7 @@ void B_strD___serialize__ (B_str self, $Serial$state state) { B_str B_strD___deserialize__ (B_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_str), B_strG_methods.$GCdescr); self->$class = &B_strG_methods; return self; } @@ -320,13 +338,14 @@ B_str B_strD___deserialize__ (B_str self, $Serial$state state) { return self; } B_str B_strG_new(B_value G_1) { - B_str $tmp = malloc(sizeof(struct B_str)); + B_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_str), B_strG_methods.$GCdescr); $tmp->$class = &B_strG_methods; B_strG_methods.__init__($tmp, G_1); return $tmp; } */ struct B_strG_class B_strG_methods; +GC_word B_strD_gcbm[GC_BITMAP_SIZE(struct B_str)]; B_NoneType B_bytesD___init__ (B_bytes self, B_Iterable W_IterableE_226, $WORD iterable); B_bytes B_bytesD_capitalize (B_bytes self); B_bytes B_bytesD_center (B_bytes self, B_int width, B_bytes fillchar); @@ -367,7 +386,7 @@ void B_bytesD___serialize__ (B_bytes self, $Serial$state state) { B_bytes B_bytesD___deserialize__ (B_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytes), B_bytesG_methods.$GCdescr); self->$class = &B_bytesG_methods; return self; } @@ -376,13 +395,14 @@ B_bytes B_bytesD___deserialize__ (B_bytes self, $Serial$state state) { return self; } B_bytes B_bytesG_new(B_Iterable G_1, $WORD G_2) { - B_bytes $tmp = malloc(sizeof(struct B_bytes)); + B_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytes), B_bytesG_methods.$GCdescr); $tmp->$class = &B_bytesG_methods; B_bytesG_methods.__init__($tmp, G_1, G_2); return $tmp; } */ struct B_bytesG_class B_bytesG_methods; +GC_word B_bytesD_gcbm[GC_BITMAP_SIZE(struct B_bytes)]; B_NoneType B_bytearrayD___init__ (B_bytearray self, B_bytes val); B_bytearray B_bytearrayD_capitalize (B_bytearray self); B_bytearray B_bytearrayD_center (B_bytearray self, B_int width, B_bytearray fillchar); @@ -423,7 +443,7 @@ void B_bytearrayD___serialize__ (B_bytearray self, $Serial$state state) { B_bytearray B_bytearrayD___deserialize__ (B_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytearray), B_bytearrayG_methods.$GCdescr); self->$class = &B_bytearrayG_methods; return self; } @@ -432,20 +452,21 @@ B_bytearray B_bytearrayD___deserialize__ (B_bytearray self, $Serial$state state) return self; } B_bytearray B_bytearrayG_new(B_bytes G_1) { - B_bytearray $tmp = malloc(sizeof(struct B_bytearray)); + B_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytearray), B_bytearrayG_methods.$GCdescr); $tmp->$class = &B_bytearrayG_methods; B_bytearrayG_methods.__init__($tmp, G_1); return $tmp; } */ struct B_bytearrayG_class B_bytearrayG_methods; +GC_word B_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_bytearray)]; /* void B_MsgD___serialize__ (B_Msg self, $Serial$state state) { } B_Msg B_MsgD___deserialize__ (B_Msg self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Msg)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Msg), B_MsgG_methods.$GCdescr); self->$class = &B_MsgG_methods; return self; } @@ -454,12 +475,13 @@ B_Msg B_MsgD___deserialize__ (B_Msg self, $Serial$state state) { return self; } B_Msg B_MsgG_new() { - B_Msg $tmp = malloc(sizeof(struct B_Msg)); + B_Msg $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Msg), B_MsgG_methods.$GCdescr); $tmp->$class = &B_MsgG_methods; B_MsgG_methods.__init__($tmp); return $tmp; } struct B_MsgG_class B_MsgG_methods; +GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)]; */ B_NoneType B_BaseExceptionD___init__ (B_BaseException self, B_str msg) { self->error_message = msg; @@ -471,7 +493,7 @@ void B_BaseExceptionD___serialize__ (B_BaseException self, $Serial$state state) B_BaseException B_BaseExceptionD___deserialize__ (B_BaseException self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_BaseException)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_BaseException), B_BaseExceptionG_methods.$GCdescr); self->$class = &B_BaseExceptionG_methods; return self; } @@ -481,19 +503,20 @@ B_BaseException B_BaseExceptionD___deserialize__ (B_BaseException self, $Serial$ return self; } B_BaseException B_BaseExceptionG_new(B_str G_1) { - B_BaseException $tmp = malloc(sizeof(struct B_BaseException)); + B_BaseException $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_BaseException), B_BaseExceptionG_methods.$GCdescr); $tmp->$class = &B_BaseExceptionG_methods; B_BaseExceptionG_methods.__init__($tmp, G_1); return $tmp; } struct B_BaseExceptionG_class B_BaseExceptionG_methods; +GC_word B_BaseExceptionD_gcbm[GC_BITMAP_SIZE(struct B_BaseException)]; void B_SystemExitD___serialize__ (B_SystemExit self, $Serial$state state) { $step_serialize(self->error_message, state); } B_SystemExit B_SystemExitD___deserialize__ (B_SystemExit self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SystemExit)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SystemExit), B_SystemExitG_methods.$GCdescr); self->$class = &B_SystemExitG_methods; return self; } @@ -503,19 +526,20 @@ B_SystemExit B_SystemExitD___deserialize__ (B_SystemExit self, $Serial$state sta return self; } B_SystemExit B_SystemExitG_new(B_str G_1) { - B_SystemExit $tmp = malloc(sizeof(struct B_SystemExit)); + B_SystemExit $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SystemExit), B_SystemExitG_methods.$GCdescr); $tmp->$class = &B_SystemExitG_methods; B_SystemExitG_methods.__init__($tmp, G_1); return $tmp; } struct B_SystemExitG_class B_SystemExitG_methods; +GC_word B_SystemExitD_gcbm[GC_BITMAP_SIZE(struct B_SystemExit)]; void B_KeyboardInterruptD___serialize__ (B_KeyboardInterrupt self, $Serial$state state) { $step_serialize(self->error_message, state); } B_KeyboardInterrupt B_KeyboardInterruptD___deserialize__ (B_KeyboardInterrupt self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_KeyboardInterrupt)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyboardInterrupt), B_KeyboardInterruptG_methods.$GCdescr); self->$class = &B_KeyboardInterruptG_methods; return self; } @@ -525,19 +549,20 @@ B_KeyboardInterrupt B_KeyboardInterruptD___deserialize__ (B_KeyboardInterrupt se return self; } B_KeyboardInterrupt B_KeyboardInterruptG_new(B_str G_1) { - B_KeyboardInterrupt $tmp = malloc(sizeof(struct B_KeyboardInterrupt)); + B_KeyboardInterrupt $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyboardInterrupt), B_KeyboardInterruptG_methods.$GCdescr); $tmp->$class = &B_KeyboardInterruptG_methods; B_KeyboardInterruptG_methods.__init__($tmp, G_1); return $tmp; } struct B_KeyboardInterruptG_class B_KeyboardInterruptG_methods; +GC_word B_KeyboardInterruptD_gcbm[GC_BITMAP_SIZE(struct B_KeyboardInterrupt)]; void B_ExceptionD___serialize__ (B_Exception self, $Serial$state state) { $step_serialize(self->error_message, state); } B_Exception B_ExceptionD___deserialize__ (B_Exception self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Exception)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Exception), B_ExceptionG_methods.$GCdescr); self->$class = &B_ExceptionG_methods; return self; } @@ -547,19 +572,20 @@ B_Exception B_ExceptionD___deserialize__ (B_Exception self, $Serial$state state) return self; } B_Exception B_ExceptionG_new(B_str G_1) { - B_Exception $tmp = malloc(sizeof(struct B_Exception)); + B_Exception $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Exception), B_ExceptionG_methods.$GCdescr); $tmp->$class = &B_ExceptionG_methods; B_ExceptionG_methods.__init__($tmp, G_1); return $tmp; } struct B_ExceptionG_class B_ExceptionG_methods; +GC_word B_ExceptionD_gcbm[GC_BITMAP_SIZE(struct B_Exception)]; void B_AssertionErrorD___serialize__ (B_AssertionError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_AssertionError B_AssertionErrorD___deserialize__ (B_AssertionError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_AssertionError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_AssertionError), B_AssertionErrorG_methods.$GCdescr); self->$class = &B_AssertionErrorG_methods; return self; } @@ -569,19 +595,20 @@ B_AssertionError B_AssertionErrorD___deserialize__ (B_AssertionError self, $Seri return self; } B_AssertionError B_AssertionErrorG_new(B_str G_1) { - B_AssertionError $tmp = malloc(sizeof(struct B_AssertionError)); + B_AssertionError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_AssertionError), B_AssertionErrorG_methods.$GCdescr); $tmp->$class = &B_AssertionErrorG_methods; B_AssertionErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_AssertionErrorG_class B_AssertionErrorG_methods; +GC_word B_AssertionErrorD_gcbm[GC_BITMAP_SIZE(struct B_AssertionError)]; void B_LookupErrorD___serialize__ (B_LookupError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_LookupError B_LookupErrorD___deserialize__ (B_LookupError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LookupError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LookupError), B_LookupErrorG_methods.$GCdescr); self->$class = &B_LookupErrorG_methods; return self; } @@ -591,19 +618,20 @@ B_LookupError B_LookupErrorD___deserialize__ (B_LookupError self, $Serial$state return self; } B_LookupError B_LookupErrorG_new(B_str G_1) { - B_LookupError $tmp = malloc(sizeof(struct B_LookupError)); + B_LookupError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LookupError), B_LookupErrorG_methods.$GCdescr); $tmp->$class = &B_LookupErrorG_methods; B_LookupErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_LookupErrorG_class B_LookupErrorG_methods; +GC_word B_LookupErrorD_gcbm[GC_BITMAP_SIZE(struct B_LookupError)]; void B_IndexErrorD___serialize__ (B_IndexError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_IndexError B_IndexErrorD___deserialize__ (B_IndexError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IndexError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexError), B_IndexErrorG_methods.$GCdescr); self->$class = &B_IndexErrorG_methods; return self; } @@ -613,19 +641,20 @@ B_IndexError B_IndexErrorD___deserialize__ (B_IndexError self, $Serial$state sta return self; } B_IndexError B_IndexErrorG_new(B_str G_1) { - B_IndexError $tmp = malloc(sizeof(struct B_IndexError)); + B_IndexError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexError), B_IndexErrorG_methods.$GCdescr); $tmp->$class = &B_IndexErrorG_methods; B_IndexErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_IndexErrorG_class B_IndexErrorG_methods; +GC_word B_IndexErrorD_gcbm[GC_BITMAP_SIZE(struct B_IndexError)]; void B_KeyErrorD___serialize__ (B_KeyError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_KeyError B_KeyErrorD___deserialize__ (B_KeyError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_KeyError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyError), B_KeyErrorG_methods.$GCdescr); self->$class = &B_KeyErrorG_methods; return self; } @@ -635,19 +664,20 @@ B_KeyError B_KeyErrorD___deserialize__ (B_KeyError self, $Serial$state state) { return self; } B_KeyError B_KeyErrorG_new(B_str G_1) { - B_KeyError $tmp = malloc(sizeof(struct B_KeyError)); + B_KeyError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyError), B_KeyErrorG_methods.$GCdescr); $tmp->$class = &B_KeyErrorG_methods; B_KeyErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_KeyErrorG_class B_KeyErrorG_methods; +GC_word B_KeyErrorD_gcbm[GC_BITMAP_SIZE(struct B_KeyError)]; void B_MemoryErrorD___serialize__ (B_MemoryError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_MemoryError B_MemoryErrorD___deserialize__ (B_MemoryError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MemoryError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MemoryError), B_MemoryErrorG_methods.$GCdescr); self->$class = &B_MemoryErrorG_methods; return self; } @@ -657,19 +687,20 @@ B_MemoryError B_MemoryErrorD___deserialize__ (B_MemoryError self, $Serial$state return self; } B_MemoryError B_MemoryErrorG_new(B_str G_1) { - B_MemoryError $tmp = malloc(sizeof(struct B_MemoryError)); + B_MemoryError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MemoryError), B_MemoryErrorG_methods.$GCdescr); $tmp->$class = &B_MemoryErrorG_methods; B_MemoryErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_MemoryErrorG_class B_MemoryErrorG_methods; +GC_word B_MemoryErrorD_gcbm[GC_BITMAP_SIZE(struct B_MemoryError)]; void B_OSErrorD___serialize__ (B_OSError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_OSError B_OSErrorD___deserialize__ (B_OSError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OSError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OSError), B_OSErrorG_methods.$GCdescr); self->$class = &B_OSErrorG_methods; return self; } @@ -679,19 +710,20 @@ B_OSError B_OSErrorD___deserialize__ (B_OSError self, $Serial$state state) { return self; } B_OSError B_OSErrorG_new(B_str G_1) { - B_OSError $tmp = malloc(sizeof(struct B_OSError)); + B_OSError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OSError), B_OSErrorG_methods.$GCdescr); $tmp->$class = &B_OSErrorG_methods; B_OSErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_OSErrorG_class B_OSErrorG_methods; +GC_word B_OSErrorD_gcbm[GC_BITMAP_SIZE(struct B_OSError)]; void B_RuntimeErrorD___serialize__ (B_RuntimeError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_RuntimeError B_RuntimeErrorD___deserialize__ (B_RuntimeError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_RuntimeError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RuntimeError), B_RuntimeErrorG_methods.$GCdescr); self->$class = &B_RuntimeErrorG_methods; return self; } @@ -701,19 +733,20 @@ B_RuntimeError B_RuntimeErrorD___deserialize__ (B_RuntimeError self, $Serial$sta return self; } B_RuntimeError B_RuntimeErrorG_new(B_str G_1) { - B_RuntimeError $tmp = malloc(sizeof(struct B_RuntimeError)); + B_RuntimeError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RuntimeError), B_RuntimeErrorG_methods.$GCdescr); $tmp->$class = &B_RuntimeErrorG_methods; B_RuntimeErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_RuntimeErrorG_class B_RuntimeErrorG_methods; +GC_word B_RuntimeErrorD_gcbm[GC_BITMAP_SIZE(struct B_RuntimeError)]; void B_NotImplementedErrorD___serialize__ (B_NotImplementedError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_NotImplementedError B_NotImplementedErrorD___deserialize__ (B_NotImplementedError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_NotImplementedError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NotImplementedError), B_NotImplementedErrorG_methods.$GCdescr); self->$class = &B_NotImplementedErrorG_methods; return self; } @@ -723,19 +756,20 @@ B_NotImplementedError B_NotImplementedErrorD___deserialize__ (B_NotImplementedEr return self; } B_NotImplementedError B_NotImplementedErrorG_new(B_str G_1) { - B_NotImplementedError $tmp = malloc(sizeof(struct B_NotImplementedError)); + B_NotImplementedError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NotImplementedError), B_NotImplementedErrorG_methods.$GCdescr); $tmp->$class = &B_NotImplementedErrorG_methods; B_NotImplementedErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_NotImplementedErrorG_class B_NotImplementedErrorG_methods; +GC_word B_NotImplementedErrorD_gcbm[GC_BITMAP_SIZE(struct B_NotImplementedError)]; void B_ValueErrorD___serialize__ (B_ValueError self, $Serial$state state) { $step_serialize(self->error_message, state); } B_ValueError B_ValueErrorD___deserialize__ (B_ValueError self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_ValueError)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ValueError), B_ValueErrorG_methods.$GCdescr); self->$class = &B_ValueErrorG_methods; return self; } @@ -745,12 +779,13 @@ B_ValueError B_ValueErrorD___deserialize__ (B_ValueError self, $Serial$state sta return self; } B_ValueError B_ValueErrorG_new(B_str G_1) { - B_ValueError $tmp = malloc(sizeof(struct B_ValueError)); + B_ValueError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ValueError), B_ValueErrorG_methods.$GCdescr); $tmp->$class = &B_ValueErrorG_methods; B_ValueErrorG_methods.__init__($tmp, G_1); return $tmp; } struct B_ValueErrorG_class B_ValueErrorG_methods; +GC_word B_ValueErrorD_gcbm[GC_BITMAP_SIZE(struct B_ValueError)]; B_NoneType B_IdentityD___init__ (B_Identity W_self) { return B_None; } @@ -759,7 +794,7 @@ void B_IdentityD___serialize__ (B_Identity self, $Serial$state state) { B_Identity B_IdentityD___deserialize__ (B_Identity self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Identity)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Identity), B_IdentityG_methods.$GCdescr); self->$class = &B_IdentityG_methods; return self; } @@ -768,6 +803,7 @@ B_Identity B_IdentityD___deserialize__ (B_Identity self, $Serial$state state) { return self; } struct B_IdentityG_class B_IdentityG_methods; +GC_word B_IdentityD_gcbm[GC_BITMAP_SIZE(struct B_Identity)]; B_NoneType B_EqD___init__ (B_Eq W_self) { return B_None; } @@ -779,7 +815,7 @@ void B_EqD___serialize__ (B_Eq self, $Serial$state state) { B_Eq B_EqD___deserialize__ (B_Eq self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Eq)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Eq), B_EqG_methods.$GCdescr); self->$class = &B_EqG_methods; return self; } @@ -788,6 +824,7 @@ B_Eq B_EqD___deserialize__ (B_Eq self, $Serial$state state) { return self; } struct B_EqG_class B_EqG_methods; +GC_word B_EqD_gcbm[GC_BITMAP_SIZE(struct B_Eq)]; B_NoneType B_OrdD___init__ (B_Ord W_self) { ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self)); return B_None; @@ -806,7 +843,7 @@ void B_OrdD___serialize__ (B_Ord self, $Serial$state state) { B_Ord B_OrdD___deserialize__ (B_Ord self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Ord)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Ord), B_OrdG_methods.$GCdescr); self->$class = &B_OrdG_methods; return self; } @@ -815,6 +852,7 @@ B_Ord B_OrdD___deserialize__ (B_Ord self, $Serial$state state) { return self; } struct B_OrdG_class B_OrdG_methods; +GC_word B_OrdD_gcbm[GC_BITMAP_SIZE(struct B_Ord)]; B_NoneType B_LogicalD___init__ (B_Logical W_self) { return B_None; } @@ -832,7 +870,7 @@ void B_LogicalD___serialize__ (B_Logical self, $Serial$state state) { B_Logical B_LogicalD___deserialize__ (B_Logical self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Logical)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Logical), B_LogicalG_methods.$GCdescr); self->$class = &B_LogicalG_methods; return self; } @@ -841,6 +879,7 @@ B_Logical B_LogicalD___deserialize__ (B_Logical self, $Serial$state state) { return self; } struct B_LogicalG_class B_LogicalG_methods; +GC_word B_LogicalD_gcbm[GC_BITMAP_SIZE(struct B_Logical)]; B_NoneType B_PlusD___init__ (B_Plus W_self) { return B_None; } @@ -852,7 +891,7 @@ void B_PlusD___serialize__ (B_Plus self, $Serial$state state) { B_Plus B_PlusD___deserialize__ (B_Plus self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Plus)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Plus), B_PlusG_methods.$GCdescr); self->$class = &B_PlusG_methods; return self; } @@ -861,6 +900,7 @@ B_Plus B_PlusD___deserialize__ (B_Plus self, $Serial$state state) { return self; } struct B_PlusG_class B_PlusG_methods; +GC_word B_PlusD_gcbm[GC_BITMAP_SIZE(struct B_Plus)]; B_NoneType B_MinusD___init__ (B_Minus W_self) { return B_None; } @@ -872,7 +912,7 @@ void B_MinusD___serialize__ (B_Minus self, $Serial$state state) { B_Minus B_MinusD___deserialize__ (B_Minus self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Minus)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Minus), B_MinusG_methods.$GCdescr); self->$class = &B_MinusG_methods; return self; } @@ -881,6 +921,7 @@ B_Minus B_MinusD___deserialize__ (B_Minus self, $Serial$state state) { return self; } struct B_MinusG_class B_MinusG_methods; +GC_word B_MinusD_gcbm[GC_BITMAP_SIZE(struct B_Minus)]; B_NoneType B_TimesD___init__ (B_Times W_self) { ((B_NoneType (*) (B_Plus))B_PlusG_methods.__init__)(((B_Plus)W_self)); return B_None; @@ -893,7 +934,7 @@ void B_TimesD___serialize__ (B_Times self, $Serial$state state) { B_Times B_TimesD___deserialize__ (B_Times self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Times)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Times), B_TimesG_methods.$GCdescr); self->$class = &B_TimesG_methods; return self; } @@ -902,6 +943,7 @@ B_Times B_TimesD___deserialize__ (B_Times self, $Serial$state state) { return self; } struct B_TimesG_class B_TimesG_methods; +GC_word B_TimesD_gcbm[GC_BITMAP_SIZE(struct B_Times)]; B_NoneType B_DivD___init__ (B_Div W_self) { return B_None; } @@ -913,7 +955,7 @@ void B_DivD___serialize__ (B_Div self, $Serial$state state) { B_Div B_DivD___deserialize__ (B_Div self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Div)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Div), B_DivG_methods.$GCdescr); self->$class = &B_DivG_methods; return self; } @@ -922,6 +964,7 @@ B_Div B_DivD___deserialize__ (B_Div self, $Serial$state state) { return self; } struct B_DivG_class B_DivG_methods; +GC_word B_DivD_gcbm[GC_BITMAP_SIZE(struct B_Div)]; B_NoneType B_HashableD___init__ (B_Hashable W_self) { ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self)); return B_None; @@ -931,7 +974,7 @@ void B_HashableD___serialize__ (B_Hashable self, $Serial$state state) { B_Hashable B_HashableD___deserialize__ (B_Hashable self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Hashable)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Hashable), B_HashableG_methods.$GCdescr); self->$class = &B_HashableG_methods; return self; } @@ -940,6 +983,7 @@ B_Hashable B_HashableD___deserialize__ (B_Hashable self, $Serial$state state) { return self; } struct B_HashableG_class B_HashableG_methods; +GC_word B_HashableD_gcbm[GC_BITMAP_SIZE(struct B_Hashable)]; /* B_NoneType B_complexD___init__ (B_complex self, B_Number W_NumberE_604, $WORD val); void B_complexD___serialize__ (B_complex self, $Serial$state state) { @@ -947,7 +991,7 @@ void B_complexD___serialize__ (B_complex self, $Serial$state state) { B_complex B_complexD___deserialize__ (B_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_complex), B_complexG_methods.$GCdescr); self->$class = &B_complexG_methods; return self; } @@ -956,13 +1000,14 @@ B_complex B_complexD___deserialize__ (B_complex self, $Serial$state state) { return self; } B_complex B_complexG_new(B_Number G_1, $WORD G_2) { - B_complex $tmp = malloc(sizeof(struct B_complex)); + B_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_complex), B_complexG_methods.$GCdescr); $tmp->$class = &B_complexG_methods; B_complexG_methods.__init__($tmp, G_1, G_2); return $tmp; } */ struct B_complexG_class B_complexG_methods; +GC_word B_complexD_gcbm[GC_BITMAP_SIZE(struct B_complex)]; /* B_NoneType B_dictD___init__ (B_dict self, B_Hashable W_HashableD_A, B_Iterable W_IterableE_609, $WORD iterable); void B_dictD___serialize__ (B_dict self, $Serial$state state) { @@ -970,7 +1015,7 @@ void B_dictD___serialize__ (B_dict self, $Serial$state state) { B_dict B_dictD___deserialize__ (B_dict self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_dict)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_dict), B_dictG_methods.$GCdescr); self->$class = &B_dictG_methods; return self; } @@ -979,13 +1024,14 @@ B_dict B_dictD___deserialize__ (B_dict self, $Serial$state state) { return self; } B_dict B_dictG_new(B_Hashable G_1, B_Iterable G_2, $WORD G_3) { - B_dict $tmp = malloc(sizeof(struct B_dict)); + B_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_dict), B_dictG_methods.$GCdescr); $tmp->$class = &B_dictG_methods; B_dictG_methods.__init__($tmp, G_1, G_2, G_3); return $tmp; } */ struct B_dictG_class B_dictG_methods; +GC_word B_dictD_gcbm[GC_BITMAP_SIZE(struct B_dict)]; /* B_NoneType B_setD___init__ (B_set self, B_Hashable W_HashableD_A, B_Iterable W_IterableE_617, $WORD iterable); void B_setD___serialize__ (B_set self, $Serial$state state) { @@ -993,7 +1039,7 @@ void B_setD___serialize__ (B_set self, $Serial$state state) { B_set B_setD___deserialize__ (B_set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_set), B_setG_methods.$GCdescr); self->$class = &B_setG_methods; return self; } @@ -1002,13 +1048,14 @@ B_set B_setD___deserialize__ (B_set self, $Serial$state state) { return self; } B_set B_setG_new(B_Hashable G_1, B_Iterable G_2, $WORD G_3) { - B_set $tmp = malloc(sizeof(struct B_set)); + B_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_set), B_setG_methods.$GCdescr); $tmp->$class = &B_setG_methods; B_setG_methods.__init__($tmp, G_1, G_2, G_3); return $tmp; } */ struct B_setG_class B_setG_methods; +GC_word B_setD_gcbm[GC_BITMAP_SIZE(struct B_set)]; B_NoneType B_NumberD___init__ (B_Number W_self, B_Minus W_Minus) { ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self)); W_self->W_Minus = W_Minus; @@ -1023,7 +1070,7 @@ void B_NumberD___serialize__ (B_Number self, $Serial$state state) { B_Number B_NumberD___deserialize__ (B_Number self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Number)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Number), B_NumberG_methods.$GCdescr); self->$class = &B_NumberG_methods; return self; } @@ -1033,6 +1080,7 @@ B_Number B_NumberD___deserialize__ (B_Number self, $Serial$state state) { return self; } struct B_NumberG_class B_NumberG_methods; +GC_word B_NumberD_gcbm[GC_BITMAP_SIZE(struct B_Number)]; B_NoneType B_MinusD_NumberD___init__ (B_MinusD_Number W_self, B_Number W_Number) { ((B_NoneType (*) (B_Minus))B_MinusG_methods.__init__)(((B_Minus)W_self)); W_self->W_Number = W_Number; @@ -1044,7 +1092,7 @@ void B_MinusD_NumberD___serialize__ (B_MinusD_Number self, $Serial$state state) B_MinusD_Number B_MinusD_NumberD___deserialize__ (B_MinusD_Number self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_Number)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Number), B_MinusD_NumberG_methods.$GCdescr); self->$class = &B_MinusD_NumberG_methods; return self; } @@ -1054,6 +1102,7 @@ B_MinusD_Number B_MinusD_NumberD___deserialize__ (B_MinusD_Number self, $Serial$ return self; } struct B_MinusD_NumberG_class B_MinusD_NumberG_methods; +GC_word B_MinusD_NumberD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Number)]; B_NoneType B_RealD___init__ (B_Real W_self, B_Minus W_Minus) { ((B_NoneType (*) (B_Number, B_Minus))B_NumberG_methods.__init__)(((B_Number)W_self), W_Minus); return B_None; @@ -1064,7 +1113,7 @@ void B_RealD___serialize__ (B_Real self, $Serial$state state) { B_Real B_RealD___deserialize__ (B_Real self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Real)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Real), B_RealG_methods.$GCdescr); self->$class = &B_RealG_methods; return self; } @@ -1074,6 +1123,7 @@ B_Real B_RealD___deserialize__ (B_Real self, $Serial$state state) { return self; } struct B_RealG_class B_RealG_methods; +GC_word B_RealD_gcbm[GC_BITMAP_SIZE(struct B_Real)]; B_NoneType B_MinusD_RealD___init__ (B_MinusD_Real W_self, B_Real W_Real) { ((B_NoneType (*) (B_MinusD_Number, B_Number))B_MinusD_NumberG_methods.__init__)(((B_MinusD_Number)W_self), ((B_Number)W_Real)); W_self->W_Real = W_Real; @@ -1086,7 +1136,7 @@ void B_MinusD_RealD___serialize__ (B_MinusD_Real self, $Serial$state state) { B_MinusD_Real B_MinusD_RealD___deserialize__ (B_MinusD_Real self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_Real)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Real), B_MinusD_RealG_methods.$GCdescr); self->$class = &B_MinusD_RealG_methods; return self; } @@ -1097,6 +1147,7 @@ B_MinusD_Real B_MinusD_RealD___deserialize__ (B_MinusD_Real self, $Serial$state return self; } struct B_MinusD_RealG_class B_MinusD_RealG_methods; +GC_word B_MinusD_RealD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Real)]; B_NoneType B_RealFloatD___init__ (B_RealFloat W_self, B_Minus W_Minus) { ((B_NoneType (*) (B_Real, B_Minus))B_RealG_methods.__init__)(((B_Real)W_self), W_Minus); return B_None; @@ -1107,7 +1158,7 @@ void B_RealFloatD___serialize__ (B_RealFloat self, $Serial$state state) { B_RealFloat B_RealFloatD___deserialize__ (B_RealFloat self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_RealFloat)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloat), B_RealFloatG_methods.$GCdescr); self->$class = &B_RealFloatG_methods; return self; } @@ -1117,6 +1168,7 @@ B_RealFloat B_RealFloatD___deserialize__ (B_RealFloat self, $Serial$state state) return self; } struct B_RealFloatG_class B_RealFloatG_methods; +GC_word B_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloat)]; B_NoneType B_MinusD_RealFloatD___init__ (B_MinusD_RealFloat W_self, B_RealFloat W_RealFloat) { ((B_NoneType (*) (B_MinusD_Real, B_Real))B_MinusD_RealG_methods.__init__)(((B_MinusD_Real)W_self), ((B_Real)W_RealFloat)); W_self->W_RealFloat = W_RealFloat; @@ -1130,7 +1182,7 @@ void B_MinusD_RealFloatD___serialize__ (B_MinusD_RealFloat self, $Serial$state s B_MinusD_RealFloat B_MinusD_RealFloatD___deserialize__ (B_MinusD_RealFloat self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_RealFloat)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloat), B_MinusD_RealFloatG_methods.$GCdescr); self->$class = &B_MinusD_RealFloatG_methods; return self; } @@ -1142,6 +1194,7 @@ B_MinusD_RealFloat B_MinusD_RealFloatD___deserialize__ (B_MinusD_RealFloat self, return self; } struct B_MinusD_RealFloatG_class B_MinusD_RealFloatG_methods; +GC_word B_MinusD_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloat)]; B_NoneType B_RationalD___init__ (B_Rational W_self, B_Minus W_Minus) { ((B_NoneType (*) (B_Real, B_Minus))B_RealG_methods.__init__)(((B_Real)W_self), W_Minus); return B_None; @@ -1152,7 +1205,7 @@ void B_RationalD___serialize__ (B_Rational self, $Serial$state state) { B_Rational B_RationalD___deserialize__ (B_Rational self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Rational)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Rational), B_RationalG_methods.$GCdescr); self->$class = &B_RationalG_methods; return self; } @@ -1162,6 +1215,7 @@ B_Rational B_RationalD___deserialize__ (B_Rational self, $Serial$state state) { return self; } struct B_RationalG_class B_RationalG_methods; +GC_word B_RationalD_gcbm[GC_BITMAP_SIZE(struct B_Rational)]; B_NoneType B_MinusD_RationalD___init__ (B_MinusD_Rational W_self, B_Rational W_Rational) { ((B_NoneType (*) (B_MinusD_Real, B_Real))B_MinusD_RealG_methods.__init__)(((B_MinusD_Real)W_self), ((B_Real)W_Rational)); W_self->W_Rational = W_Rational; @@ -1175,7 +1229,7 @@ void B_MinusD_RationalD___serialize__ (B_MinusD_Rational self, $Serial$state sta B_MinusD_Rational B_MinusD_RationalD___deserialize__ (B_MinusD_Rational self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_Rational)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Rational), B_MinusD_RationalG_methods.$GCdescr); self->$class = &B_MinusD_RationalG_methods; return self; } @@ -1187,6 +1241,7 @@ B_MinusD_Rational B_MinusD_RationalD___deserialize__ (B_MinusD_Rational self, $S return self; } struct B_MinusD_RationalG_class B_MinusD_RationalG_methods; +GC_word B_MinusD_RationalD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Rational)]; B_NoneType B_IntegralD___init__ (B_Integral W_self, B_Minus W_Minus, B_Logical W_Logical) { ((B_NoneType (*) (B_Rational, B_Minus))B_RationalG_methods.__init__)(((B_Rational)W_self), W_Minus); W_self->W_Logical = W_Logical; @@ -1211,7 +1266,7 @@ void B_IntegralD___serialize__ (B_Integral self, $Serial$state state) { B_Integral B_IntegralD___deserialize__ (B_Integral self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Integral)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Integral), B_IntegralG_methods.$GCdescr); self->$class = &B_IntegralG_methods; return self; } @@ -1222,6 +1277,7 @@ B_Integral B_IntegralD___deserialize__ (B_Integral self, $Serial$state state) { return self; } struct B_IntegralG_class B_IntegralG_methods; +GC_word B_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_Integral)]; B_NoneType B_MinusD_IntegralD___init__ (B_MinusD_Integral W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Rational, B_Rational))B_MinusD_RationalG_methods.__init__)(((B_MinusD_Rational)W_self), ((B_Rational)W_Integral)); W_self->W_Integral = W_Integral; @@ -1236,7 +1292,7 @@ void B_MinusD_IntegralD___serialize__ (B_MinusD_Integral self, $Serial$state sta B_MinusD_Integral B_MinusD_IntegralD___deserialize__ (B_MinusD_Integral self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_Integral)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Integral), B_MinusD_IntegralG_methods.$GCdescr); self->$class = &B_MinusD_IntegralG_methods; return self; } @@ -1249,6 +1305,7 @@ B_MinusD_Integral B_MinusD_IntegralD___deserialize__ (B_MinusD_Integral self, $S return self; } struct B_MinusD_IntegralG_class B_MinusD_IntegralG_methods; +GC_word B_MinusD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Integral)]; B_NoneType B_LogicalD_IntegralD___init__ (B_LogicalD_Integral W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_Logical))B_LogicalG_methods.__init__)(((B_Logical)W_self)); W_self->W_Integral = W_Integral; @@ -1260,7 +1317,7 @@ void B_LogicalD_IntegralD___serialize__ (B_LogicalD_Integral self, $Serial$state B_LogicalD_Integral B_LogicalD_IntegralD___deserialize__ (B_LogicalD_Integral self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_Integral)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_Integral), B_LogicalD_IntegralG_methods.$GCdescr); self->$class = &B_LogicalD_IntegralG_methods; return self; } @@ -1270,6 +1327,7 @@ B_LogicalD_Integral B_LogicalD_IntegralD___deserialize__ (B_LogicalD_Integral se return self; } struct B_LogicalD_IntegralG_class B_LogicalD_IntegralG_methods; +GC_word B_LogicalD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Integral)]; B_NoneType B_HashableD_boolD___init__ (B_HashableD_bool W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -1281,7 +1339,7 @@ void B_HashableD_boolD___serialize__ (B_HashableD_bool self, $Serial$state state B_HashableD_bool B_HashableD_boolD___deserialize__ (B_HashableD_bool self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_bool)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bool), B_HashableD_boolG_methods.$GCdescr); self->$class = &B_HashableD_boolG_methods; return self; } @@ -1290,12 +1348,13 @@ B_HashableD_bool B_HashableD_boolD___deserialize__ (B_HashableD_bool self, $Seri return self; } B_HashableD_bool B_HashableD_boolG_new() { - B_HashableD_bool $tmp = malloc(sizeof(struct B_HashableD_bool)); + B_HashableD_bool $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bool), B_HashableD_boolG_methods.$GCdescr); $tmp->$class = &B_HashableD_boolG_methods; B_HashableD_boolG_methods.__init__($tmp); return $tmp; } struct B_HashableD_boolG_class B_HashableD_boolG_methods; +GC_word B_HashableD_boolD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bool)]; B_NoneType B_IntegralD_intD___init__ (B_IntegralD_int W_self) { ((B_NoneType (*) (B_Integral, B_Minus, B_Logical))B_IntegralG_methods.__init__)(((B_Integral)W_self), ((B_Minus)B_MinusD_IntegralD_intG_new(((B_Integral)W_self))), ((B_Logical)B_LogicalD_IntegralD_intG_new(((B_Integral)W_self)))); return B_None; @@ -1333,7 +1392,7 @@ void B_IntegralD_intD___serialize__ (B_IntegralD_int self, $Serial$state state) B_IntegralD_int B_IntegralD_intD___deserialize__ (B_IntegralD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_int), B_IntegralD_intG_methods.$GCdescr); self->$class = &B_IntegralD_intG_methods; return self; } @@ -1344,12 +1403,13 @@ B_IntegralD_int B_IntegralD_intD___deserialize__ (B_IntegralD_int self, $Serial$ return self; } B_IntegralD_int B_IntegralD_intG_new() { - B_IntegralD_int $tmp = malloc(sizeof(struct B_IntegralD_int)); + B_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_int), B_IntegralD_intG_methods.$GCdescr); $tmp->$class = &B_IntegralD_intG_methods; B_IntegralD_intG_methods.__init__($tmp); return $tmp; } struct B_IntegralD_intG_class B_IntegralD_intG_methods; +GC_word B_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_int)]; B_NoneType B_MinusD_IntegralD_intD___init__ (B_MinusD_IntegralD_int W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1364,7 +1424,7 @@ void B_MinusD_IntegralD_intD___serialize__ (B_MinusD_IntegralD_int self, $Serial B_MinusD_IntegralD_int B_MinusD_IntegralD_intD___deserialize__ (B_MinusD_IntegralD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_int), B_MinusD_IntegralD_intG_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_intG_methods; return self; } @@ -1377,12 +1437,13 @@ B_MinusD_IntegralD_int B_MinusD_IntegralD_intD___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_int B_MinusD_IntegralD_intG_new(B_Integral G_1) { - B_MinusD_IntegralD_int $tmp = malloc(sizeof(struct B_MinusD_IntegralD_int)); + B_MinusD_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_int), B_MinusD_IntegralD_intG_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_intG_methods; B_MinusD_IntegralD_intG_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_intG_class B_MinusD_IntegralD_intG_methods; +GC_word B_MinusD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_int)]; B_NoneType B_LogicalD_IntegralD_intD___init__ (B_LogicalD_IntegralD_int W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1396,7 +1457,7 @@ void B_LogicalD_IntegralD_intD___serialize__ (B_LogicalD_IntegralD_int self, $Se B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intD___deserialize__ (B_LogicalD_IntegralD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_int), B_LogicalD_IntegralD_intG_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_intG_methods; return self; } @@ -1406,12 +1467,13 @@ B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intD___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intG_new(B_Integral G_1) { - B_LogicalD_IntegralD_int $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_int)); + B_LogicalD_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_int), B_LogicalD_IntegralD_intG_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_intG_methods; B_LogicalD_IntegralD_intG_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_intG_class B_LogicalD_IntegralD_intG_methods; +GC_word B_LogicalD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_int)]; B_NoneType B_DivD_intD___init__ (B_DivD_int W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -1422,7 +1484,7 @@ void B_DivD_intD___serialize__ (B_DivD_int self, $Serial$state state) { B_DivD_int B_DivD_intD___deserialize__ (B_DivD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_int), B_DivD_intG_methods.$GCdescr); self->$class = &B_DivD_intG_methods; return self; } @@ -1431,12 +1493,13 @@ B_DivD_int B_DivD_intD___deserialize__ (B_DivD_int self, $Serial$state state) { return self; } B_DivD_int B_DivD_intG_new() { - B_DivD_int $tmp = malloc(sizeof(struct B_DivD_int)); + B_DivD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_int), B_DivD_intG_methods.$GCdescr); $tmp->$class = &B_DivD_intG_methods; B_DivD_intG_methods.__init__($tmp); return $tmp; } struct B_DivD_intG_class B_DivD_intG_methods; +GC_word B_DivD_intD_gcbm[GC_BITMAP_SIZE(struct B_DivD_int)]; B_NoneType B_OrdD_intD___init__ (B_OrdD_int W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -1448,7 +1511,7 @@ void B_OrdD_intD___serialize__ (B_OrdD_int self, $Serial$state state) { B_OrdD_int B_OrdD_intD___deserialize__ (B_OrdD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_int), B_OrdD_intG_methods.$GCdescr); self->$class = &B_OrdD_intG_methods; return self; } @@ -1457,12 +1520,13 @@ B_OrdD_int B_OrdD_intD___deserialize__ (B_OrdD_int self, $Serial$state state) { return self; } B_OrdD_int B_OrdD_intG_new() { - B_OrdD_int $tmp = malloc(sizeof(struct B_OrdD_int)); + B_OrdD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_int), B_OrdD_intG_methods.$GCdescr); $tmp->$class = &B_OrdD_intG_methods; B_OrdD_intG_methods.__init__($tmp); return $tmp; } struct B_OrdD_intG_class B_OrdD_intG_methods; +GC_word B_OrdD_intD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_int)]; B_NoneType B_HashableD_intD___init__ (B_HashableD_int W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -1473,7 +1537,7 @@ void B_HashableD_intD___serialize__ (B_HashableD_int self, $Serial$state state) B_HashableD_int B_HashableD_intD___deserialize__ (B_HashableD_int self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_int)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_int), B_HashableD_intG_methods.$GCdescr); self->$class = &B_HashableD_intG_methods; return self; } @@ -1485,6 +1549,7 @@ B_HashableD_int B_HashableD_intG_new() { // manually added return $NEW(B_HashableD_int); // } // struct B_HashableD_intG_class B_HashableD_intG_methods; +GC_word B_HashableD_intD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_int)]; @@ -1534,7 +1599,7 @@ void B_IntegralD_i64D___serialize__ (B_IntegralD_i64 self, $Serial$state state) B_IntegralD_i64 B_IntegralD_i64D___deserialize__ (B_IntegralD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i64), B_IntegralD_i64G_methods.$GCdescr); self->$class = &B_IntegralD_i64G_methods; return self; } @@ -1545,12 +1610,13 @@ B_IntegralD_i64 B_IntegralD_i64D___deserialize__ (B_IntegralD_i64 self, $Serial$ return self; } B_IntegralD_i64 B_IntegralD_i64G_new() { - B_IntegralD_i64 $tmp = malloc(sizeof(struct B_IntegralD_i64)); + B_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i64), B_IntegralD_i64G_methods.$GCdescr); $tmp->$class = &B_IntegralD_i64G_methods; B_IntegralD_i64G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_i64G_class B_IntegralD_i64G_methods; +GC_word B_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i64)]; B_NoneType B_MinusD_IntegralD_i64D___init__ (B_MinusD_IntegralD_i64 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1565,7 +1631,7 @@ void B_MinusD_IntegralD_i64D___serialize__ (B_MinusD_IntegralD_i64 self, $Serial B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64D___deserialize__ (B_MinusD_IntegralD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i64), B_MinusD_IntegralD_i64G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_i64G_methods; return self; } @@ -1578,12 +1644,13 @@ B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64G_new(B_Integral G_1) { - B_MinusD_IntegralD_i64 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i64)); + B_MinusD_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i64), B_MinusD_IntegralD_i64G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_i64G_methods; B_MinusD_IntegralD_i64G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_i64G_class B_MinusD_IntegralD_i64G_methods; +GC_word B_MinusD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i64)]; B_NoneType B_LogicalD_IntegralD_i64D___init__ (B_LogicalD_IntegralD_i64 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1597,7 +1664,7 @@ void B_LogicalD_IntegralD_i64D___serialize__ (B_LogicalD_IntegralD_i64 self, $Se B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64D___deserialize__ (B_LogicalD_IntegralD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i64), B_LogicalD_IntegralD_i64G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_i64G_methods; return self; } @@ -1607,12 +1674,13 @@ B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64G_new(B_Integral G_1) { - B_LogicalD_IntegralD_i64 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i64)); + B_LogicalD_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i64), B_LogicalD_IntegralD_i64G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_i64G_methods; B_LogicalD_IntegralD_i64G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_i64G_class B_LogicalD_IntegralD_i64G_methods; +GC_word B_LogicalD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i64)]; B_NoneType B_DivD_i64D___init__ (B_DivD_i64 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -1623,7 +1691,7 @@ void B_DivD_i64D___serialize__ (B_DivD_i64 self, $Serial$state state) { B_DivD_i64 B_DivD_i64D___deserialize__ (B_DivD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i64), B_DivD_i64G_methods.$GCdescr); self->$class = &B_DivD_i64G_methods; return self; } @@ -1632,12 +1700,13 @@ B_DivD_i64 B_DivD_i64D___deserialize__ (B_DivD_i64 self, $Serial$state state) { return self; } B_DivD_i64 B_DivD_i64G_new() { - B_DivD_i64 $tmp = malloc(sizeof(struct B_DivD_i64)); + B_DivD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i64), B_DivD_i64G_methods.$GCdescr); $tmp->$class = &B_DivD_i64G_methods; B_DivD_i64G_methods.__init__($tmp); return $tmp; } struct B_DivD_i64G_class B_DivD_i64G_methods; +GC_word B_DivD_i64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i64)]; B_NoneType B_OrdD_i64D___init__ (B_OrdD_i64 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -1649,7 +1718,7 @@ void B_OrdD_i64D___serialize__ (B_OrdD_i64 self, $Serial$state state) { B_OrdD_i64 B_OrdD_i64D___deserialize__ (B_OrdD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i64), B_OrdD_i64G_methods.$GCdescr); self->$class = &B_OrdD_i64G_methods; return self; } @@ -1658,12 +1727,13 @@ B_OrdD_i64 B_OrdD_i64D___deserialize__ (B_OrdD_i64 self, $Serial$state state) { return self; } B_OrdD_i64 B_OrdD_i64G_new() { - B_OrdD_i64 $tmp = malloc(sizeof(struct B_OrdD_i64)); + B_OrdD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i64), B_OrdD_i64G_methods.$GCdescr); $tmp->$class = &B_OrdD_i64G_methods; B_OrdD_i64G_methods.__init__($tmp); return $tmp; } struct B_OrdD_i64G_class B_OrdD_i64G_methods; +GC_word B_OrdD_i64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i64)]; B_NoneType B_HashableD_i64D___init__ (B_HashableD_i64 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -1674,7 +1744,7 @@ void B_HashableD_i64D___serialize__ (B_HashableD_i64 self, $Serial$state state) B_HashableD_i64 B_HashableD_i64D___deserialize__ (B_HashableD_i64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_i64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i64), B_HashableD_i64G_methods.$GCdescr); self->$class = &B_HashableD_i64G_methods; return self; } @@ -1686,6 +1756,7 @@ B_HashableD_i64 B_HashableD_i64G_new() { // manually added return $NEW(B_HashableD_i64); // } // struct B_HashableD_i64G_class B_HashableD_i64G_methods; +GC_word B_HashableD_i64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i64)]; @@ -1734,7 +1805,7 @@ void B_IntegralD_i32D___serialize__ (B_IntegralD_i32 self, $Serial$state state) B_IntegralD_i32 B_IntegralD_i32D___deserialize__ (B_IntegralD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i32), B_IntegralD_i32G_methods.$GCdescr); self->$class = &B_IntegralD_i32G_methods; return self; } @@ -1745,12 +1816,13 @@ B_IntegralD_i32 B_IntegralD_i32D___deserialize__ (B_IntegralD_i32 self, $Serial$ return self; } B_IntegralD_i32 B_IntegralD_i32G_new() { - B_IntegralD_i32 $tmp = malloc(sizeof(struct B_IntegralD_i32)); + B_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i32), B_IntegralD_i32G_methods.$GCdescr); $tmp->$class = &B_IntegralD_i32G_methods; B_IntegralD_i32G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_i32G_class B_IntegralD_i32G_methods; +GC_word B_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i32)]; B_NoneType B_MinusD_IntegralD_i32D___init__ (B_MinusD_IntegralD_i32 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1765,7 +1837,7 @@ void B_MinusD_IntegralD_i32D___serialize__ (B_MinusD_IntegralD_i32 self, $Serial B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32D___deserialize__ (B_MinusD_IntegralD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i32), B_MinusD_IntegralD_i32G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_i32G_methods; return self; } @@ -1778,12 +1850,13 @@ B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32G_new(B_Integral G_1) { - B_MinusD_IntegralD_i32 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i32)); + B_MinusD_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i32), B_MinusD_IntegralD_i32G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_i32G_methods; B_MinusD_IntegralD_i32G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_i32G_class B_MinusD_IntegralD_i32G_methods; +GC_word B_MinusD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i32)]; B_NoneType B_LogicalD_IntegralD_i32D___init__ (B_LogicalD_IntegralD_i32 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1797,7 +1870,7 @@ void B_LogicalD_IntegralD_i32D___serialize__ (B_LogicalD_IntegralD_i32 self, $Se B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32D___deserialize__ (B_LogicalD_IntegralD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i32), B_LogicalD_IntegralD_i32G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_i32G_methods; return self; } @@ -1807,12 +1880,13 @@ B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32G_new(B_Integral G_1) { - B_LogicalD_IntegralD_i32 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i32)); + B_LogicalD_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i32), B_LogicalD_IntegralD_i32G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_i32G_methods; B_LogicalD_IntegralD_i32G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_i32G_class B_LogicalD_IntegralD_i32G_methods; +GC_word B_LogicalD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i32)]; B_NoneType B_DivD_i32D___init__ (B_DivD_i32 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -1823,7 +1897,7 @@ void B_DivD_i32D___serialize__ (B_DivD_i32 self, $Serial$state state) { B_DivD_i32 B_DivD_i32D___deserialize__ (B_DivD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i32), B_DivD_i32G_methods.$GCdescr); self->$class = &B_DivD_i32G_methods; return self; } @@ -1832,12 +1906,13 @@ B_DivD_i32 B_DivD_i32D___deserialize__ (B_DivD_i32 self, $Serial$state state) { return self; } B_DivD_i32 B_DivD_i32G_new() { - B_DivD_i32 $tmp = malloc(sizeof(struct B_DivD_i32)); + B_DivD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i32), B_DivD_i32G_methods.$GCdescr); $tmp->$class = &B_DivD_i32G_methods; B_DivD_i32G_methods.__init__($tmp); return $tmp; } struct B_DivD_i32G_class B_DivD_i32G_methods; +GC_word B_DivD_i32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i32)]; B_NoneType B_OrdD_i32D___init__ (B_OrdD_i32 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -1849,7 +1924,7 @@ void B_OrdD_i32D___serialize__ (B_OrdD_i32 self, $Serial$state state) { B_OrdD_i32 B_OrdD_i32D___deserialize__ (B_OrdD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i32), B_OrdD_i32G_methods.$GCdescr); self->$class = &B_OrdD_i32G_methods; return self; } @@ -1858,12 +1933,13 @@ B_OrdD_i32 B_OrdD_i32D___deserialize__ (B_OrdD_i32 self, $Serial$state state) { return self; } B_OrdD_i32 B_OrdD_i32G_new() { - B_OrdD_i32 $tmp = malloc(sizeof(struct B_OrdD_i32)); + B_OrdD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i32), B_OrdD_i32G_methods.$GCdescr); $tmp->$class = &B_OrdD_i32G_methods; B_OrdD_i32G_methods.__init__($tmp); return $tmp; } struct B_OrdD_i32G_class B_OrdD_i32G_methods; +GC_word B_OrdD_i32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i32)]; B_NoneType B_HashableD_i32D___init__ (B_HashableD_i32 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -1874,7 +1950,7 @@ void B_HashableD_i32D___serialize__ (B_HashableD_i32 self, $Serial$state state) B_HashableD_i32 B_HashableD_i32D___deserialize__ (B_HashableD_i32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_i32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i32), B_HashableD_i32G_methods.$GCdescr); self->$class = &B_HashableD_i32G_methods; return self; } @@ -1886,6 +1962,7 @@ B_HashableD_i32 B_HashableD_i32G_new() { // manually added return $NEW(B_HashableD_i32); // } // struct B_HashableD_i32G_class B_HashableD_i32G_methods; +GC_word B_HashableD_i32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i32)]; @@ -1934,7 +2011,7 @@ void B_IntegralD_i16D___serialize__ (B_IntegralD_i16 self, $Serial$state state) B_IntegralD_i16 B_IntegralD_i16D___deserialize__ (B_IntegralD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i16), B_IntegralD_i16G_methods.$GCdescr); self->$class = &B_IntegralD_i16G_methods; return self; } @@ -1945,12 +2022,13 @@ B_IntegralD_i16 B_IntegralD_i16D___deserialize__ (B_IntegralD_i16 self, $Serial$ return self; } B_IntegralD_i16 B_IntegralD_i16G_new() { - B_IntegralD_i16 $tmp = malloc(sizeof(struct B_IntegralD_i16)); + B_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i16), B_IntegralD_i16G_methods.$GCdescr); $tmp->$class = &B_IntegralD_i16G_methods; B_IntegralD_i16G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_i16G_class B_IntegralD_i16G_methods; +GC_word B_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i16)]; B_NoneType B_MinusD_IntegralD_i16D___init__ (B_MinusD_IntegralD_i16 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1965,7 +2043,7 @@ void B_MinusD_IntegralD_i16D___serialize__ (B_MinusD_IntegralD_i16 self, $Serial B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16D___deserialize__ (B_MinusD_IntegralD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i16), B_MinusD_IntegralD_i16G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_i16G_methods; return self; } @@ -1978,12 +2056,13 @@ B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16G_new(B_Integral G_1) { - B_MinusD_IntegralD_i16 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i16)); + B_MinusD_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i16), B_MinusD_IntegralD_i16G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_i16G_methods; B_MinusD_IntegralD_i16G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_i16G_class B_MinusD_IntegralD_i16G_methods; +GC_word B_MinusD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i16)]; B_NoneType B_LogicalD_IntegralD_i16D___init__ (B_LogicalD_IntegralD_i16 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -1997,7 +2076,7 @@ void B_LogicalD_IntegralD_i16D___serialize__ (B_LogicalD_IntegralD_i16 self, $Se B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16D___deserialize__ (B_LogicalD_IntegralD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i16), B_LogicalD_IntegralD_i16G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_i16G_methods; return self; } @@ -2007,12 +2086,13 @@ B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16G_new(B_Integral G_1) { - B_LogicalD_IntegralD_i16 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i16)); + B_LogicalD_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i16), B_LogicalD_IntegralD_i16G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_i16G_methods; B_LogicalD_IntegralD_i16G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_i16G_class B_LogicalD_IntegralD_i16G_methods; +GC_word B_LogicalD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i16)]; B_NoneType B_DivD_i16D___init__ (B_DivD_i16 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2023,7 +2103,7 @@ void B_DivD_i16D___serialize__ (B_DivD_i16 self, $Serial$state state) { B_DivD_i16 B_DivD_i16D___deserialize__ (B_DivD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i16), B_DivD_i16G_methods.$GCdescr); self->$class = &B_DivD_i16G_methods; return self; } @@ -2032,12 +2112,13 @@ B_DivD_i16 B_DivD_i16D___deserialize__ (B_DivD_i16 self, $Serial$state state) { return self; } B_DivD_i16 B_DivD_i16G_new() { - B_DivD_i16 $tmp = malloc(sizeof(struct B_DivD_i16)); + B_DivD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i16), B_DivD_i16G_methods.$GCdescr); $tmp->$class = &B_DivD_i16G_methods; B_DivD_i16G_methods.__init__($tmp); return $tmp; } struct B_DivD_i16G_class B_DivD_i16G_methods; +GC_word B_DivD_i16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i16)]; B_NoneType B_OrdD_i16D___init__ (B_OrdD_i16 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -2049,7 +2130,7 @@ void B_OrdD_i16D___serialize__ (B_OrdD_i16 self, $Serial$state state) { B_OrdD_i16 B_OrdD_i16D___deserialize__ (B_OrdD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i16), B_OrdD_i16G_methods.$GCdescr); self->$class = &B_OrdD_i16G_methods; return self; } @@ -2058,12 +2139,13 @@ B_OrdD_i16 B_OrdD_i16D___deserialize__ (B_OrdD_i16 self, $Serial$state state) { return self; } B_OrdD_i16 B_OrdD_i16G_new() { - B_OrdD_i16 $tmp = malloc(sizeof(struct B_OrdD_i16)); + B_OrdD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i16), B_OrdD_i16G_methods.$GCdescr); $tmp->$class = &B_OrdD_i16G_methods; B_OrdD_i16G_methods.__init__($tmp); return $tmp; } struct B_OrdD_i16G_class B_OrdD_i16G_methods; +GC_word B_OrdD_i16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i16)]; B_NoneType B_HashableD_i16D___init__ (B_HashableD_i16 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2074,7 +2156,7 @@ void B_HashableD_i16D___serialize__ (B_HashableD_i16 self, $Serial$state state) B_HashableD_i16 B_HashableD_i16D___deserialize__ (B_HashableD_i16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_i16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i16), B_HashableD_i16G_methods.$GCdescr); self->$class = &B_HashableD_i16G_methods; return self; } @@ -2086,6 +2168,7 @@ B_HashableD_i16 B_HashableD_i16G_new() { // manually added return $NEW(B_HashableD_i16); // } // struct B_HashableD_i16G_class B_HashableD_i16G_methods; +GC_word B_HashableD_i16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i16)]; @@ -2135,7 +2218,7 @@ void B_IntegralD_u64D___serialize__ (B_IntegralD_u64 self, $Serial$state state) B_IntegralD_u64 B_IntegralD_u64D___deserialize__ (B_IntegralD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u64), B_IntegralD_u64G_methods.$GCdescr); self->$class = &B_IntegralD_u64G_methods; return self; } @@ -2146,12 +2229,13 @@ B_IntegralD_u64 B_IntegralD_u64D___deserialize__ (B_IntegralD_u64 self, $Serial$ return self; } B_IntegralD_u64 B_IntegralD_u64G_new() { - B_IntegralD_u64 $tmp = malloc(sizeof(struct B_IntegralD_u64)); + B_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u64), B_IntegralD_u64G_methods.$GCdescr); $tmp->$class = &B_IntegralD_u64G_methods; B_IntegralD_u64G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_u64G_class B_IntegralD_u64G_methods; +GC_word B_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u64)]; B_NoneType B_MinusD_IntegralD_u64D___init__ (B_MinusD_IntegralD_u64 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2166,7 +2250,7 @@ void B_MinusD_IntegralD_u64D___serialize__ (B_MinusD_IntegralD_u64 self, $Serial B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64D___deserialize__ (B_MinusD_IntegralD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u64), B_MinusD_IntegralD_u64G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_u64G_methods; return self; } @@ -2179,12 +2263,13 @@ B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64G_new(B_Integral G_1) { - B_MinusD_IntegralD_u64 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u64)); + B_MinusD_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u64), B_MinusD_IntegralD_u64G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_u64G_methods; B_MinusD_IntegralD_u64G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_u64G_class B_MinusD_IntegralD_u64G_methods; +GC_word B_MinusD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u64)]; B_NoneType B_LogicalD_IntegralD_u64D___init__ (B_LogicalD_IntegralD_u64 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2198,7 +2283,7 @@ void B_LogicalD_IntegralD_u64D___serialize__ (B_LogicalD_IntegralD_u64 self, $Se B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64D___deserialize__ (B_LogicalD_IntegralD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u64), B_LogicalD_IntegralD_u64G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_u64G_methods; return self; } @@ -2208,12 +2293,13 @@ B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64G_new(B_Integral G_1) { - B_LogicalD_IntegralD_u64 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u64)); + B_LogicalD_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u64), B_LogicalD_IntegralD_u64G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_u64G_methods; B_LogicalD_IntegralD_u64G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_u64G_class B_LogicalD_IntegralD_u64G_methods; +GC_word B_LogicalD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u64)]; B_NoneType B_DivD_u64D___init__ (B_DivD_u64 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2224,7 +2310,7 @@ void B_DivD_u64D___serialize__ (B_DivD_u64 self, $Serial$state state) { B_DivD_u64 B_DivD_u64D___deserialize__ (B_DivD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u64), B_DivD_u64G_methods.$GCdescr); self->$class = &B_DivD_u64G_methods; return self; } @@ -2236,12 +2322,13 @@ B_HashableD_u64 B_HashableD_u64G_new() { // manually added return $NEW(B_HashableD_u64); // } // B_DivD_u64 B_DivD_u64G_new() { - B_DivD_u64 $tmp = malloc(sizeof(struct B_DivD_u64)); + B_DivD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u64), B_DivD_u64G_methods.$GCdescr); $tmp->$class = &B_DivD_u64G_methods; B_DivD_u64G_methods.__init__($tmp); return $tmp; } struct B_DivD_u64G_class B_DivD_u64G_methods; +GC_word B_DivD_u64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u64)]; B_NoneType B_OrdD_u64D___init__ (B_OrdD_u64 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -2253,7 +2340,7 @@ void B_OrdD_u64D___serialize__ (B_OrdD_u64 self, $Serial$state state) { B_OrdD_u64 B_OrdD_u64D___deserialize__ (B_OrdD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u64), B_OrdD_u64G_methods.$GCdescr); self->$class = &B_OrdD_u64G_methods; return self; } @@ -2262,12 +2349,13 @@ B_OrdD_u64 B_OrdD_u64D___deserialize__ (B_OrdD_u64 self, $Serial$state state) { return self; } B_OrdD_u64 B_OrdD_u64G_new() { - B_OrdD_u64 $tmp = malloc(sizeof(struct B_OrdD_u64)); + B_OrdD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u64), B_OrdD_u64G_methods.$GCdescr); $tmp->$class = &B_OrdD_u64G_methods; B_OrdD_u64G_methods.__init__($tmp); return $tmp; } struct B_OrdD_u64G_class B_OrdD_u64G_methods; +GC_word B_OrdD_u64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u64)]; B_NoneType B_HashableD_u64D___init__ (B_HashableD_u64 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2278,7 +2366,7 @@ void B_HashableD_u64D___serialize__ (B_HashableD_u64 self, $Serial$state state) B_HashableD_u64 B_HashableD_u64D___deserialize__ (B_HashableD_u64 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_u64)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u64), B_HashableD_u64G_methods.$GCdescr); self->$class = &B_HashableD_u64G_methods; return self; } @@ -2287,6 +2375,7 @@ B_HashableD_u64 B_HashableD_u64D___deserialize__ (B_HashableD_u64 self, $Serial$ return self; } struct B_HashableD_u64G_class B_HashableD_u64G_methods; +GC_word B_HashableD_u64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u64)]; @@ -2334,7 +2423,7 @@ void B_IntegralD_u32D___serialize__ (B_IntegralD_u32 self, $Serial$state state) B_IntegralD_u32 B_IntegralD_u32D___deserialize__ (B_IntegralD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u32), B_IntegralD_u32G_methods.$GCdescr); self->$class = &B_IntegralD_u32G_methods; return self; } @@ -2345,12 +2434,13 @@ B_IntegralD_u32 B_IntegralD_u32D___deserialize__ (B_IntegralD_u32 self, $Serial$ return self; } B_IntegralD_u32 B_IntegralD_u32G_new() { - B_IntegralD_u32 $tmp = malloc(sizeof(struct B_IntegralD_u32)); + B_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u32), B_IntegralD_u32G_methods.$GCdescr); $tmp->$class = &B_IntegralD_u32G_methods; B_IntegralD_u32G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_u32G_class B_IntegralD_u32G_methods; +GC_word B_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u32)]; B_NoneType B_MinusD_IntegralD_u32D___init__ (B_MinusD_IntegralD_u32 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2365,7 +2455,7 @@ void B_MinusD_IntegralD_u32D___serialize__ (B_MinusD_IntegralD_u32 self, $Serial B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32D___deserialize__ (B_MinusD_IntegralD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u32), B_MinusD_IntegralD_u32G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_u32G_methods; return self; } @@ -2378,12 +2468,13 @@ B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32G_new(B_Integral G_1) { - B_MinusD_IntegralD_u32 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u32)); + B_MinusD_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u32), B_MinusD_IntegralD_u32G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_u32G_methods; B_MinusD_IntegralD_u32G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_u32G_class B_MinusD_IntegralD_u32G_methods; +GC_word B_MinusD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u32)]; B_NoneType B_LogicalD_IntegralD_u32D___init__ (B_LogicalD_IntegralD_u32 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2397,7 +2488,7 @@ void B_LogicalD_IntegralD_u32D___serialize__ (B_LogicalD_IntegralD_u32 self, $Se B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32D___deserialize__ (B_LogicalD_IntegralD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u32), B_LogicalD_IntegralD_u32G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_u32G_methods; return self; } @@ -2407,12 +2498,13 @@ B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32G_new(B_Integral G_1) { - B_LogicalD_IntegralD_u32 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u32)); + B_LogicalD_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u32), B_LogicalD_IntegralD_u32G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_u32G_methods; B_LogicalD_IntegralD_u32G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_u32G_class B_LogicalD_IntegralD_u32G_methods; +GC_word B_LogicalD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u32)]; B_NoneType B_DivD_u32D___init__ (B_DivD_u32 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2423,7 +2515,7 @@ void B_DivD_u32D___serialize__ (B_DivD_u32 self, $Serial$state state) { B_DivD_u32 B_DivD_u32D___deserialize__ (B_DivD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u32), B_DivD_u32G_methods.$GCdescr); self->$class = &B_DivD_u32G_methods; return self; } @@ -2432,12 +2524,13 @@ B_DivD_u32 B_DivD_u32D___deserialize__ (B_DivD_u32 self, $Serial$state state) { return self; } B_DivD_u32 B_DivD_u32G_new() { - B_DivD_u32 $tmp = malloc(sizeof(struct B_DivD_u32)); + B_DivD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u32), B_DivD_u32G_methods.$GCdescr); $tmp->$class = &B_DivD_u32G_methods; B_DivD_u32G_methods.__init__($tmp); return $tmp; } struct B_DivD_u32G_class B_DivD_u32G_methods; +GC_word B_DivD_u32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u32)]; B_NoneType B_OrdD_u32D___init__ (B_OrdD_u32 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -2449,7 +2542,7 @@ void B_OrdD_u32D___serialize__ (B_OrdD_u32 self, $Serial$state state) { B_OrdD_u32 B_OrdD_u32D___deserialize__ (B_OrdD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u32), B_OrdD_u32G_methods.$GCdescr); self->$class = &B_OrdD_u32G_methods; return self; } @@ -2458,12 +2551,13 @@ B_OrdD_u32 B_OrdD_u32D___deserialize__ (B_OrdD_u32 self, $Serial$state state) { return self; } B_OrdD_u32 B_OrdD_u32G_new() { - B_OrdD_u32 $tmp = malloc(sizeof(struct B_OrdD_u32)); + B_OrdD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u32), B_OrdD_u32G_methods.$GCdescr); $tmp->$class = &B_OrdD_u32G_methods; B_OrdD_u32G_methods.__init__($tmp); return $tmp; } struct B_OrdD_u32G_class B_OrdD_u32G_methods; +GC_word B_OrdD_u32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u32)]; B_NoneType B_HashableD_u32D___init__ (B_HashableD_u32 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2474,7 +2568,7 @@ void B_HashableD_u32D___serialize__ (B_HashableD_u32 self, $Serial$state state) B_HashableD_u32 B_HashableD_u32D___deserialize__ (B_HashableD_u32 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_u32)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u32), B_HashableD_u32G_methods.$GCdescr); self->$class = &B_HashableD_u32G_methods; return self; } @@ -2486,6 +2580,7 @@ B_HashableD_u32 B_HashableD_u32G_new() { // manually added return $NEW(B_HashableD_u32); // } // struct B_HashableD_u32G_class B_HashableD_u32G_methods; +GC_word B_HashableD_u32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u32)]; @@ -2534,7 +2629,7 @@ void B_IntegralD_u16D___serialize__ (B_IntegralD_u16 self, $Serial$state state) B_IntegralD_u16 B_IntegralD_u16D___deserialize__ (B_IntegralD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IntegralD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u16), B_IntegralD_u16G_methods.$GCdescr); self->$class = &B_IntegralD_u16G_methods; return self; } @@ -2545,12 +2640,13 @@ B_IntegralD_u16 B_IntegralD_u16D___deserialize__ (B_IntegralD_u16 self, $Serial$ return self; } B_IntegralD_u16 B_IntegralD_u16G_new() { - B_IntegralD_u16 $tmp = malloc(sizeof(struct B_IntegralD_u16)); + B_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u16), B_IntegralD_u16G_methods.$GCdescr); $tmp->$class = &B_IntegralD_u16G_methods; B_IntegralD_u16G_methods.__init__($tmp); return $tmp; } struct B_IntegralD_u16G_class B_IntegralD_u16G_methods; +GC_word B_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u16)]; B_NoneType B_MinusD_IntegralD_u16D___init__ (B_MinusD_IntegralD_u16 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2565,7 +2661,7 @@ void B_MinusD_IntegralD_u16D___serialize__ (B_MinusD_IntegralD_u16 self, $Serial B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16D___deserialize__ (B_MinusD_IntegralD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_IntegralD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u16), B_MinusD_IntegralD_u16G_methods.$GCdescr); self->$class = &B_MinusD_IntegralD_u16G_methods; return self; } @@ -2578,12 +2674,13 @@ B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16D___deserialize__ (B_MinusD_Integra return self; } B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16G_new(B_Integral G_1) { - B_MinusD_IntegralD_u16 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u16)); + B_MinusD_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u16), B_MinusD_IntegralD_u16G_methods.$GCdescr); $tmp->$class = &B_MinusD_IntegralD_u16G_methods; B_MinusD_IntegralD_u16G_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_IntegralD_u16G_class B_MinusD_IntegralD_u16G_methods; +GC_word B_MinusD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u16)]; B_NoneType B_LogicalD_IntegralD_u16D___init__ (B_LogicalD_IntegralD_u16 W_self, B_Integral W_Integral) { ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral)); return B_None; @@ -2597,7 +2694,7 @@ void B_LogicalD_IntegralD_u16D___serialize__ (B_LogicalD_IntegralD_u16 self, $Se B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16D___deserialize__ (B_LogicalD_IntegralD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_IntegralD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u16), B_LogicalD_IntegralD_u16G_methods.$GCdescr); self->$class = &B_LogicalD_IntegralD_u16G_methods; return self; } @@ -2607,12 +2704,13 @@ B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16D___deserialize__ (B_LogicalD_I return self; } B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16G_new(B_Integral G_1) { - B_LogicalD_IntegralD_u16 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u16)); + B_LogicalD_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u16), B_LogicalD_IntegralD_u16G_methods.$GCdescr); $tmp->$class = &B_LogicalD_IntegralD_u16G_methods; B_LogicalD_IntegralD_u16G_methods.__init__($tmp, G_1); return $tmp; } struct B_LogicalD_IntegralD_u16G_class B_LogicalD_IntegralD_u16G_methods; +GC_word B_LogicalD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u16)]; B_NoneType B_DivD_u16D___init__ (B_DivD_u16 W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2623,7 +2721,7 @@ void B_DivD_u16D___serialize__ (B_DivD_u16 self, $Serial$state state) { B_DivD_u16 B_DivD_u16D___deserialize__ (B_DivD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u16), B_DivD_u16G_methods.$GCdescr); self->$class = &B_DivD_u16G_methods; return self; } @@ -2632,12 +2730,13 @@ B_DivD_u16 B_DivD_u16D___deserialize__ (B_DivD_u16 self, $Serial$state state) { return self; } B_DivD_u16 B_DivD_u16G_new() { - B_DivD_u16 $tmp = malloc(sizeof(struct B_DivD_u16)); + B_DivD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u16), B_DivD_u16G_methods.$GCdescr); $tmp->$class = &B_DivD_u16G_methods; B_DivD_u16G_methods.__init__($tmp); return $tmp; } struct B_DivD_u16G_class B_DivD_u16G_methods; +GC_word B_DivD_u16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u16)]; B_NoneType B_OrdD_u16D___init__ (B_OrdD_u16 W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -2649,7 +2748,7 @@ void B_OrdD_u16D___serialize__ (B_OrdD_u16 self, $Serial$state state) { B_OrdD_u16 B_OrdD_u16D___deserialize__ (B_OrdD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u16), B_OrdD_u16G_methods.$GCdescr); self->$class = &B_OrdD_u16G_methods; return self; } @@ -2658,12 +2757,13 @@ B_OrdD_u16 B_OrdD_u16D___deserialize__ (B_OrdD_u16 self, $Serial$state state) { return self; } B_OrdD_u16 B_OrdD_u16G_new() { - B_OrdD_u16 $tmp = malloc(sizeof(struct B_OrdD_u16)); + B_OrdD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u16), B_OrdD_u16G_methods.$GCdescr); $tmp->$class = &B_OrdD_u16G_methods; B_OrdD_u16G_methods.__init__($tmp); return $tmp; } struct B_OrdD_u16G_class B_OrdD_u16G_methods; +GC_word B_OrdD_u16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u16)]; B_NoneType B_HashableD_u16D___init__ (B_HashableD_u16 W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2674,7 +2774,7 @@ void B_HashableD_u16D___serialize__ (B_HashableD_u16 self, $Serial$state state) B_HashableD_u16 B_HashableD_u16D___deserialize__ (B_HashableD_u16 self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_u16)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u16), B_HashableD_u16G_methods.$GCdescr); self->$class = &B_HashableD_u16G_methods; return self; } @@ -2686,6 +2786,7 @@ B_HashableD_u16 B_HashableD_u16G_new() { // manually added return $NEW(B_HashableD_u16); // } // struct B_HashableD_u16G_class B_HashableD_u16G_methods; +GC_word B_HashableD_u16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u16)]; @@ -2724,7 +2825,7 @@ void B_RealFloatD_floatD___serialize__ (B_RealFloatD_float self, $Serial$state s B_RealFloatD_float B_RealFloatD_floatD___deserialize__ (B_RealFloatD_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_RealFloatD_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloatD_float), B_RealFloatD_floatG_methods.$GCdescr); self->$class = &B_RealFloatD_floatG_methods; return self; } @@ -2734,12 +2835,13 @@ B_RealFloatD_float B_RealFloatD_floatD___deserialize__ (B_RealFloatD_float self, return self; } B_RealFloatD_float B_RealFloatD_floatG_new() { - B_RealFloatD_float $tmp = malloc(sizeof(struct B_RealFloatD_float)); + B_RealFloatD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloatD_float), B_RealFloatD_floatG_methods.$GCdescr); $tmp->$class = &B_RealFloatD_floatG_methods; B_RealFloatD_floatG_methods.__init__($tmp); return $tmp; } struct B_RealFloatD_floatG_class B_RealFloatD_floatG_methods; +GC_word B_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloatD_float)]; B_NoneType B_MinusD_RealFloatD_floatD___init__ (B_MinusD_RealFloatD_float W_self, B_RealFloat W_RealFloat) { ((B_NoneType (*) (B_MinusD_RealFloat, B_RealFloat))B_MinusD_RealFloatG_methods.__init__)(((B_MinusD_RealFloat)W_self), ((B_RealFloat)W_RealFloat)); return B_None; @@ -2753,7 +2855,7 @@ void B_MinusD_RealFloatD_floatD___serialize__ (B_MinusD_RealFloatD_float self, $ B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatD___deserialize__ (B_MinusD_RealFloatD_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_RealFloatD_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloatD_float), B_MinusD_RealFloatD_floatG_methods.$GCdescr); self->$class = &B_MinusD_RealFloatD_floatG_methods; return self; } @@ -2765,12 +2867,13 @@ B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatD___deserialize__ (B_MinusD_R return self; } B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatG_new(B_RealFloat G_1) { - B_MinusD_RealFloatD_float $tmp = malloc(sizeof(struct B_MinusD_RealFloatD_float)); + B_MinusD_RealFloatD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloatD_float), B_MinusD_RealFloatD_floatG_methods.$GCdescr); $tmp->$class = &B_MinusD_RealFloatD_floatG_methods; B_MinusD_RealFloatD_floatG_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_RealFloatD_floatG_class B_MinusD_RealFloatD_floatG_methods; +GC_word B_MinusD_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloatD_float)]; B_NoneType B_DivD_floatD___init__ (B_DivD_float W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2781,7 +2884,7 @@ void B_DivD_floatD___serialize__ (B_DivD_float self, $Serial$state state) { B_DivD_float B_DivD_floatD___deserialize__ (B_DivD_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_float), B_DivD_floatG_methods.$GCdescr); self->$class = &B_DivD_floatG_methods; return self; } @@ -2790,12 +2893,13 @@ B_DivD_float B_DivD_floatD___deserialize__ (B_DivD_float self, $Serial$state sta return self; } B_DivD_float B_DivD_floatG_new() { - B_DivD_float $tmp = malloc(sizeof(struct B_DivD_float)); + B_DivD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_float), B_DivD_floatG_methods.$GCdescr); $tmp->$class = &B_DivD_floatG_methods; B_DivD_floatG_methods.__init__($tmp); return $tmp; } struct B_DivD_floatG_class B_DivD_floatG_methods; +GC_word B_DivD_floatD_gcbm[GC_BITMAP_SIZE(struct B_DivD_float)]; B_NoneType B_OrdD_floatD___init__ (B_OrdD_float W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -2807,7 +2911,7 @@ void B_OrdD_floatD___serialize__ (B_OrdD_float self, $Serial$state state) { B_OrdD_float B_OrdD_floatD___deserialize__ (B_OrdD_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_float), B_OrdD_floatG_methods.$GCdescr); self->$class = &B_OrdD_floatG_methods; return self; } @@ -2816,12 +2920,13 @@ B_OrdD_float B_OrdD_floatD___deserialize__ (B_OrdD_float self, $Serial$state sta return self; } B_OrdD_float B_OrdD_floatG_new() { - B_OrdD_float $tmp = malloc(sizeof(struct B_OrdD_float)); + B_OrdD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_float), B_OrdD_floatG_methods.$GCdescr); $tmp->$class = &B_OrdD_floatG_methods; B_OrdD_floatG_methods.__init__($tmp); return $tmp; } struct B_OrdD_floatG_class B_OrdD_floatG_methods; +GC_word B_OrdD_floatD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_float)]; B_NoneType B_HashableD_floatD___init__ (B_HashableD_float W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2832,7 +2937,7 @@ void B_HashableD_floatD___serialize__ (B_HashableD_float self, $Serial$state sta B_HashableD_float B_HashableD_floatD___deserialize__ (B_HashableD_float self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_float)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_float), B_HashableD_floatG_methods.$GCdescr); self->$class = &B_HashableD_floatG_methods; return self; } @@ -2841,6 +2946,7 @@ B_HashableD_float B_HashableD_floatD___deserialize__ (B_HashableD_float self, $S return self; } struct B_HashableD_floatG_class B_HashableD_floatG_methods; +GC_word B_HashableD_floatD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_float)]; B_NoneType B_NumberD_complexD___init__ (B_NumberD_complex W_self) { ((B_NoneType (*) (B_Number, B_Minus))B_NumberG_methods.__init__)(((B_Number)W_self), ((B_Minus)B_MinusD_NumberD_complexG_new(((B_Number)W_self)))); return B_None; @@ -2862,7 +2968,7 @@ void B_NumberD_complexD___serialize__ (B_NumberD_complex self, $Serial$state sta B_NumberD_complex B_NumberD_complexD___deserialize__ (B_NumberD_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_NumberD_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NumberD_complex), B_NumberD_complexG_methods.$GCdescr); self->$class = &B_NumberD_complexG_methods; return self; } @@ -2872,12 +2978,13 @@ B_NumberD_complex B_NumberD_complexD___deserialize__ (B_NumberD_complex self, $S return self; } B_NumberD_complex B_NumberD_complexG_new() { - B_NumberD_complex $tmp = malloc(sizeof(struct B_NumberD_complex)); + B_NumberD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NumberD_complex), B_NumberD_complexG_methods.$GCdescr); $tmp->$class = &B_NumberD_complexG_methods; B_NumberD_complexG_methods.__init__($tmp); return $tmp; } struct B_NumberD_complexG_class B_NumberD_complexG_methods; +GC_word B_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_NumberD_complex)]; B_NoneType B_MinusD_NumberD_complexD___init__ (B_MinusD_NumberD_complex W_self, B_Number W_Number) { ((B_NoneType (*) (B_MinusD_Number, B_Number))B_MinusD_NumberG_methods.__init__)(((B_MinusD_Number)W_self), ((B_Number)W_Number)); return B_None; @@ -2889,7 +2996,7 @@ void B_MinusD_NumberD_complexD___serialize__ (B_MinusD_NumberD_complex self, $Se B_MinusD_NumberD_complex B_MinusD_NumberD_complexD___deserialize__ (B_MinusD_NumberD_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_NumberD_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_NumberD_complex), B_MinusD_NumberD_complexG_methods.$GCdescr); self->$class = &B_MinusD_NumberD_complexG_methods; return self; } @@ -2899,12 +3006,13 @@ B_MinusD_NumberD_complex B_MinusD_NumberD_complexD___deserialize__ (B_MinusD_Num return self; } B_MinusD_NumberD_complex B_MinusD_NumberD_complexG_new(B_Number G_1) { - B_MinusD_NumberD_complex $tmp = malloc(sizeof(struct B_MinusD_NumberD_complex)); + B_MinusD_NumberD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_NumberD_complex), B_MinusD_NumberD_complexG_methods.$GCdescr); $tmp->$class = &B_MinusD_NumberD_complexG_methods; B_MinusD_NumberD_complexG_methods.__init__($tmp, G_1); return $tmp; } struct B_MinusD_NumberD_complexG_class B_MinusD_NumberD_complexG_methods; +GC_word B_MinusD_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_NumberD_complex)]; B_NoneType B_DivD_complexD___init__ (B_DivD_complex W_self) { ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self)); return B_None; @@ -2915,7 +3023,7 @@ void B_DivD_complexD___serialize__ (B_DivD_complex self, $Serial$state state) { B_DivD_complex B_DivD_complexD___deserialize__ (B_DivD_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_DivD_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_complex), B_DivD_complexG_methods.$GCdescr); self->$class = &B_DivD_complexG_methods; return self; } @@ -2924,12 +3032,13 @@ B_DivD_complex B_DivD_complexD___deserialize__ (B_DivD_complex self, $Serial$sta return self; } B_DivD_complex B_DivD_complexG_new() { - B_DivD_complex $tmp = malloc(sizeof(struct B_DivD_complex)); + B_DivD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_complex), B_DivD_complexG_methods.$GCdescr); $tmp->$class = &B_DivD_complexG_methods; B_DivD_complexG_methods.__init__($tmp); return $tmp; } struct B_DivD_complexG_class B_DivD_complexG_methods; +GC_word B_DivD_complexD_gcbm[GC_BITMAP_SIZE(struct B_DivD_complex)]; B_NoneType B_EqD_complexD___init__ (B_EqD_complex W_self) { ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self)); return B_None; @@ -2940,7 +3049,7 @@ void B_EqD_complexD___serialize__ (B_EqD_complex self, $Serial$state state) { B_EqD_complex B_EqD_complexD___deserialize__ (B_EqD_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_EqD_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_EqD_complex), B_EqD_complexG_methods.$GCdescr); self->$class = &B_EqD_complexG_methods; return self; } @@ -2949,12 +3058,13 @@ B_EqD_complex B_EqD_complexD___deserialize__ (B_EqD_complex self, $Serial$state return self; } B_EqD_complex B_EqD_complexG_new() { - B_EqD_complex $tmp = malloc(sizeof(struct B_EqD_complex)); + B_EqD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_EqD_complex), B_EqD_complexG_methods.$GCdescr); $tmp->$class = &B_EqD_complexG_methods; B_EqD_complexG_methods.__init__($tmp); return $tmp; } struct B_EqD_complexG_class B_EqD_complexG_methods; +GC_word B_EqD_complexD_gcbm[GC_BITMAP_SIZE(struct B_EqD_complex)]; B_NoneType B_HashableD_complexD___init__ (B_HashableD_complex W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -2965,7 +3075,7 @@ void B_HashableD_complexD___serialize__ (B_HashableD_complex self, $Serial$state B_HashableD_complex B_HashableD_complexD___deserialize__ (B_HashableD_complex self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_complex)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_complex), B_HashableD_complexG_methods.$GCdescr); self->$class = &B_HashableD_complexG_methods; return self; } @@ -2974,6 +3084,7 @@ B_HashableD_complex B_HashableD_complexD___deserialize__ (B_HashableD_complex se return self; } struct B_HashableD_complexG_class B_HashableD_complexG_methods; +GC_word B_HashableD_complexD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_complex)]; B_NoneType B_IndexedD___init__ (B_Indexed W_self, B_Eq W_EqD_A) { W_self->W_EqD_AD_Indexed = W_EqD_A; return B_None; @@ -2984,7 +3095,7 @@ void B_IndexedD___serialize__ (B_Indexed self, $Serial$state state) { B_Indexed B_IndexedD___deserialize__ (B_Indexed self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Indexed)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Indexed), B_IndexedG_methods.$GCdescr); self->$class = &B_IndexedG_methods; return self; } @@ -2994,6 +3105,7 @@ B_Indexed B_IndexedD___deserialize__ (B_Indexed self, $Serial$state state) { return self; } struct B_IndexedG_class B_IndexedG_methods; +GC_word B_IndexedD_gcbm[GC_BITMAP_SIZE(struct B_Indexed)]; B_NoneType B_SliceableD___init__ (B_Sliceable W_self) { B_Eq W_333 = ((B_Eq)B_OrdD_intG_new()); ((B_NoneType (*) (B_Indexed, B_Eq))B_IndexedG_methods.__init__)(((B_Indexed)W_self), W_333); @@ -3005,7 +3117,7 @@ void B_SliceableD___serialize__ (B_Sliceable self, $Serial$state state) { B_Sliceable B_SliceableD___deserialize__ (B_Sliceable self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Sliceable)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Sliceable), B_SliceableG_methods.$GCdescr); self->$class = &B_SliceableG_methods; return self; } @@ -3015,6 +3127,7 @@ B_Sliceable B_SliceableD___deserialize__ (B_Sliceable self, $Serial$state state) return self; } struct B_SliceableG_class B_SliceableG_methods; +GC_word B_SliceableD_gcbm[GC_BITMAP_SIZE(struct B_Sliceable)]; B_NoneType B_CollectionD___init__ (B_Collection W_self) { ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self)); return B_None; @@ -3024,7 +3137,7 @@ void B_CollectionD___serialize__ (B_Collection self, $Serial$state state) { B_Collection B_CollectionD___deserialize__ (B_Collection self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Collection)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Collection), B_CollectionG_methods.$GCdescr); self->$class = &B_CollectionG_methods; return self; } @@ -3033,6 +3146,7 @@ B_Collection B_CollectionD___deserialize__ (B_Collection self, $Serial$state sta return self; } struct B_CollectionG_class B_CollectionG_methods; +GC_word B_CollectionD_gcbm[GC_BITMAP_SIZE(struct B_Collection)]; B_NoneType B_ContainerD___init__ (B_Container W_self, B_Eq W_EqD_A) { ((B_NoneType (*) (B_Collection))B_CollectionG_methods.__init__)(((B_Collection)W_self)); W_self->W_EqD_AD_Container = W_EqD_A; @@ -3044,7 +3158,7 @@ void B_ContainerD___serialize__ (B_Container self, $Serial$state state) { B_Container B_ContainerD___deserialize__ (B_Container self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Container)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Container), B_ContainerG_methods.$GCdescr); self->$class = &B_ContainerG_methods; return self; } @@ -3054,6 +3168,7 @@ B_Container B_ContainerD___deserialize__ (B_Container self, $Serial$state state) return self; } struct B_ContainerG_class B_ContainerG_methods; +GC_word B_ContainerD_gcbm[GC_BITMAP_SIZE(struct B_Container)]; B_NoneType B_SequenceD___init__ (B_Sequence W_self, B_Collection W_Collection, B_Times W_Times) { ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self)); W_self->W_Collection = W_Collection; @@ -3068,7 +3183,7 @@ void B_SequenceD___serialize__ (B_Sequence self, $Serial$state state) { B_Sequence B_SequenceD___deserialize__ (B_Sequence self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Sequence)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Sequence), B_SequenceG_methods.$GCdescr); self->$class = &B_SequenceG_methods; return self; } @@ -3080,6 +3195,7 @@ B_Sequence B_SequenceD___deserialize__ (B_Sequence self, $Serial$state state) { return self; } struct B_SequenceG_class B_SequenceG_methods; +GC_word B_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_Sequence)]; B_NoneType B_CollectionD_SequenceD___init__ (B_CollectionD_Sequence W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_Collection))B_CollectionG_methods.__init__)(((B_Collection)W_self)); W_self->W_Sequence = W_Sequence; @@ -3091,7 +3207,7 @@ void B_CollectionD_SequenceD___serialize__ (B_CollectionD_Sequence self, $Serial B_CollectionD_Sequence B_CollectionD_SequenceD___deserialize__ (B_CollectionD_Sequence self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_CollectionD_Sequence)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_Sequence), B_CollectionD_SequenceG_methods.$GCdescr); self->$class = &B_CollectionD_SequenceG_methods; return self; } @@ -3101,6 +3217,7 @@ B_CollectionD_Sequence B_CollectionD_SequenceD___deserialize__ (B_CollectionD_Se return self; } struct B_CollectionD_SequenceG_class B_CollectionD_SequenceG_methods; +GC_word B_CollectionD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_Sequence)]; B_NoneType B_TimesD_SequenceD___init__ (B_TimesD_Sequence W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self)); W_self->W_Sequence = W_Sequence; @@ -3112,7 +3229,7 @@ void B_TimesD_SequenceD___serialize__ (B_TimesD_Sequence self, $Serial$state sta B_TimesD_Sequence B_TimesD_SequenceD___deserialize__ (B_TimesD_Sequence self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_TimesD_Sequence)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_Sequence), B_TimesD_SequenceG_methods.$GCdescr); self->$class = &B_TimesD_SequenceG_methods; return self; } @@ -3122,6 +3239,7 @@ B_TimesD_Sequence B_TimesD_SequenceD___deserialize__ (B_TimesD_Sequence self, $S return self; } struct B_TimesD_SequenceG_class B_TimesD_SequenceG_methods; +GC_word B_TimesD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_Sequence)]; B_NoneType B_MappingD___init__ (B_Mapping W_self, B_Eq W_EqD_A, B_Indexed W_Indexed) { ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A); W_self->W_EqD_AD_Mapping = W_EqD_A; @@ -3136,7 +3254,7 @@ void B_MappingD___serialize__ (B_Mapping self, $Serial$state state) { B_Mapping B_MappingD___deserialize__ (B_Mapping self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Mapping)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Mapping), B_MappingG_methods.$GCdescr); self->$class = &B_MappingG_methods; return self; } @@ -3148,6 +3266,7 @@ B_Mapping B_MappingD___deserialize__ (B_Mapping self, $Serial$state state) { return self; } struct B_MappingG_class B_MappingG_methods; +GC_word B_MappingD_gcbm[GC_BITMAP_SIZE(struct B_Mapping)]; B_NoneType B_IndexedD_MappingD___init__ (B_IndexedD_Mapping W_self, B_Eq W_EqD_A, B_Mapping W_Mapping) { ((B_NoneType (*) (B_Indexed, B_Eq))B_IndexedG_methods.__init__)(((B_Indexed)W_self), W_EqD_A); W_self->W_EqD_AD_Mapping = W_EqD_A; @@ -3162,7 +3281,7 @@ void B_IndexedD_MappingD___serialize__ (B_IndexedD_Mapping self, $Serial$state s B_IndexedD_Mapping B_IndexedD_MappingD___deserialize__ (B_IndexedD_Mapping self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IndexedD_Mapping)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_Mapping), B_IndexedD_MappingG_methods.$GCdescr); self->$class = &B_IndexedD_MappingG_methods; return self; } @@ -3174,6 +3293,7 @@ B_IndexedD_Mapping B_IndexedD_MappingD___deserialize__ (B_IndexedD_Mapping self, return self; } struct B_IndexedD_MappingG_class B_IndexedD_MappingG_methods; +GC_word B_IndexedD_MappingD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_Mapping)]; B_NoneType B_SetD___init__ (B_Set W_self, B_Eq W_EqD_A, B_Ord W_Ord, B_Logical W_Logical, B_Minus W_Minus) { ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A); W_self->W_EqD_AD_Set = W_EqD_A; @@ -3192,7 +3312,7 @@ void B_SetD___serialize__ (B_Set self, $Serial$state state) { B_Set B_SetD___deserialize__ (B_Set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Set), B_SetG_methods.$GCdescr); self->$class = &B_SetG_methods; return self; } @@ -3206,6 +3326,7 @@ B_Set B_SetD___deserialize__ (B_Set self, $Serial$state state) { return self; } struct B_SetG_class B_SetG_methods; +GC_word B_SetD_gcbm[GC_BITMAP_SIZE(struct B_Set)]; B_NoneType B_OrdD_SetD___init__ (B_OrdD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); W_self->W_EqD_AD_Set = W_EqD_A; @@ -3219,7 +3340,7 @@ void B_OrdD_SetD___serialize__ (B_OrdD_Set self, $Serial$state state) { B_OrdD_Set B_OrdD_SetD___deserialize__ (B_OrdD_Set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_Set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_Set), B_OrdD_SetG_methods.$GCdescr); self->$class = &B_OrdD_SetG_methods; return self; } @@ -3230,6 +3351,7 @@ B_OrdD_Set B_OrdD_SetD___deserialize__ (B_OrdD_Set self, $Serial$state state) { return self; } struct B_OrdD_SetG_class B_OrdD_SetG_methods; +GC_word B_OrdD_SetD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_Set)]; B_NoneType B_LogicalD_SetD___init__ (B_LogicalD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) { ((B_NoneType (*) (B_Logical))B_LogicalG_methods.__init__)(((B_Logical)W_self)); W_self->W_EqD_AD_Set = W_EqD_A; @@ -3243,7 +3365,7 @@ void B_LogicalD_SetD___serialize__ (B_LogicalD_Set self, $Serial$state state) { B_LogicalD_Set B_LogicalD_SetD___deserialize__ (B_LogicalD_Set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_Set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_Set), B_LogicalD_SetG_methods.$GCdescr); self->$class = &B_LogicalD_SetG_methods; return self; } @@ -3254,6 +3376,7 @@ B_LogicalD_Set B_LogicalD_SetD___deserialize__ (B_LogicalD_Set self, $Serial$sta return self; } struct B_LogicalD_SetG_class B_LogicalD_SetG_methods; +GC_word B_LogicalD_SetD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Set)]; B_NoneType B_MinusD_SetD___init__ (B_MinusD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) { ((B_NoneType (*) (B_Minus))B_MinusG_methods.__init__)(((B_Minus)W_self)); W_self->W_EqD_AD_Set = W_EqD_A; @@ -3267,7 +3390,7 @@ void B_MinusD_SetD___serialize__ (B_MinusD_Set self, $Serial$state state) { B_MinusD_Set B_MinusD_SetD___deserialize__ (B_MinusD_Set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_Set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Set), B_MinusD_SetG_methods.$GCdescr); self->$class = &B_MinusD_SetG_methods; return self; } @@ -3278,6 +3401,7 @@ B_MinusD_Set B_MinusD_SetD___deserialize__ (B_MinusD_Set self, $Serial$state sta return self; } struct B_MinusD_SetG_class B_MinusD_SetG_methods; +GC_word B_MinusD_SetD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Set)]; B_NoneType B_SequenceD_listD___init__ (B_SequenceD_list W_self) { ((B_NoneType (*) (B_Sequence, B_Collection, B_Times))B_SequenceG_methods.__init__)(((B_Sequence)W_self), ((B_Collection)B_CollectionD_SequenceD_listG_new(((B_Sequence)W_self))), ((B_Times)B_TimesD_SequenceD_listG_new(((B_Sequence)W_self)))); return B_None; @@ -3300,7 +3424,7 @@ void B_SequenceD_listD___serialize__ (B_SequenceD_list self, $Serial$state state B_SequenceD_list B_SequenceD_listD___deserialize__ (B_SequenceD_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SequenceD_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_list), B_SequenceD_listG_methods.$GCdescr); self->$class = &B_SequenceD_listG_methods; return self; } @@ -3312,12 +3436,13 @@ B_SequenceD_list B_SequenceD_listD___deserialize__ (B_SequenceD_list self, $Seri return self; } B_SequenceD_list B_SequenceD_listG_new() { - B_SequenceD_list $tmp = malloc(sizeof(struct B_SequenceD_list)); + B_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_list), B_SequenceD_listG_methods.$GCdescr); $tmp->$class = &B_SequenceD_listG_methods; B_SequenceD_listG_methods.__init__($tmp); return $tmp; } struct B_SequenceD_listG_class B_SequenceD_listG_methods; +GC_word B_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_list)]; B_NoneType B_CollectionD_SequenceD_listD___init__ (B_CollectionD_SequenceD_list W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_CollectionD_Sequence, B_Sequence))B_CollectionD_SequenceG_methods.__init__)(((B_CollectionD_Sequence)W_self), ((B_Sequence)W_Sequence)); return B_None; @@ -3331,7 +3456,7 @@ void B_CollectionD_SequenceD_listD___serialize__ (B_CollectionD_SequenceD_list s B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listD___deserialize__ (B_CollectionD_SequenceD_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_CollectionD_SequenceD_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_list), B_CollectionD_SequenceD_listG_methods.$GCdescr); self->$class = &B_CollectionD_SequenceD_listG_methods; return self; } @@ -3341,12 +3466,13 @@ B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listD___deserialize__ (B_Co return self; } B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listG_new(B_Sequence G_1) { - B_CollectionD_SequenceD_list $tmp = malloc(sizeof(struct B_CollectionD_SequenceD_list)); + B_CollectionD_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_list), B_CollectionD_SequenceD_listG_methods.$GCdescr); $tmp->$class = &B_CollectionD_SequenceD_listG_methods; B_CollectionD_SequenceD_listG_methods.__init__($tmp, G_1); return $tmp; } struct B_CollectionD_SequenceD_listG_class B_CollectionD_SequenceD_listG_methods; +GC_word B_CollectionD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_list)]; B_NoneType B_TimesD_SequenceD_listD___init__ (B_TimesD_SequenceD_list W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_TimesD_Sequence, B_Sequence))B_TimesD_SequenceG_methods.__init__)(((B_TimesD_Sequence)W_self), ((B_Sequence)W_Sequence)); return B_None; @@ -3359,7 +3485,7 @@ void B_TimesD_SequenceD_listD___serialize__ (B_TimesD_SequenceD_list self, $Seri B_TimesD_SequenceD_list B_TimesD_SequenceD_listD___deserialize__ (B_TimesD_SequenceD_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_TimesD_SequenceD_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_list), B_TimesD_SequenceD_listG_methods.$GCdescr); self->$class = &B_TimesD_SequenceD_listG_methods; return self; } @@ -3369,12 +3495,13 @@ B_TimesD_SequenceD_list B_TimesD_SequenceD_listD___deserialize__ (B_TimesD_Seque return self; } B_TimesD_SequenceD_list B_TimesD_SequenceD_listG_new(B_Sequence G_1) { - B_TimesD_SequenceD_list $tmp = malloc(sizeof(struct B_TimesD_SequenceD_list)); + B_TimesD_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_list), B_TimesD_SequenceD_listG_methods.$GCdescr); $tmp->$class = &B_TimesD_SequenceD_listG_methods; B_TimesD_SequenceD_listG_methods.__init__($tmp, G_1); return $tmp; } struct B_TimesD_SequenceD_listG_class B_TimesD_SequenceD_listG_methods; +GC_word B_TimesD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_list)]; B_NoneType B_ContainerD_listD___init__ (B_ContainerD_list W_self, B_Eq W_EqD_A) { ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A); W_self->W_EqD_AD_ContainerD_list = W_EqD_A; @@ -3389,7 +3516,7 @@ void B_ContainerD_listD___serialize__ (B_ContainerD_list self, $Serial$state sta B_ContainerD_list B_ContainerD_listD___deserialize__ (B_ContainerD_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_ContainerD_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_list), B_ContainerD_listG_methods.$GCdescr); self->$class = &B_ContainerD_listG_methods; return self; } @@ -3403,6 +3530,7 @@ B_ContainerD_list B_ContainerD_listG_new(B_Eq w) { // Why is this not generated return $NEW(B_ContainerD_list,w); // } // struct B_ContainerD_listG_class B_ContainerD_listG_methods; +GC_word B_ContainerD_listD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_list)]; B_NoneType B_OrdD_listD___init__ (B_OrdD_list W_self, B_Ord W_OrdD_A) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); W_self->W_OrdD_AD_OrdD_list = W_OrdD_A; @@ -3416,7 +3544,7 @@ void B_OrdD_listD___serialize__ (B_OrdD_list self, $Serial$state state) { B_OrdD_list B_OrdD_listD___deserialize__ (B_OrdD_list self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_list)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_list), B_OrdD_listG_methods.$GCdescr); self->$class = &B_OrdD_listG_methods; return self; } @@ -3426,12 +3554,13 @@ B_OrdD_list B_OrdD_listD___deserialize__ (B_OrdD_list self, $Serial$state state) return self; } B_OrdD_list B_OrdD_listG_new(B_Ord G_1) { - B_OrdD_list $tmp = malloc(sizeof(struct B_OrdD_list)); + B_OrdD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_list), B_OrdD_listG_methods.$GCdescr); $tmp->$class = &B_OrdD_listG_methods; B_OrdD_listG_methods.__init__($tmp, G_1); return $tmp; } struct B_OrdD_listG_class B_OrdD_listG_methods; +GC_word B_OrdD_listD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_list)]; B_NoneType B_MappingD_dictD___init__ (B_MappingD_dict W_self, B_Hashable W_HashableD_A) { ((B_NoneType (*) (B_Mapping, B_Eq, B_Indexed))B_MappingG_methods.__init__)(((B_Mapping)W_self), ((B_Eq)W_HashableD_A), ((B_Indexed)B_IndexedD_MappingD_dictG_new(W_HashableD_A, ((B_Mapping)W_self)))); W_self->W_HashableD_AD_MappingD_dict = W_HashableD_A; @@ -3458,7 +3587,7 @@ void B_MappingD_dictD___serialize__ (B_MappingD_dict self, $Serial$state state) B_MappingD_dict B_MappingD_dictD___deserialize__ (B_MappingD_dict self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MappingD_dict)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MappingD_dict), B_MappingD_dictG_methods.$GCdescr); self->$class = &B_MappingD_dictG_methods; return self; } @@ -3471,12 +3600,13 @@ B_MappingD_dict B_MappingD_dictD___deserialize__ (B_MappingD_dict self, $Serial$ return self; } B_MappingD_dict B_MappingD_dictG_new(B_Hashable G_1) { - B_MappingD_dict $tmp = malloc(sizeof(struct B_MappingD_dict)); + B_MappingD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MappingD_dict), B_MappingD_dictG_methods.$GCdescr); $tmp->$class = &B_MappingD_dictG_methods; B_MappingD_dictG_methods.__init__($tmp, G_1); return $tmp; } struct B_MappingD_dictG_class B_MappingD_dictG_methods; +GC_word B_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_MappingD_dict)]; B_NoneType B_IndexedD_MappingD_dictD___init__ (B_IndexedD_MappingD_dict W_self, B_Hashable W_HashableD_A, B_Mapping W_Mapping) { ((B_NoneType (*) (B_IndexedD_Mapping, B_Eq, B_Mapping))B_IndexedD_MappingG_methods.__init__)(((B_IndexedD_Mapping)W_self), ((B_Eq)W_HashableD_A), ((B_Mapping)W_Mapping)); W_self->W_HashableD_AD_MappingD_dict = W_HashableD_A; @@ -3494,7 +3624,7 @@ void B_IndexedD_MappingD_dictD___serialize__ (B_IndexedD_MappingD_dict self, $Se B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictD___deserialize__ (B_IndexedD_MappingD_dict self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IndexedD_MappingD_dict)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_MappingD_dict), B_IndexedD_MappingD_dictG_methods.$GCdescr); self->$class = &B_IndexedD_MappingD_dictG_methods; return self; } @@ -3507,12 +3637,13 @@ B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictD___deserialize__ (B_IndexedD_M return self; } B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictG_new(B_Hashable G_1, B_Mapping G_2) { - B_IndexedD_MappingD_dict $tmp = malloc(sizeof(struct B_IndexedD_MappingD_dict)); + B_IndexedD_MappingD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_MappingD_dict), B_IndexedD_MappingD_dictG_methods.$GCdescr); $tmp->$class = &B_IndexedD_MappingD_dictG_methods; B_IndexedD_MappingD_dictG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods; +GC_word B_IndexedD_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_MappingD_dict)]; B_NoneType B_OrdD_dictD___init__ (B_OrdD_dict W_self, B_Hashable W_HashableD_A, B_Eq W_EqD_B) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); W_self->W_HashableD_AD_OrdD_dict = W_HashableD_A; @@ -3528,7 +3659,7 @@ void B_OrdD_dictD___serialize__ (B_OrdD_dict self, $Serial$state state) { B_OrdD_dict B_OrdD_dictD___deserialize__ (B_OrdD_dict self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_dict)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_dict), B_OrdD_dictG_methods.$GCdescr); self->$class = &B_OrdD_dictG_methods; return self; } @@ -3539,12 +3670,13 @@ B_OrdD_dict B_OrdD_dictD___deserialize__ (B_OrdD_dict self, $Serial$state state) return self; } B_OrdD_dict B_OrdD_dictG_new(B_Hashable G_1, B_Eq G_2) { - B_OrdD_dict $tmp = malloc(sizeof(struct B_OrdD_dict)); + B_OrdD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_dict), B_OrdD_dictG_methods.$GCdescr); $tmp->$class = &B_OrdD_dictG_methods; B_OrdD_dictG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_OrdD_dictG_class B_OrdD_dictG_methods; +GC_word B_OrdD_dictD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_dict)]; B_NoneType B_SetD_setD___init__ (B_SetD_set W_self, B_Hashable W_HashableD_A) { ((B_NoneType (*) (B_Set, B_Eq, B_Ord, B_Logical, B_Minus))B_SetG_methods.__init__)(((B_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Ord)B_OrdD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self))), ((B_Logical)B_LogicalD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self))), ((B_Minus)B_MinusD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self)))); W_self->W_HashableD_AD_SetD_set = W_HashableD_A; @@ -3570,7 +3702,7 @@ void B_SetD_setD___serialize__ (B_SetD_set self, $Serial$state state) { B_SetD_set B_SetD_setD___deserialize__ (B_SetD_set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SetD_set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SetD_set), B_SetD_setG_methods.$GCdescr); self->$class = &B_SetD_setG_methods; return self; } @@ -3585,12 +3717,13 @@ B_SetD_set B_SetD_setD___deserialize__ (B_SetD_set self, $Serial$state state) { return self; } B_SetD_set B_SetD_setG_new(B_Hashable G_1) { - B_SetD_set $tmp = malloc(sizeof(struct B_SetD_set)); + B_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SetD_set), B_SetD_setG_methods.$GCdescr); $tmp->$class = &B_SetD_setG_methods; B_SetD_setG_methods.__init__($tmp, G_1); return $tmp; } struct B_SetD_setG_class B_SetD_setG_methods; +GC_word B_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_SetD_set)]; B_NoneType B_OrdD_SetD_setD___init__ (B_OrdD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) { ((B_NoneType (*) (B_OrdD_Set, B_Eq, B_Set))B_OrdD_SetG_methods.__init__)(((B_OrdD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set)); W_self->W_HashableD_AD_SetD_set = W_HashableD_A; @@ -3606,7 +3739,7 @@ void B_OrdD_SetD_setD___serialize__ (B_OrdD_SetD_set self, $Serial$state state) B_OrdD_SetD_set B_OrdD_SetD_setD___deserialize__ (B_OrdD_SetD_set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_SetD_set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_SetD_set), B_OrdD_SetD_setG_methods.$GCdescr); self->$class = &B_OrdD_SetD_setG_methods; return self; } @@ -3618,12 +3751,13 @@ B_OrdD_SetD_set B_OrdD_SetD_setD___deserialize__ (B_OrdD_SetD_set self, $Serial$ return self; } B_OrdD_SetD_set B_OrdD_SetD_setG_new(B_Hashable G_1, B_Set G_2) { - B_OrdD_SetD_set $tmp = malloc(sizeof(struct B_OrdD_SetD_set)); + B_OrdD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_SetD_set), B_OrdD_SetD_setG_methods.$GCdescr); $tmp->$class = &B_OrdD_SetD_setG_methods; B_OrdD_SetD_setG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_OrdD_SetD_setG_class B_OrdD_SetD_setG_methods; +GC_word B_OrdD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_SetD_set)]; B_NoneType B_LogicalD_SetD_setD___init__ (B_LogicalD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) { ((B_NoneType (*) (B_LogicalD_Set, B_Eq, B_Set))B_LogicalD_SetG_methods.__init__)(((B_LogicalD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set)); W_self->W_HashableD_AD_SetD_set = W_HashableD_A; @@ -3640,7 +3774,7 @@ void B_LogicalD_SetD_setD___serialize__ (B_LogicalD_SetD_set self, $Serial$state B_LogicalD_SetD_set B_LogicalD_SetD_setD___deserialize__ (B_LogicalD_SetD_set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_LogicalD_SetD_set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_SetD_set), B_LogicalD_SetD_setG_methods.$GCdescr); self->$class = &B_LogicalD_SetD_setG_methods; return self; } @@ -3652,12 +3786,13 @@ B_LogicalD_SetD_set B_LogicalD_SetD_setD___deserialize__ (B_LogicalD_SetD_set se return self; } B_LogicalD_SetD_set B_LogicalD_SetD_setG_new(B_Hashable G_1, B_Set G_2) { - B_LogicalD_SetD_set $tmp = malloc(sizeof(struct B_LogicalD_SetD_set)); + B_LogicalD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_SetD_set), B_LogicalD_SetD_setG_methods.$GCdescr); $tmp->$class = &B_LogicalD_SetD_setG_methods; B_LogicalD_SetD_setG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_LogicalD_SetD_setG_class B_LogicalD_SetD_setG_methods; +GC_word B_LogicalD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_SetD_set)]; B_NoneType B_MinusD_SetD_setD___init__ (B_MinusD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) { ((B_NoneType (*) (B_MinusD_Set, B_Eq, B_Set))B_MinusD_SetG_methods.__init__)(((B_MinusD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set)); W_self->W_HashableD_AD_SetD_set = W_HashableD_A; @@ -3672,7 +3807,7 @@ void B_MinusD_SetD_setD___serialize__ (B_MinusD_SetD_set self, $Serial$state sta B_MinusD_SetD_set B_MinusD_SetD_setD___deserialize__ (B_MinusD_SetD_set self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_MinusD_SetD_set)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_SetD_set), B_MinusD_SetD_setG_methods.$GCdescr); self->$class = &B_MinusD_SetD_setG_methods; return self; } @@ -3684,12 +3819,13 @@ B_MinusD_SetD_set B_MinusD_SetD_setD___deserialize__ (B_MinusD_SetD_set self, $S return self; } B_MinusD_SetD_set B_MinusD_SetD_setG_new(B_Hashable G_1, B_Set G_2) { - B_MinusD_SetD_set $tmp = malloc(sizeof(struct B_MinusD_SetD_set)); + B_MinusD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_SetD_set), B_MinusD_SetD_setG_methods.$GCdescr); $tmp->$class = &B_MinusD_SetD_setG_methods; B_MinusD_SetD_setG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_MinusD_SetD_setG_class B_MinusD_SetD_setG_methods; +GC_word B_MinusD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_SetD_set)]; B_NoneType B_IterableD_IteratorD___init__ (B_IterableD_Iterator W_self) { ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self)); return B_None; @@ -3700,7 +3836,7 @@ void B_IterableD_IteratorD___serialize__ (B_IterableD_Iterator self, $Serial$sta B_IterableD_Iterator B_IterableD_IteratorD___deserialize__ (B_IterableD_Iterator self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IterableD_Iterator)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_Iterator), B_IterableD_IteratorG_methods.$GCdescr); self->$class = &B_IterableD_IteratorG_methods; return self; } @@ -3709,12 +3845,13 @@ B_IterableD_Iterator B_IterableD_IteratorD___deserialize__ (B_IterableD_Iterator return self; } B_IterableD_Iterator B_IterableD_IteratorG_new() { - B_IterableD_Iterator $tmp = malloc(sizeof(struct B_IterableD_Iterator)); + B_IterableD_Iterator $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_Iterator), B_IterableD_IteratorG_methods.$GCdescr); $tmp->$class = &B_IterableD_IteratorG_methods; B_IterableD_IteratorG_methods.__init__($tmp); return $tmp; } struct B_IterableD_IteratorG_class B_IterableD_IteratorG_methods; +GC_word B_IterableD_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_Iterator)]; B_NoneType B_IterableD_rangeD___init__ (B_IterableD_range W_self) { ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self)); return B_None; @@ -3725,7 +3862,7 @@ void B_IterableD_rangeD___serialize__ (B_IterableD_range self, $Serial$state sta B_IterableD_range B_IterableD_rangeD___deserialize__ (B_IterableD_range self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_IterableD_range)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_range), B_IterableD_rangeG_methods.$GCdescr); self->$class = &B_IterableD_rangeG_methods; return self; } @@ -3734,12 +3871,13 @@ B_IterableD_range B_IterableD_rangeD___deserialize__ (B_IterableD_range self, $S return self; } B_IterableD_range B_IterableD_rangeG_new() { - B_IterableD_range $tmp = malloc(sizeof(struct B_IterableD_range)); + B_IterableD_range $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_range), B_IterableD_rangeG_methods.$GCdescr); $tmp->$class = &B_IterableD_rangeG_methods; B_IterableD_rangeG_methods.__init__($tmp); return $tmp; } struct B_IterableD_rangeG_class B_IterableD_rangeG_methods; +GC_word B_IterableD_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_range)]; B_NoneType B_OrdD_strD___init__ (B_OrdD_str W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -3751,7 +3889,7 @@ void B_OrdD_strD___serialize__ (B_OrdD_str self, $Serial$state state) { B_OrdD_str B_OrdD_strD___deserialize__ (B_OrdD_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_str), B_OrdD_strG_methods.$GCdescr); self->$class = &B_OrdD_strG_methods; return self; } @@ -3760,12 +3898,13 @@ B_OrdD_str B_OrdD_strD___deserialize__ (B_OrdD_str self, $Serial$state state) { return self; } B_OrdD_str B_OrdD_strG_new() { - B_OrdD_str $tmp = malloc(sizeof(struct B_OrdD_str)); + B_OrdD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_str), B_OrdD_strG_methods.$GCdescr); $tmp->$class = &B_OrdD_strG_methods; B_OrdD_strG_methods.__init__($tmp); return $tmp; } struct B_OrdD_strG_class B_OrdD_strG_methods; +GC_word B_OrdD_strD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_str)]; B_NoneType B_ContainerD_strD___init__ (B_ContainerD_str W_self) { B_Eq W_395 = ((B_Eq)B_OrdD_strG_new()); ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_395); @@ -3782,7 +3921,7 @@ void B_ContainerD_strD___serialize__ (B_ContainerD_str self, $Serial$state state B_ContainerD_str B_ContainerD_strD___deserialize__ (B_ContainerD_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_ContainerD_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_str), B_ContainerD_strG_methods.$GCdescr); self->$class = &B_ContainerD_strG_methods; return self; } @@ -3792,12 +3931,13 @@ B_ContainerD_str B_ContainerD_strD___deserialize__ (B_ContainerD_str self, $Seri return self; } B_ContainerD_str B_ContainerD_strG_new() { - B_ContainerD_str $tmp = malloc(sizeof(struct B_ContainerD_str)); + B_ContainerD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_str), B_ContainerD_strG_methods.$GCdescr); $tmp->$class = &B_ContainerD_strG_methods; B_ContainerD_strG_methods.__init__($tmp); return $tmp; } struct B_ContainerD_strG_class B_ContainerD_strG_methods; +GC_word B_ContainerD_strD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_str)]; B_NoneType B_SliceableD_strD___init__ (B_SliceableD_str W_self) { ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self)); return B_None; @@ -3814,7 +3954,7 @@ void B_SliceableD_strD___serialize__ (B_SliceableD_str self, $Serial$state state B_SliceableD_str B_SliceableD_strD___deserialize__ (B_SliceableD_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SliceableD_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_str), B_SliceableD_strG_methods.$GCdescr); self->$class = &B_SliceableD_strG_methods; return self; } @@ -3824,12 +3964,13 @@ B_SliceableD_str B_SliceableD_strD___deserialize__ (B_SliceableD_str self, $Seri return self; } B_SliceableD_str B_SliceableD_strG_new() { - B_SliceableD_str $tmp = malloc(sizeof(struct B_SliceableD_str)); + B_SliceableD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_str), B_SliceableD_strG_methods.$GCdescr); $tmp->$class = &B_SliceableD_strG_methods; B_SliceableD_strG_methods.__init__($tmp); return $tmp; } struct B_SliceableD_strG_class B_SliceableD_strG_methods; +GC_word B_SliceableD_strD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_str)]; B_NoneType B_TimesD_strD___init__ (B_TimesD_str W_self) { ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self)); return B_None; @@ -3841,7 +3982,7 @@ void B_TimesD_strD___serialize__ (B_TimesD_str self, $Serial$state state) { B_TimesD_str B_TimesD_strD___deserialize__ (B_TimesD_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_TimesD_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_str), B_TimesD_strG_methods.$GCdescr); self->$class = &B_TimesD_strG_methods; return self; } @@ -3850,12 +3991,13 @@ B_TimesD_str B_TimesD_strD___deserialize__ (B_TimesD_str self, $Serial$state sta return self; } B_TimesD_str B_TimesD_strG_new() { - B_TimesD_str $tmp = malloc(sizeof(struct B_TimesD_str)); + B_TimesD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_str), B_TimesD_strG_methods.$GCdescr); $tmp->$class = &B_TimesD_strG_methods; B_TimesD_strG_methods.__init__($tmp); return $tmp; } struct B_TimesD_strG_class B_TimesD_strG_methods; +GC_word B_TimesD_strD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_str)]; B_NoneType B_HashableD_strD___init__ (B_HashableD_str W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -3866,7 +4008,7 @@ void B_HashableD_strD___serialize__ (B_HashableD_str self, $Serial$state state) B_HashableD_str B_HashableD_strD___deserialize__ (B_HashableD_str self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_str)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_str), B_HashableD_strG_methods.$GCdescr); self->$class = &B_HashableD_strG_methods; return self; } @@ -3878,6 +4020,7 @@ B_HashableD_str B_HashableD_strG_new() { // Manually added. return $NEW(B_HashableD_str); // } // struct B_HashableD_strG_class B_HashableD_strG_methods; +GC_word B_HashableD_strD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_str)]; B_NoneType B_OrdD_bytearrayD___init__ (B_OrdD_bytearray W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -3889,7 +4032,7 @@ void B_OrdD_bytearrayD___serialize__ (B_OrdD_bytearray self, $Serial$state state B_OrdD_bytearray B_OrdD_bytearrayD___deserialize__ (B_OrdD_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytearray), B_OrdD_bytearrayG_methods.$GCdescr); self->$class = &B_OrdD_bytearrayG_methods; return self; } @@ -3898,12 +4041,13 @@ B_OrdD_bytearray B_OrdD_bytearrayD___deserialize__ (B_OrdD_bytearray self, $Seri return self; } B_OrdD_bytearray B_OrdD_bytearrayG_new() { - B_OrdD_bytearray $tmp = malloc(sizeof(struct B_OrdD_bytearray)); + B_OrdD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytearray), B_OrdD_bytearrayG_methods.$GCdescr); $tmp->$class = &B_OrdD_bytearrayG_methods; B_OrdD_bytearrayG_methods.__init__($tmp); return $tmp; } struct B_OrdD_bytearrayG_class B_OrdD_bytearrayG_methods; +GC_word B_OrdD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytearray)]; B_NoneType B_SequenceD_bytearrayD___init__ (B_SequenceD_bytearray W_self) { ((B_NoneType (*) (B_Sequence, B_Collection, B_Times))B_SequenceG_methods.__init__)(((B_Sequence)W_self), ((B_Collection)B_CollectionD_SequenceD_bytearrayG_new(((B_Sequence)W_self))), ((B_Times)B_TimesD_SequenceD_bytearrayG_new(((B_Sequence)W_self)))); return B_None; @@ -3926,7 +4070,7 @@ void B_SequenceD_bytearrayD___serialize__ (B_SequenceD_bytearray self, $Serial$s B_SequenceD_bytearray B_SequenceD_bytearrayD___deserialize__ (B_SequenceD_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SequenceD_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_bytearray), B_SequenceD_bytearrayG_methods.$GCdescr); self->$class = &B_SequenceD_bytearrayG_methods; return self; } @@ -3938,12 +4082,13 @@ B_SequenceD_bytearray B_SequenceD_bytearrayD___deserialize__ (B_SequenceD_bytear return self; } B_SequenceD_bytearray B_SequenceD_bytearrayG_new() { - B_SequenceD_bytearray $tmp = malloc(sizeof(struct B_SequenceD_bytearray)); + B_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_bytearray), B_SequenceD_bytearrayG_methods.$GCdescr); $tmp->$class = &B_SequenceD_bytearrayG_methods; B_SequenceD_bytearrayG_methods.__init__($tmp); return $tmp; } struct B_SequenceD_bytearrayG_class B_SequenceD_bytearrayG_methods; +GC_word B_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_bytearray)]; B_NoneType B_CollectionD_SequenceD_bytearrayD___init__ (B_CollectionD_SequenceD_bytearray W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_CollectionD_Sequence, B_Sequence))B_CollectionD_SequenceG_methods.__init__)(((B_CollectionD_Sequence)W_self), ((B_Sequence)W_Sequence)); return B_None; @@ -3957,7 +4102,7 @@ void B_CollectionD_SequenceD_bytearrayD___serialize__ (B_CollectionD_SequenceD_b B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayD___deserialize__ (B_CollectionD_SequenceD_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_CollectionD_SequenceD_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_bytearray), B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr); self->$class = &B_CollectionD_SequenceD_bytearrayG_methods; return self; } @@ -3967,12 +4112,13 @@ B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayD___deseriali return self; } B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayG_new(B_Sequence G_1) { - B_CollectionD_SequenceD_bytearray $tmp = malloc(sizeof(struct B_CollectionD_SequenceD_bytearray)); + B_CollectionD_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_bytearray), B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr); $tmp->$class = &B_CollectionD_SequenceD_bytearrayG_methods; B_CollectionD_SequenceD_bytearrayG_methods.__init__($tmp, G_1); return $tmp; } struct B_CollectionD_SequenceD_bytearrayG_class B_CollectionD_SequenceD_bytearrayG_methods; +GC_word B_CollectionD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_bytearray)]; B_NoneType B_TimesD_SequenceD_bytearrayD___init__ (B_TimesD_SequenceD_bytearray W_self, B_Sequence W_Sequence) { ((B_NoneType (*) (B_TimesD_Sequence, B_Sequence))B_TimesD_SequenceG_methods.__init__)(((B_TimesD_Sequence)W_self), ((B_Sequence)W_Sequence)); return B_None; @@ -3985,7 +4131,7 @@ void B_TimesD_SequenceD_bytearrayD___serialize__ (B_TimesD_SequenceD_bytearray s B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayD___deserialize__ (B_TimesD_SequenceD_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_TimesD_SequenceD_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_bytearray), B_TimesD_SequenceD_bytearrayG_methods.$GCdescr); self->$class = &B_TimesD_SequenceD_bytearrayG_methods; return self; } @@ -3995,12 +4141,13 @@ B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayD___deserialize__ (B_Ti return self; } B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayG_new(B_Sequence G_1) { - B_TimesD_SequenceD_bytearray $tmp = malloc(sizeof(struct B_TimesD_SequenceD_bytearray)); + B_TimesD_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_bytearray), B_TimesD_SequenceD_bytearrayG_methods.$GCdescr); $tmp->$class = &B_TimesD_SequenceD_bytearrayG_methods; B_TimesD_SequenceD_bytearrayG_methods.__init__($tmp, G_1); return $tmp; } struct B_TimesD_SequenceD_bytearrayG_class B_TimesD_SequenceD_bytearrayG_methods; +GC_word B_TimesD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_bytearray)]; B_NoneType B_ContainerD_bytearrayD___init__ (B_ContainerD_bytearray W_self) { B_Eq W_427 = ((B_Eq)B_OrdD_intG_new()); ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_427); @@ -4014,7 +4161,7 @@ void B_ContainerD_bytearrayD___serialize__ (B_ContainerD_bytearray self, $Serial B_ContainerD_bytearray B_ContainerD_bytearrayD___deserialize__ (B_ContainerD_bytearray self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_ContainerD_bytearray)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytearray), B_ContainerD_bytearrayG_methods.$GCdescr); self->$class = &B_ContainerD_bytearrayG_methods; return self; } @@ -4024,6 +4171,7 @@ B_ContainerD_bytearray B_ContainerD_bytearrayD___deserialize__ (B_ContainerD_byt return self; } struct B_ContainerD_bytearrayG_class B_ContainerD_bytearrayG_methods; +GC_word B_ContainerD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytearray)]; B_NoneType B_OrdD_bytesD___init__ (B_OrdD_bytes W_self) { ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self)); return B_None; @@ -4035,7 +4183,7 @@ void B_OrdD_bytesD___serialize__ (B_OrdD_bytes self, $Serial$state state) { B_OrdD_bytes B_OrdD_bytesD___deserialize__ (B_OrdD_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_OrdD_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytes), B_OrdD_bytesG_methods.$GCdescr); self->$class = &B_OrdD_bytesG_methods; return self; } @@ -4044,12 +4192,13 @@ B_OrdD_bytes B_OrdD_bytesD___deserialize__ (B_OrdD_bytes self, $Serial$state sta return self; } B_OrdD_bytes B_OrdD_bytesG_new() { - B_OrdD_bytes $tmp = malloc(sizeof(struct B_OrdD_bytes)); + B_OrdD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytes), B_OrdD_bytesG_methods.$GCdescr); $tmp->$class = &B_OrdD_bytesG_methods; B_OrdD_bytesG_methods.__init__($tmp); return $tmp; } struct B_OrdD_bytesG_class B_OrdD_bytesG_methods; +GC_word B_OrdD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytes)]; B_NoneType B_SliceableD_bytesD___init__ (B_SliceableD_bytes W_self) { ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self)); return B_None; @@ -4066,7 +4215,7 @@ void B_SliceableD_bytesD___serialize__ (B_SliceableD_bytes self, $Serial$state s B_SliceableD_bytes B_SliceableD_bytesD___deserialize__ (B_SliceableD_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_SliceableD_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_bytes), B_SliceableD_bytesG_methods.$GCdescr); self->$class = &B_SliceableD_bytesG_methods; return self; } @@ -4076,12 +4225,13 @@ B_SliceableD_bytes B_SliceableD_bytesD___deserialize__ (B_SliceableD_bytes self, return self; } B_SliceableD_bytes B_SliceableD_bytesG_new() { - B_SliceableD_bytes $tmp = malloc(sizeof(struct B_SliceableD_bytes)); + B_SliceableD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_bytes), B_SliceableD_bytesG_methods.$GCdescr); $tmp->$class = &B_SliceableD_bytesG_methods; B_SliceableD_bytesG_methods.__init__($tmp); return $tmp; } struct B_SliceableD_bytesG_class B_SliceableD_bytesG_methods; +GC_word B_SliceableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_bytes)]; B_NoneType B_ContainerD_bytesD___init__ (B_ContainerD_bytes W_self) { B_Eq W_438 = ((B_Eq)B_OrdD_intG_new()); ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_438); @@ -4098,7 +4248,7 @@ void B_ContainerD_bytesD___serialize__ (B_ContainerD_bytes self, $Serial$state s B_ContainerD_bytes B_ContainerD_bytesD___deserialize__ (B_ContainerD_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_ContainerD_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytes), B_ContainerD_bytesG_methods.$GCdescr); self->$class = &B_ContainerD_bytesG_methods; return self; } @@ -4108,12 +4258,13 @@ B_ContainerD_bytes B_ContainerD_bytesD___deserialize__ (B_ContainerD_bytes self, return self; } B_ContainerD_bytes B_ContainerD_bytesG_new() { - B_ContainerD_bytes $tmp = malloc(sizeof(struct B_ContainerD_bytes)); + B_ContainerD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytes), B_ContainerD_bytesG_methods.$GCdescr); $tmp->$class = &B_ContainerD_bytesG_methods; B_ContainerD_bytesG_methods.__init__($tmp); return $tmp; } struct B_ContainerD_bytesG_class B_ContainerD_bytesG_methods; +GC_word B_ContainerD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytes)]; B_NoneType B_TimesD_bytesD___init__ (B_TimesD_bytes W_self) { ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self)); return B_None; @@ -4125,7 +4276,7 @@ void B_TimesD_bytesD___serialize__ (B_TimesD_bytes self, $Serial$state state) { B_TimesD_bytes B_TimesD_bytesD___deserialize__ (B_TimesD_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_TimesD_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_bytes), B_TimesD_bytesG_methods.$GCdescr); self->$class = &B_TimesD_bytesG_methods; return self; } @@ -4134,12 +4285,13 @@ B_TimesD_bytes B_TimesD_bytesD___deserialize__ (B_TimesD_bytes self, $Serial$sta return self; } B_TimesD_bytes B_TimesD_bytesG_new() { - B_TimesD_bytes $tmp = malloc(sizeof(struct B_TimesD_bytes)); + B_TimesD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_bytes), B_TimesD_bytesG_methods.$GCdescr); $tmp->$class = &B_TimesD_bytesG_methods; B_TimesD_bytesG_methods.__init__($tmp); return $tmp; } struct B_TimesD_bytesG_class B_TimesD_bytesG_methods; +GC_word B_TimesD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_bytes)]; B_NoneType B_HashableD_bytesD___init__ (B_HashableD_bytes W_self) { ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self)); return B_None; @@ -4150,7 +4302,7 @@ void B_HashableD_bytesD___serialize__ (B_HashableD_bytes self, $Serial$state sta B_HashableD_bytes B_HashableD_bytesD___deserialize__ (B_HashableD_bytes self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_HashableD_bytes)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bytes), B_HashableD_bytesG_methods.$GCdescr); self->$class = &B_HashableD_bytesG_methods; return self; } @@ -4159,6 +4311,7 @@ B_HashableD_bytes B_HashableD_bytesD___deserialize__ (B_HashableD_bytes self, $S return self; } struct B_HashableD_bytesG_class B_HashableD_bytesG_methods; +GC_word B_HashableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bytes)]; $WORD B_abs (B_Real W_RealE_768, B_Number W_NumberE_767, $WORD x) { return (($WORD (*) (B_Number, $WORD, B_Real))W_NumberE_767->$class->__abs__)(W_NumberE_767, x, W_RealE_768); } @@ -4254,7 +4407,7 @@ void B_L_1procD___serialize__ (B_L_1proc self, $Serial$state state) { B_L_1proc B_L_1procD___deserialize__ (B_L_1proc self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_L_1proc)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_1proc), B_L_1procG_methods.$GCdescr); self->$class = &B_L_1procG_methods; return self; } @@ -4265,12 +4418,13 @@ B_L_1proc B_L_1procD___deserialize__ (B_L_1proc self, $Serial$state state) { return self; } B_L_1proc B_L_1procG_new(B_Env G_1, B_str G_2) { - B_L_1proc $tmp = malloc(sizeof(struct B_L_1proc)); + B_L_1proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_1proc), B_L_1procG_methods.$GCdescr); $tmp->$class = &B_L_1procG_methods; B_L_1procG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_L_1procG_class B_L_1procG_methods; +GC_word B_L_1procD_gcbm[GC_BITMAP_SIZE(struct B_L_1proc)]; B_NoneType B_L_2procD___init__ (B_L_2proc L_self, B_Env self, $action cb) { L_self->self = self; L_self->cb = cb; @@ -4291,7 +4445,7 @@ void B_L_2procD___serialize__ (B_L_2proc self, $Serial$state state) { B_L_2proc B_L_2procD___deserialize__ (B_L_2proc self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_L_2proc)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_2proc), B_L_2procG_methods.$GCdescr); self->$class = &B_L_2procG_methods; return self; } @@ -4302,12 +4456,13 @@ B_L_2proc B_L_2procD___deserialize__ (B_L_2proc self, $Serial$state state) { return self; } B_L_2proc B_L_2procG_new(B_Env G_1, $action G_2) { - B_L_2proc $tmp = malloc(sizeof(struct B_L_2proc)); + B_L_2proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_2proc), B_L_2procG_methods.$GCdescr); $tmp->$class = &B_L_2procG_methods; B_L_2procG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_L_2procG_class B_L_2procG_methods; +GC_word B_L_2procD_gcbm[GC_BITMAP_SIZE(struct B_L_2proc)]; B_NoneType B_L_3procD___init__ (B_L_3proc L_self, B_Env self, B_int n) { L_self->self = self; L_self->n = n; @@ -4328,7 +4483,7 @@ void B_L_3procD___serialize__ (B_L_3proc self, $Serial$state state) { B_L_3proc B_L_3procD___deserialize__ (B_L_3proc self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_L_3proc)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_3proc), B_L_3procG_methods.$GCdescr); self->$class = &B_L_3procG_methods; return self; } @@ -4339,12 +4494,13 @@ B_L_3proc B_L_3procD___deserialize__ (B_L_3proc self, $Serial$state state) { return self; } B_L_3proc B_L_3procG_new(B_Env G_1, B_int G_2) { - B_L_3proc $tmp = malloc(sizeof(struct B_L_3proc)); + B_L_3proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_3proc), B_L_3procG_methods.$GCdescr); $tmp->$class = &B_L_3procG_methods; B_L_3procG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_L_3procG_class B_L_3procG_methods; +GC_word B_L_3procD_gcbm[GC_BITMAP_SIZE(struct B_L_3proc)]; $R B_L_4C_1cont (B_Env G_act, $Cont C_cont, B_NoneType C_2res) { return $RU_CONT(C_cont, G_act); } @@ -4365,7 +4521,7 @@ void B_L_5ContD___serialize__ (B_L_5Cont self, $Serial$state state) { B_L_5Cont B_L_5ContD___deserialize__ (B_L_5Cont self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_L_5Cont)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_5Cont), B_L_5ContG_methods.$GCdescr); self->$class = &B_L_5ContG_methods; return self; } @@ -4376,12 +4532,13 @@ B_L_5Cont B_L_5ContD___deserialize__ (B_L_5Cont self, $Serial$state state) { return self; } B_L_5Cont B_L_5ContG_new(B_Env G_1, $Cont G_2) { - B_L_5Cont $tmp = malloc(sizeof(struct B_L_5Cont)); + B_L_5Cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_5Cont), B_L_5ContG_methods.$GCdescr); $tmp->$class = &B_L_5ContG_methods; B_L_5ContG_methods.__init__($tmp, G_1, G_2); return $tmp; } struct B_L_5ContG_class B_L_5ContG_methods; +GC_word B_L_5ContD_gcbm[GC_BITMAP_SIZE(struct B_L_5Cont)]; B_NoneType B_L_6procD___init__ (B_L_6proc L_self, B_Env G_act, B_WorldAuth token, B_list args) { L_self->G_act = G_act; L_self->token = token; @@ -4405,7 +4562,7 @@ void B_L_6procD___serialize__ (B_L_6proc self, $Serial$state state) { B_L_6proc B_L_6procD___deserialize__ (B_L_6proc self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_L_6proc)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_6proc), B_L_6procG_methods.$GCdescr); self->$class = &B_L_6procG_methods; return self; } @@ -4417,18 +4574,19 @@ B_L_6proc B_L_6procD___deserialize__ (B_L_6proc self, $Serial$state state) { return self; } B_L_6proc B_L_6procG_new(B_Env G_1, B_WorldAuth G_2, B_list G_3) { - B_L_6proc $tmp = malloc(sizeof(struct B_L_6proc)); + B_L_6proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_6proc), B_L_6procG_methods.$GCdescr); $tmp->$class = &B_L_6procG_methods; B_L_6procG_methods.__init__($tmp, G_1, G_2, G_3); return $tmp; } struct B_L_6procG_class B_L_6procG_methods; +GC_word B_L_6procD_gcbm[GC_BITMAP_SIZE(struct B_L_6proc)]; void B_WorldAuthD___serialize__ (B_WorldAuth self, $Serial$state state) { } B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_WorldAuth)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr); self->$class = &B_WorldAuthG_methods; return self; } @@ -4437,6 +4595,7 @@ B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) return self; } struct B_WorldAuthG_class B_WorldAuthG_methods; +GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)]; $R B_EnvD___init__ (B_Env self, $Cont C_cont, B_WorldAuth token, B_list args) { self->token = token; self->args = args; @@ -4466,7 +4625,7 @@ void B_EnvD___serialize__ (B_Env self, $Serial$state state) { B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Env)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr); self->$class = &B_EnvG_methods; return self; } @@ -4480,11 +4639,12 @@ B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) { return self; } $R B_EnvG_new($Cont G_1, B_WorldAuth G_2, B_list G_3) { - B_Env $tmp = malloc(sizeof(struct B_Env)); + B_Env $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr); $tmp->$class = &B_EnvG_methods; return B_EnvG_methods.__init__($tmp, G_1, G_2, $CONSTCONT(G_3, $tmp)); } struct B_EnvG_class B_EnvG_methods; +GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)]; $R B_EnvG_newact ($Cont C_cont, B_WorldAuth token, B_list args) { B_Env G_act = $NEWACTOR(B_Env); return $AWAIT((($Cont)B_L_5ContG_new(G_act, C_cont)), $ASYNC((($Actor)G_act), (($Cont)B_L_6procG_new(G_act, token, args)))); @@ -4496,7 +4656,9 @@ void B___init__ () { B_done$ = 1; // B___ext_init__ (); { - B_valueG_methods.$GCINFO = "B_value"; + memset(B_valueD_gcbm, 0xFF, sizeof(B_valueD_gcbm)); + B_valueG_methods.$GCdescr = GC_make_descriptor(B_valueD_gcbm, GC_WORD_LEN(struct B_value)); + B_valueG_methods.$name = "B_value"; B_valueG_methods.$superclass = NULL; B_valueG_methods.__init__ = B_valueD___init__; B_valueG_methods.__bool__ = B_valueD___bool__; @@ -4506,7 +4668,9 @@ void B___init__ () { B_valueG_methods.__deserialize__ = B_valueD___deserialize__; } { - B_objectG_methods.$GCINFO = "B_object"; + memset(B_objectD_gcbm, 0xFF, sizeof(B_objectD_gcbm)); + B_objectG_methods.$GCdescr = GC_make_descriptor(B_objectD_gcbm, GC_WORD_LEN(struct B_object)); + B_objectG_methods.$name = "B_object"; B_objectG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_objectG_methods.__init__ = (B_NoneType (*) (B_object))B_valueG_methods.__init__; B_objectG_methods.__bool__ = (B_bool (*) (B_object))B_valueG_methods.__bool__; @@ -4516,7 +4680,9 @@ void B___init__ () { B_objectG_methods.__deserialize__ = B_objectD___deserialize__; } { - B_atomG_methods.$GCINFO = "B_atom"; + memset(B_atomD_gcbm, 0xFF, sizeof(B_atomD_gcbm)); + B_atomG_methods.$GCdescr = GC_make_descriptor(B_atomD_gcbm, GC_WORD_LEN(struct B_atom)); + B_atomG_methods.$name = "B_atom"; B_atomG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_atomG_methods.__init__ = (B_NoneType (*) (B_atom))B_valueG_methods.__init__; B_atomG_methods.__bool__ = (B_bool (*) (B_atom))B_valueG_methods.__bool__; @@ -4526,7 +4692,9 @@ void B___init__ () { B_atomG_methods.__deserialize__ = B_atomD___deserialize__; } { - B_intG_methods.$GCINFO = "B_int"; + memset(B_intD_gcbm, 0xFF, sizeof(B_intD_gcbm)); + B_intG_methods.$GCdescr = GC_make_descriptor(B_intD_gcbm, GC_WORD_LEN(struct B_int)); + B_intG_methods.$name = "B_int"; B_intG_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_intG_methods.__bool__ = B_intD___bool__; B_intG_methods.__str__ = B_intD___str__; @@ -4536,7 +4704,9 @@ void B___init__ () { B_intG_methods.__deserialize__ = B_intD___deserialize__; } { - B_i64G_methods.$GCINFO = "B_i64"; + memset(B_i64D_gcbm, 0xFF, sizeof(B_i64D_gcbm)); + B_i64G_methods.$GCdescr = GC_make_descriptor(B_i64D_gcbm, GC_WORD_LEN(struct B_i64)); + B_i64G_methods.$name = "B_i64"; B_i64G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_i64G_methods.__bool__ = B_i64D___bool__; B_i64G_methods.__str__ = B_i64D___str__; @@ -4546,7 +4716,9 @@ void B___init__ () { B_i64G_methods.__deserialize__ = B_i64D___deserialize__; } { - B_i32G_methods.$GCINFO = "B_i32"; + memset(B_i32D_gcbm, 0xFF, sizeof(B_i32D_gcbm)); + B_i32G_methods.$GCdescr = GC_make_descriptor(B_i32D_gcbm, GC_WORD_LEN(struct B_i32)); + B_i32G_methods.$name = "B_i32"; B_i32G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_i32G_methods.__bool__ = B_i32D___bool__; B_i32G_methods.__str__ = B_i32D___str__; @@ -4556,7 +4728,9 @@ void B___init__ () { B_i32G_methods.__deserialize__ = B_i32D___deserialize__; } { - B_i16G_methods.$GCINFO = "B_i16"; + memset(B_i16D_gcbm, 0xFF, sizeof(B_i16D_gcbm)); + B_i16G_methods.$GCdescr = GC_make_descriptor(B_i16D_gcbm, GC_WORD_LEN(struct B_i16)); + B_i16G_methods.$name = "B_i16"; B_i16G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_i16G_methods.__bool__ = B_i16D___bool__; B_i16G_methods.__str__ = B_i16D___str__; @@ -4566,7 +4740,9 @@ void B___init__ () { B_i16G_methods.__deserialize__ = B_i16D___deserialize__; } { - B_u64G_methods.$GCINFO = "B_u64"; + memset(B_u64D_gcbm, 0xFF, sizeof(B_u64D_gcbm)); + B_u64G_methods.$GCdescr = GC_make_descriptor(B_u64D_gcbm, GC_WORD_LEN(struct B_u64)); + B_u64G_methods.$name = "B_u64"; B_u64G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_u64G_methods.__bool__ = B_u64D___bool__; B_u64G_methods.__str__ = B_u64D___str__; @@ -4576,7 +4752,9 @@ void B___init__ () { B_u64G_methods.__deserialize__ = B_u64D___deserialize__; } { - B_u32G_methods.$GCINFO = "B_u32"; + memset(B_u32D_gcbm, 0xFF, sizeof(B_u32D_gcbm)); + B_u32G_methods.$GCdescr = GC_make_descriptor(B_u32D_gcbm, GC_WORD_LEN(struct B_u32)); + B_u32G_methods.$name = "B_u32"; B_u32G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_u32G_methods.__bool__ = B_u32D___bool__; B_u32G_methods.__str__ = B_u32D___str__; @@ -4586,7 +4764,9 @@ void B___init__ () { B_u32G_methods.__deserialize__ = B_u32D___deserialize__; } { - B_u16G_methods.$GCINFO = "B_u16"; + memset(B_u16D_gcbm, 0xFF, sizeof(B_u16D_gcbm)); + B_u16G_methods.$GCdescr = GC_make_descriptor(B_u16D_gcbm, GC_WORD_LEN(struct B_u16)); + B_u16G_methods.$name = "B_u16"; B_u16G_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_u16G_methods.__bool__ = B_u16D___bool__; B_u16G_methods.__str__ = B_u16D___str__; @@ -4596,7 +4776,9 @@ void B___init__ () { B_u16G_methods.__deserialize__ = B_u16D___deserialize__; } { - B_floatG_methods.$GCINFO = "B_float"; + memset(B_floatD_gcbm, 0xFF, sizeof(B_floatD_gcbm)); + B_floatG_methods.$GCdescr = GC_make_descriptor(B_floatD_gcbm, GC_WORD_LEN(struct B_float)); + B_floatG_methods.$name = "B_float"; B_floatG_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_floatG_methods.__bool__ = B_floatD___bool__; B_floatG_methods.__str__ = B_floatD___str__; @@ -4606,7 +4788,9 @@ void B___init__ () { B_floatG_methods.__deserialize__ = B_floatD___deserialize__; } { - B_boolG_methods.$GCINFO = "B_bool"; + memset(B_boolD_gcbm, 0xFF, sizeof(B_boolD_gcbm)); + B_boolG_methods.$GCdescr = GC_make_descriptor(B_boolD_gcbm, GC_WORD_LEN(struct B_bool)); + B_boolG_methods.$name = "B_bool"; B_boolG_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_boolG_methods.__bool__ = B_boolD___bool__; B_boolG_methods.__str__ = B_boolD___str__; @@ -4616,7 +4800,9 @@ void B___init__ () { B_boolG_methods.__deserialize__ = B_boolD___deserialize__; } { - B_sliceG_methods.$GCINFO = "B_slice"; + memset(B_sliceD_gcbm, 0xFF, sizeof(B_sliceD_gcbm)); + B_sliceG_methods.$GCdescr = GC_make_descriptor(B_sliceD_gcbm, GC_WORD_LEN(struct B_slice)); + B_sliceG_methods.$name = "B_slice"; B_sliceG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_sliceG_methods.__bool__ = (B_bool (*) (B_slice))B_valueG_methods.__bool__; B_sliceG_methods.__str__ = (B_str (*) (B_slice))B_valueG_methods.__str__; @@ -4626,7 +4812,9 @@ void B___init__ () { B_sliceG_methods.__deserialize__ = B_sliceD___deserialize__; } { - B_listG_methods.$GCINFO = "B_list"; + memset(B_listD_gcbm, 0xFF, sizeof(B_listD_gcbm)); + B_listG_methods.$GCdescr = GC_make_descriptor(B_listD_gcbm, GC_WORD_LEN(struct B_list)); + B_listG_methods.$name = "B_list"; B_listG_methods.$superclass = ($SuperG_class)&B_objectG_methods; B_listG_methods.__bool__ = B_listD___bool__; B_listG_methods.__str__ = B_listD___str__; @@ -4640,7 +4828,9 @@ void B___init__ () { B_listG_methods.pop = B_listD_pop; } { - B_rangeG_methods.$GCINFO = "B_range"; + memset(B_rangeD_gcbm, 0xFF, sizeof(B_rangeD_gcbm)); + B_rangeG_methods.$GCdescr = GC_make_descriptor(B_rangeD_gcbm, GC_WORD_LEN(struct B_range)); + B_rangeG_methods.$name = "B_range"; B_rangeG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_rangeG_methods.__bool__ = (B_bool (*) (B_range))B_valueG_methods.__bool__; B_rangeG_methods.__str__ = (B_str (*) (B_range))B_valueG_methods.__str__; @@ -4650,7 +4840,9 @@ void B___init__ () { B_rangeG_methods.__deserialize__ = B_rangeD___deserialize__; } { - B_IteratorG_methods.$GCINFO = "B_Iterator"; + memset(B_IteratorD_gcbm, 0xFF, sizeof(B_IteratorD_gcbm)); + B_IteratorG_methods.$GCdescr = GC_make_descriptor(B_IteratorD_gcbm, GC_WORD_LEN(struct B_Iterator)); + B_IteratorG_methods.$name = "B_Iterator"; B_IteratorG_methods.$superclass = ($SuperG_class)&B_objectG_methods; B_IteratorG_methods.__bool__ = (B_bool (*) (B_Iterator))B_valueG_methods.__bool__; B_IteratorG_methods.__str__ = (B_str (*) (B_Iterator))B_valueG_methods.__str__; @@ -4659,7 +4851,9 @@ void B___init__ () { B_IteratorG_methods.__deserialize__ = B_IteratorD___deserialize__; } { - B_IterableG_methods.$GCINFO = "B_Iterable"; + memset(B_IterableD_gcbm, 0xFF, sizeof(B_IterableD_gcbm)); + B_IterableG_methods.$GCdescr = GC_make_descriptor(B_IterableD_gcbm, GC_WORD_LEN(struct B_Iterable)); + B_IterableG_methods.$name = "B_Iterable"; B_IterableG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_IterableG_methods.__bool__ = (B_bool (*) (B_Iterable))B_valueG_methods.__bool__; B_IterableG_methods.__str__ = (B_str (*) (B_Iterable))B_valueG_methods.__str__; @@ -4670,7 +4864,9 @@ void B___init__ () { $register(&B_IterableG_methods); } { - B_strG_methods.$GCINFO = "B_str"; + memset(B_strD_gcbm, 0xFF, sizeof(B_strD_gcbm)); + B_strG_methods.$GCdescr = GC_make_descriptor(B_strD_gcbm, GC_WORD_LEN(struct B_str)); + B_strG_methods.$name = "B_str"; B_strG_methods.$superclass = ($SuperG_class)&B_atomG_methods; B_strG_methods.__bool__ = (B_bool (*) (B_str))B_valueG_methods.__bool__; B_strG_methods.__str__ = B_strD___str__; @@ -4714,7 +4910,9 @@ void B___init__ () { B_strG_methods.__deserialize__ = B_strD___deserialize__; } { - B_bytesG_methods.$GCINFO = "B_bytes"; + memset(B_bytesD_gcbm, 0xFF, sizeof(B_bytesD_gcbm)); + B_bytesG_methods.$GCdescr = GC_make_descriptor(B_bytesD_gcbm, GC_WORD_LEN(struct B_bytes)); + B_bytesG_methods.$name = "B_bytes"; B_bytesG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_bytesG_methods.__bool__ = (B_bool (*) (B_bytes))B_valueG_methods.__bool__; B_bytesG_methods.__str__ = B_bytesD___str__; @@ -4757,7 +4955,9 @@ void B___init__ () { B_bytesG_methods.__deserialize__ = B_bytesD___deserialize__; } { - B_bytearrayG_methods.$GCINFO = "B_bytearray"; + memset(B_bytearrayD_gcbm, 0xFF, sizeof(B_bytearrayD_gcbm)); + B_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_bytearrayD_gcbm, GC_WORD_LEN(struct B_bytearray)); + B_bytearrayG_methods.$name = "B_bytearray"; B_bytearrayG_methods.$superclass = ($SuperG_class)&B_objectG_methods; B_bytearrayG_methods.__bool__ = (B_bool (*) (B_bytearray))B_valueG_methods.__bool__; B_bytearrayG_methods.__str__ = B_bytearrayD___str__; @@ -4801,7 +5001,9 @@ void B___init__ () { } /* { - B_MsgG_methods.$GCINFO = "B_Msg"; + memset(B_MsgD_gcbm, 0xFF, sizeof(B_MsgD_gcbm)); + B_MsgG_methods.$GCdescr = GC_make_descriptor(B_MsgD_gcbm, GC_WORD_LEN(struct B_Msg)); + B_MsgG_methods.$name = "B_Msg"; B_MsgG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_MsgG_methods.__bool__ = (B_bool (*) (B_Msg))B_valueG_methods.__bool__; B_MsgG_methods.__str__ = (B_str (*) (B_Msg))B_valueG_methods.__str__; @@ -4812,7 +5014,9 @@ void B___init__ () { } */ { - B_BaseExceptionG_methods.$GCINFO = "B_BaseException"; + memset(B_BaseExceptionD_gcbm, 0xFF, sizeof(B_BaseExceptionD_gcbm)); + B_BaseExceptionG_methods.$GCdescr = GC_make_descriptor(B_BaseExceptionD_gcbm, GC_WORD_LEN(struct B_BaseException)); + B_BaseExceptionG_methods.$name = "B_BaseException"; B_BaseExceptionG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_BaseExceptionG_methods.__bool__ = (B_bool (*) (B_BaseException))B_valueG_methods.__bool__; B_BaseExceptionG_methods.__str__ = B_BaseExceptionD___str__; @@ -4822,7 +5026,9 @@ void B___init__ () { B_BaseExceptionG_methods.__deserialize__ = B_BaseExceptionD___deserialize__; } { - B_SystemExitG_methods.$GCINFO = "B_SystemExit"; + memset(B_SystemExitD_gcbm, 0xFF, sizeof(B_SystemExitD_gcbm)); + B_SystemExitG_methods.$GCdescr = GC_make_descriptor(B_SystemExitD_gcbm, GC_WORD_LEN(struct B_SystemExit)); + B_SystemExitG_methods.$name = "B_SystemExit"; B_SystemExitG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods; B_SystemExitG_methods.__init__ = (B_NoneType (*) (B_SystemExit, B_str))B_BaseExceptionG_methods.__init__; B_SystemExitG_methods.__bool__ = (B_bool (*) (B_SystemExit))B_valueG_methods.__bool__; @@ -4832,7 +5038,9 @@ void B___init__ () { B_SystemExitG_methods.__deserialize__ = B_SystemExitD___deserialize__; } { - B_KeyboardInterruptG_methods.$GCINFO = "B_KeyboardInterrupt"; + memset(B_KeyboardInterruptD_gcbm, 0xFF, sizeof(B_KeyboardInterruptD_gcbm)); + B_KeyboardInterruptG_methods.$GCdescr = GC_make_descriptor(B_KeyboardInterruptD_gcbm, GC_WORD_LEN(struct B_KeyboardInterrupt)); + B_KeyboardInterruptG_methods.$name = "B_KeyboardInterrupt"; B_KeyboardInterruptG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods; B_KeyboardInterruptG_methods.__init__ = (B_NoneType (*) (B_KeyboardInterrupt, B_str))B_BaseExceptionG_methods.__init__; B_KeyboardInterruptG_methods.__bool__ = (B_bool (*) (B_KeyboardInterrupt))B_valueG_methods.__bool__; @@ -4842,7 +5050,9 @@ void B___init__ () { B_KeyboardInterruptG_methods.__deserialize__ = B_KeyboardInterruptD___deserialize__; } { - B_ExceptionG_methods.$GCINFO = "B_Exception"; + memset(B_ExceptionD_gcbm, 0xFF, sizeof(B_ExceptionD_gcbm)); + B_ExceptionG_methods.$GCdescr = GC_make_descriptor(B_ExceptionD_gcbm, GC_WORD_LEN(struct B_Exception)); + B_ExceptionG_methods.$name = "B_Exception"; B_ExceptionG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods; B_ExceptionG_methods.__init__ = (B_NoneType (*) (B_Exception, B_str))B_BaseExceptionG_methods.__init__; B_ExceptionG_methods.__bool__ = (B_bool (*) (B_Exception))B_valueG_methods.__bool__; @@ -4852,7 +5062,9 @@ void B___init__ () { B_ExceptionG_methods.__deserialize__ = B_ExceptionD___deserialize__; } { - B_AssertionErrorG_methods.$GCINFO = "B_AssertionError"; + memset(B_AssertionErrorD_gcbm, 0xFF, sizeof(B_AssertionErrorD_gcbm)); + B_AssertionErrorG_methods.$GCdescr = GC_make_descriptor(B_AssertionErrorD_gcbm, GC_WORD_LEN(struct B_AssertionError)); + B_AssertionErrorG_methods.$name = "B_AssertionError"; B_AssertionErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_AssertionErrorG_methods.__init__ = (B_NoneType (*) (B_AssertionError, B_str))B_BaseExceptionG_methods.__init__; B_AssertionErrorG_methods.__bool__ = (B_bool (*) (B_AssertionError))B_valueG_methods.__bool__; @@ -4862,7 +5074,9 @@ void B___init__ () { B_AssertionErrorG_methods.__deserialize__ = B_AssertionErrorD___deserialize__; } { - B_LookupErrorG_methods.$GCINFO = "B_LookupError"; + memset(B_LookupErrorD_gcbm, 0xFF, sizeof(B_LookupErrorD_gcbm)); + B_LookupErrorG_methods.$GCdescr = GC_make_descriptor(B_LookupErrorD_gcbm, GC_WORD_LEN(struct B_LookupError)); + B_LookupErrorG_methods.$name = "B_LookupError"; B_LookupErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_LookupErrorG_methods.__init__ = (B_NoneType (*) (B_LookupError, B_str))B_BaseExceptionG_methods.__init__; B_LookupErrorG_methods.__bool__ = (B_bool (*) (B_LookupError))B_valueG_methods.__bool__; @@ -4872,7 +5086,9 @@ void B___init__ () { B_LookupErrorG_methods.__deserialize__ = B_LookupErrorD___deserialize__; } { - B_IndexErrorG_methods.$GCINFO = "B_IndexError"; + memset(B_IndexErrorD_gcbm, 0xFF, sizeof(B_IndexErrorD_gcbm)); + B_IndexErrorG_methods.$GCdescr = GC_make_descriptor(B_IndexErrorD_gcbm, GC_WORD_LEN(struct B_IndexError)); + B_IndexErrorG_methods.$name = "B_IndexError"; B_IndexErrorG_methods.$superclass = ($SuperG_class)&B_LookupErrorG_methods; B_IndexErrorG_methods.__init__ = (B_NoneType (*) (B_IndexError, B_str))B_BaseExceptionG_methods.__init__; B_IndexErrorG_methods.__bool__ = (B_bool (*) (B_IndexError))B_valueG_methods.__bool__; @@ -4882,7 +5098,9 @@ void B___init__ () { B_IndexErrorG_methods.__deserialize__ = B_IndexErrorD___deserialize__; } { - B_KeyErrorG_methods.$GCINFO = "B_KeyError"; + memset(B_KeyErrorD_gcbm, 0xFF, sizeof(B_KeyErrorD_gcbm)); + B_KeyErrorG_methods.$GCdescr = GC_make_descriptor(B_KeyErrorD_gcbm, GC_WORD_LEN(struct B_KeyError)); + B_KeyErrorG_methods.$name = "B_KeyError"; B_KeyErrorG_methods.$superclass = ($SuperG_class)&B_LookupErrorG_methods; B_KeyErrorG_methods.__init__ = (B_NoneType (*) (B_KeyError, B_str))B_BaseExceptionG_methods.__init__; B_KeyErrorG_methods.__bool__ = (B_bool (*) (B_KeyError))B_valueG_methods.__bool__; @@ -4892,7 +5110,9 @@ void B___init__ () { B_KeyErrorG_methods.__deserialize__ = B_KeyErrorD___deserialize__; } { - B_MemoryErrorG_methods.$GCINFO = "B_MemoryError"; + memset(B_MemoryErrorD_gcbm, 0xFF, sizeof(B_MemoryErrorD_gcbm)); + B_MemoryErrorG_methods.$GCdescr = GC_make_descriptor(B_MemoryErrorD_gcbm, GC_WORD_LEN(struct B_MemoryError)); + B_MemoryErrorG_methods.$name = "B_MemoryError"; B_MemoryErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_MemoryErrorG_methods.__init__ = (B_NoneType (*) (B_MemoryError, B_str))B_BaseExceptionG_methods.__init__; B_MemoryErrorG_methods.__bool__ = (B_bool (*) (B_MemoryError))B_valueG_methods.__bool__; @@ -4902,7 +5122,9 @@ void B___init__ () { B_MemoryErrorG_methods.__deserialize__ = B_MemoryErrorD___deserialize__; } { - B_OSErrorG_methods.$GCINFO = "B_OSError"; + memset(B_OSErrorD_gcbm, 0xFF, sizeof(B_OSErrorD_gcbm)); + B_OSErrorG_methods.$GCdescr = GC_make_descriptor(B_OSErrorD_gcbm, GC_WORD_LEN(struct B_OSError)); + B_OSErrorG_methods.$name = "B_OSError"; B_OSErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_OSErrorG_methods.__init__ = (B_NoneType (*) (B_OSError, B_str))B_BaseExceptionG_methods.__init__; B_OSErrorG_methods.__bool__ = (B_bool (*) (B_OSError))B_valueG_methods.__bool__; @@ -4912,7 +5134,9 @@ void B___init__ () { B_OSErrorG_methods.__deserialize__ = B_OSErrorD___deserialize__; } { - B_RuntimeErrorG_methods.$GCINFO = "B_RuntimeError"; + memset(B_RuntimeErrorD_gcbm, 0xFF, sizeof(B_RuntimeErrorD_gcbm)); + B_RuntimeErrorG_methods.$GCdescr = GC_make_descriptor(B_RuntimeErrorD_gcbm, GC_WORD_LEN(struct B_RuntimeError)); + B_RuntimeErrorG_methods.$name = "B_RuntimeError"; B_RuntimeErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_RuntimeErrorG_methods.__init__ = (B_NoneType (*) (B_RuntimeError, B_str))B_BaseExceptionG_methods.__init__; B_RuntimeErrorG_methods.__bool__ = (B_bool (*) (B_RuntimeError))B_valueG_methods.__bool__; @@ -4922,7 +5146,9 @@ void B___init__ () { B_RuntimeErrorG_methods.__deserialize__ = B_RuntimeErrorD___deserialize__; } { - B_NotImplementedErrorG_methods.$GCINFO = "B_NotImplementedError"; + memset(B_NotImplementedErrorD_gcbm, 0xFF, sizeof(B_NotImplementedErrorD_gcbm)); + B_NotImplementedErrorG_methods.$GCdescr = GC_make_descriptor(B_NotImplementedErrorD_gcbm, GC_WORD_LEN(struct B_NotImplementedError)); + B_NotImplementedErrorG_methods.$name = "B_NotImplementedError"; B_NotImplementedErrorG_methods.$superclass = ($SuperG_class)&B_RuntimeErrorG_methods; B_NotImplementedErrorG_methods.__init__ = (B_NoneType (*) (B_NotImplementedError, B_str))B_BaseExceptionG_methods.__init__; B_NotImplementedErrorG_methods.__bool__ = (B_bool (*) (B_NotImplementedError))B_valueG_methods.__bool__; @@ -4932,7 +5158,9 @@ void B___init__ () { B_NotImplementedErrorG_methods.__deserialize__ = B_NotImplementedErrorD___deserialize__; } { - B_ValueErrorG_methods.$GCINFO = "B_ValueError"; + memset(B_ValueErrorD_gcbm, 0xFF, sizeof(B_ValueErrorD_gcbm)); + B_ValueErrorG_methods.$GCdescr = GC_make_descriptor(B_ValueErrorD_gcbm, GC_WORD_LEN(struct B_ValueError)); + B_ValueErrorG_methods.$name = "B_ValueError"; B_ValueErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods; B_ValueErrorG_methods.__init__ = (B_NoneType (*) (B_ValueError, B_str))B_BaseExceptionG_methods.__init__; B_ValueErrorG_methods.__bool__ = (B_bool (*) (B_ValueError))B_valueG_methods.__bool__; @@ -4942,7 +5170,9 @@ void B___init__ () { B_ValueErrorG_methods.__deserialize__ = B_ValueErrorD___deserialize__; } { - B_IdentityG_methods.$GCINFO = "B_Identity"; + memset(B_IdentityD_gcbm, 0xFF, sizeof(B_IdentityD_gcbm)); + B_IdentityG_methods.$GCdescr = GC_make_descriptor(B_IdentityD_gcbm, GC_WORD_LEN(struct B_Identity)); + B_IdentityG_methods.$name = "B_Identity"; B_IdentityG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_IdentityG_methods.__bool__ = (B_bool (*) (B_Identity))B_valueG_methods.__bool__; B_IdentityG_methods.__str__ = (B_str (*) (B_Identity))B_valueG_methods.__str__; @@ -4953,7 +5183,9 @@ void B___init__ () { $register(&B_IdentityG_methods); } { - B_EqG_methods.$GCINFO = "B_Eq"; + memset(B_EqD_gcbm, 0xFF, sizeof(B_EqD_gcbm)); + B_EqG_methods.$GCdescr = GC_make_descriptor(B_EqD_gcbm, GC_WORD_LEN(struct B_Eq)); + B_EqG_methods.$name = "B_Eq"; B_EqG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_EqG_methods.__bool__ = (B_bool (*) (B_Eq))B_valueG_methods.__bool__; B_EqG_methods.__str__ = (B_str (*) (B_Eq))B_valueG_methods.__str__; @@ -4965,7 +5197,9 @@ void B___init__ () { $register(&B_EqG_methods); } { - B_OrdG_methods.$GCINFO = "B_Ord"; + memset(B_OrdD_gcbm, 0xFF, sizeof(B_OrdD_gcbm)); + B_OrdG_methods.$GCdescr = GC_make_descriptor(B_OrdD_gcbm, GC_WORD_LEN(struct B_Ord)); + B_OrdG_methods.$name = "B_Ord"; B_OrdG_methods.$superclass = ($SuperG_class)&B_EqG_methods; B_OrdG_methods.__bool__ = (B_bool (*) (B_Ord))B_valueG_methods.__bool__; B_OrdG_methods.__str__ = (B_str (*) (B_Ord))B_valueG_methods.__str__; @@ -4980,7 +5214,9 @@ void B___init__ () { $register(&B_OrdG_methods); } { - B_LogicalG_methods.$GCINFO = "B_Logical"; + memset(B_LogicalD_gcbm, 0xFF, sizeof(B_LogicalD_gcbm)); + B_LogicalG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_gcbm, GC_WORD_LEN(struct B_Logical)); + B_LogicalG_methods.$name = "B_Logical"; B_LogicalG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_LogicalG_methods.__bool__ = (B_bool (*) (B_Logical))B_valueG_methods.__bool__; B_LogicalG_methods.__str__ = (B_str (*) (B_Logical))B_valueG_methods.__str__; @@ -4994,7 +5230,9 @@ void B___init__ () { $register(&B_LogicalG_methods); } { - B_PlusG_methods.$GCINFO = "B_Plus"; + memset(B_PlusD_gcbm, 0xFF, sizeof(B_PlusD_gcbm)); + B_PlusG_methods.$GCdescr = GC_make_descriptor(B_PlusD_gcbm, GC_WORD_LEN(struct B_Plus)); + B_PlusG_methods.$name = "B_Plus"; B_PlusG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_PlusG_methods.__bool__ = (B_bool (*) (B_Plus))B_valueG_methods.__bool__; B_PlusG_methods.__str__ = (B_str (*) (B_Plus))B_valueG_methods.__str__; @@ -5006,7 +5244,9 @@ void B___init__ () { $register(&B_PlusG_methods); } { - B_MinusG_methods.$GCINFO = "B_Minus"; + memset(B_MinusD_gcbm, 0xFF, sizeof(B_MinusD_gcbm)); + B_MinusG_methods.$GCdescr = GC_make_descriptor(B_MinusD_gcbm, GC_WORD_LEN(struct B_Minus)); + B_MinusG_methods.$name = "B_Minus"; B_MinusG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_MinusG_methods.__bool__ = (B_bool (*) (B_Minus))B_valueG_methods.__bool__; B_MinusG_methods.__str__ = (B_str (*) (B_Minus))B_valueG_methods.__str__; @@ -5018,7 +5258,9 @@ void B___init__ () { $register(&B_MinusG_methods); } { - B_TimesG_methods.$GCINFO = "B_Times"; + memset(B_TimesD_gcbm, 0xFF, sizeof(B_TimesD_gcbm)); + B_TimesG_methods.$GCdescr = GC_make_descriptor(B_TimesD_gcbm, GC_WORD_LEN(struct B_Times)); + B_TimesG_methods.$name = "B_Times"; B_TimesG_methods.$superclass = ($SuperG_class)&B_PlusG_methods; B_TimesG_methods.__bool__ = (B_bool (*) (B_Times))B_valueG_methods.__bool__; B_TimesG_methods.__str__ = (B_str (*) (B_Times))B_valueG_methods.__str__; @@ -5031,7 +5273,9 @@ void B___init__ () { $register(&B_TimesG_methods); } { - B_DivG_methods.$GCINFO = "B_Div"; + memset(B_DivD_gcbm, 0xFF, sizeof(B_DivD_gcbm)); + B_DivG_methods.$GCdescr = GC_make_descriptor(B_DivD_gcbm, GC_WORD_LEN(struct B_Div)); + B_DivG_methods.$name = "B_Div"; B_DivG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_DivG_methods.__bool__ = (B_bool (*) (B_Div))B_valueG_methods.__bool__; B_DivG_methods.__str__ = (B_str (*) (B_Div))B_valueG_methods.__str__; @@ -5043,7 +5287,9 @@ void B___init__ () { $register(&B_DivG_methods); } { - B_HashableG_methods.$GCINFO = "B_Hashable"; + memset(B_HashableD_gcbm, 0xFF, sizeof(B_HashableD_gcbm)); + B_HashableG_methods.$GCdescr = GC_make_descriptor(B_HashableD_gcbm, GC_WORD_LEN(struct B_Hashable)); + B_HashableG_methods.$name = "B_Hashable"; B_HashableG_methods.$superclass = ($SuperG_class)&B_EqG_methods; B_HashableG_methods.__bool__ = (B_bool (*) (B_Hashable))B_valueG_methods.__bool__; B_HashableG_methods.__str__ = (B_str (*) (B_Hashable))B_valueG_methods.__str__; @@ -5055,7 +5301,9 @@ void B___init__ () { $register(&B_HashableG_methods); } { - B_complexG_methods.$GCINFO = "B_complex"; + memset(B_complexD_gcbm, 0xFF, sizeof(B_complexD_gcbm)); + B_complexG_methods.$GCdescr = GC_make_descriptor(B_complexD_gcbm, GC_WORD_LEN(struct B_complex)); + B_complexG_methods.$name = "B_complex"; B_complexG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_complexG_methods.__bool__ = (B_bool (*) (B_complex))B_valueG_methods.__bool__; B_complexG_methods.__str__ = B_complexD___str__; @@ -5065,7 +5313,9 @@ void B___init__ () { B_complexG_methods.__deserialize__ = B_complexD___deserialize__; } { - B_dictG_methods.$GCINFO = "B_dict"; + memset(B_dictD_gcbm, 0xFF, sizeof(B_dictD_gcbm)); + B_dictG_methods.$GCdescr = GC_make_descriptor(B_dictD_gcbm, GC_WORD_LEN(struct B_dict)); + B_dictG_methods.$name = "B_dict"; B_dictG_methods.$superclass = ($SuperG_class)&B_objectG_methods; B_dictG_methods.__bool__ = (B_bool (*) (B_dict))B_valueG_methods.__bool__; B_dictG_methods.__str__ = B_dictD___str__; @@ -5075,7 +5325,9 @@ void B___init__ () { B_dictG_methods.__deserialize__ = B_dictD___deserialize__; } { - B_setG_methods.$GCINFO = "B_set"; + memset(B_setD_gcbm, 0xFF, sizeof(B_setD_gcbm)); + B_setG_methods.$GCdescr = GC_make_descriptor(B_setD_gcbm, GC_WORD_LEN(struct B_set)); + B_setG_methods.$name = "B_set"; B_setG_methods.$superclass = ($SuperG_class)&B_objectG_methods; B_setG_methods.__bool__ = (B_bool (*) (B_set))B_valueG_methods.__bool__; B_setG_methods.__str__ = B_setD___str__; @@ -5085,7 +5337,9 @@ void B___init__ () { B_setG_methods.__deserialize__ = B_setD___deserialize__; } { - B_NumberG_methods.$GCINFO = "B_Number"; + memset(B_NumberD_gcbm, 0xFF, sizeof(B_NumberD_gcbm)); + B_NumberG_methods.$GCdescr = GC_make_descriptor(B_NumberD_gcbm, GC_WORD_LEN(struct B_Number)); + B_NumberG_methods.$name = "B_Number"; B_NumberG_methods.$superclass = ($SuperG_class)&B_TimesG_methods; B_NumberG_methods.__bool__ = (B_bool (*) (B_Number))B_valueG_methods.__bool__; B_NumberG_methods.__str__ = (B_str (*) (B_Number))B_valueG_methods.__str__; @@ -5099,7 +5353,9 @@ void B___init__ () { $register(&B_NumberG_methods); } { - B_MinusD_NumberG_methods.$GCINFO = "B_MinusD_Number"; + memset(B_MinusD_NumberD_gcbm, 0xFF, sizeof(B_MinusD_NumberD_gcbm)); + B_MinusD_NumberG_methods.$GCdescr = GC_make_descriptor(B_MinusD_NumberD_gcbm, GC_WORD_LEN(struct B_MinusD_Number)); + B_MinusD_NumberG_methods.$name = "B_MinusD_Number"; B_MinusD_NumberG_methods.$superclass = ($SuperG_class)&B_MinusG_methods; B_MinusD_NumberG_methods.__bool__ = (B_bool (*) (B_MinusD_Number))B_valueG_methods.__bool__; B_MinusD_NumberG_methods.__str__ = (B_str (*) (B_MinusD_Number))B_valueG_methods.__str__; @@ -5111,7 +5367,9 @@ void B___init__ () { $register(&B_MinusD_NumberG_methods); } { - B_RealG_methods.$GCINFO = "B_Real"; + memset(B_RealD_gcbm, 0xFF, sizeof(B_RealD_gcbm)); + B_RealG_methods.$GCdescr = GC_make_descriptor(B_RealD_gcbm, GC_WORD_LEN(struct B_Real)); + B_RealG_methods.$name = "B_Real"; B_RealG_methods.$superclass = ($SuperG_class)&B_NumberG_methods; B_RealG_methods.__bool__ = (B_bool (*) (B_Real))B_valueG_methods.__bool__; B_RealG_methods.__str__ = (B_str (*) (B_Real))B_valueG_methods.__str__; @@ -5125,7 +5383,9 @@ void B___init__ () { $register(&B_RealG_methods); } { - B_MinusD_RealG_methods.$GCINFO = "B_MinusD_Real"; + memset(B_MinusD_RealD_gcbm, 0xFF, sizeof(B_MinusD_RealD_gcbm)); + B_MinusD_RealG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealD_gcbm, GC_WORD_LEN(struct B_MinusD_Real)); + B_MinusD_RealG_methods.$name = "B_MinusD_Real"; B_MinusD_RealG_methods.$superclass = ($SuperG_class)&B_MinusD_NumberG_methods; B_MinusD_RealG_methods.__bool__ = (B_bool (*) (B_MinusD_Real))B_valueG_methods.__bool__; B_MinusD_RealG_methods.__str__ = (B_str (*) (B_MinusD_Real))B_valueG_methods.__str__; @@ -5137,7 +5397,9 @@ void B___init__ () { $register(&B_MinusD_RealG_methods); } { - B_RealFloatG_methods.$GCINFO = "B_RealFloat"; + memset(B_RealFloatD_gcbm, 0xFF, sizeof(B_RealFloatD_gcbm)); + B_RealFloatG_methods.$GCdescr = GC_make_descriptor(B_RealFloatD_gcbm, GC_WORD_LEN(struct B_RealFloat)); + B_RealFloatG_methods.$name = "B_RealFloat"; B_RealFloatG_methods.$superclass = ($SuperG_class)&B_RealG_methods; B_RealFloatG_methods.__bool__ = (B_bool (*) (B_RealFloat))B_valueG_methods.__bool__; B_RealFloatG_methods.__str__ = (B_str (*) (B_RealFloat))B_valueG_methods.__str__; @@ -5151,7 +5413,9 @@ void B___init__ () { $register(&B_RealFloatG_methods); } { - B_MinusD_RealFloatG_methods.$GCINFO = "B_MinusD_RealFloat"; + memset(B_MinusD_RealFloatD_gcbm, 0xFF, sizeof(B_MinusD_RealFloatD_gcbm)); + B_MinusD_RealFloatG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealFloatD_gcbm, GC_WORD_LEN(struct B_MinusD_RealFloat)); + B_MinusD_RealFloatG_methods.$name = "B_MinusD_RealFloat"; B_MinusD_RealFloatG_methods.$superclass = ($SuperG_class)&B_MinusD_RealG_methods; B_MinusD_RealFloatG_methods.__bool__ = (B_bool (*) (B_MinusD_RealFloat))B_valueG_methods.__bool__; B_MinusD_RealFloatG_methods.__str__ = (B_str (*) (B_MinusD_RealFloat))B_valueG_methods.__str__; @@ -5163,7 +5427,9 @@ void B___init__ () { $register(&B_MinusD_RealFloatG_methods); } { - B_RationalG_methods.$GCINFO = "B_Rational"; + memset(B_RationalD_gcbm, 0xFF, sizeof(B_RationalD_gcbm)); + B_RationalG_methods.$GCdescr = GC_make_descriptor(B_RationalD_gcbm, GC_WORD_LEN(struct B_Rational)); + B_RationalG_methods.$name = "B_Rational"; B_RationalG_methods.$superclass = ($SuperG_class)&B_RealG_methods; B_RationalG_methods.__bool__ = (B_bool (*) (B_Rational))B_valueG_methods.__bool__; B_RationalG_methods.__str__ = (B_str (*) (B_Rational))B_valueG_methods.__str__; @@ -5177,7 +5443,9 @@ void B___init__ () { $register(&B_RationalG_methods); } { - B_MinusD_RationalG_methods.$GCINFO = "B_MinusD_Rational"; + memset(B_MinusD_RationalD_gcbm, 0xFF, sizeof(B_MinusD_RationalD_gcbm)); + B_MinusD_RationalG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RationalD_gcbm, GC_WORD_LEN(struct B_MinusD_Rational)); + B_MinusD_RationalG_methods.$name = "B_MinusD_Rational"; B_MinusD_RationalG_methods.$superclass = ($SuperG_class)&B_MinusD_RealG_methods; B_MinusD_RationalG_methods.__bool__ = (B_bool (*) (B_MinusD_Rational))B_valueG_methods.__bool__; B_MinusD_RationalG_methods.__str__ = (B_str (*) (B_MinusD_Rational))B_valueG_methods.__str__; @@ -5189,7 +5457,9 @@ void B___init__ () { $register(&B_MinusD_RationalG_methods); } { - B_IntegralG_methods.$GCINFO = "B_Integral"; + memset(B_IntegralD_gcbm, 0xFF, sizeof(B_IntegralD_gcbm)); + B_IntegralG_methods.$GCdescr = GC_make_descriptor(B_IntegralD_gcbm, GC_WORD_LEN(struct B_Integral)); + B_IntegralG_methods.$name = "B_Integral"; B_IntegralG_methods.$superclass = ($SuperG_class)&B_RationalG_methods; B_IntegralG_methods.__bool__ = (B_bool (*) (B_Integral))B_valueG_methods.__bool__; B_IntegralG_methods.__str__ = (B_str (*) (B_Integral))B_valueG_methods.__str__; @@ -5207,7 +5477,9 @@ void B___init__ () { $register(&B_IntegralG_methods); } { - B_MinusD_IntegralG_methods.$GCINFO = "B_MinusD_Integral"; + memset(B_MinusD_IntegralD_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_gcbm)); + B_MinusD_IntegralG_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_gcbm, GC_WORD_LEN(struct B_MinusD_Integral)); + B_MinusD_IntegralG_methods.$name = "B_MinusD_Integral"; B_MinusD_IntegralG_methods.$superclass = ($SuperG_class)&B_MinusD_RationalG_methods; B_MinusD_IntegralG_methods.__bool__ = (B_bool (*) (B_MinusD_Integral))B_valueG_methods.__bool__; B_MinusD_IntegralG_methods.__str__ = (B_str (*) (B_MinusD_Integral))B_valueG_methods.__str__; @@ -5219,7 +5491,9 @@ void B___init__ () { $register(&B_MinusD_IntegralG_methods); } { - B_LogicalD_IntegralG_methods.$GCINFO = "B_LogicalD_Integral"; + memset(B_LogicalD_IntegralD_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_gcbm)); + B_LogicalD_IntegralG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_gcbm, GC_WORD_LEN(struct B_LogicalD_Integral)); + B_LogicalD_IntegralG_methods.$name = "B_LogicalD_Integral"; B_LogicalD_IntegralG_methods.$superclass = ($SuperG_class)&B_LogicalG_methods; B_LogicalD_IntegralG_methods.__bool__ = (B_bool (*) (B_LogicalD_Integral))B_valueG_methods.__bool__; B_LogicalD_IntegralG_methods.__str__ = (B_str (*) (B_LogicalD_Integral))B_valueG_methods.__str__; @@ -5233,7 +5507,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralG_methods); } { - B_HashableD_boolG_methods.$GCINFO = "B_HashableD_bool"; + memset(B_HashableD_boolD_gcbm, 0xFF, sizeof(B_HashableD_boolD_gcbm)); + B_HashableD_boolG_methods.$GCdescr = GC_make_descriptor(B_HashableD_boolD_gcbm, GC_WORD_LEN(struct B_HashableD_bool)); + B_HashableD_boolG_methods.$name = "B_HashableD_bool"; B_HashableD_boolG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_boolG_methods.__bool__ = (B_bool (*) (B_HashableD_bool))B_valueG_methods.__bool__; B_HashableD_boolG_methods.__str__ = (B_str (*) (B_HashableD_bool))B_valueG_methods.__str__; @@ -5247,7 +5523,9 @@ void B___init__ () { $register(&B_HashableD_boolG_methods); } { - B_IntegralD_intG_methods.$GCINFO = "B_IntegralD_int"; + memset(B_IntegralD_intD_gcbm, 0xFF, sizeof(B_IntegralD_intD_gcbm)); + B_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_IntegralD_int)); + B_IntegralD_intG_methods.$name = "B_IntegralD_int"; B_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_IntegralD_int))B_valueG_methods.__bool__; B_IntegralD_intG_methods.__str__ = (B_str (*) (B_IntegralD_int))B_valueG_methods.__str__; @@ -5291,7 +5569,9 @@ void B___init__ () { $register(&B_IntegralD_intG_methods); } { - B_MinusD_IntegralD_intG_methods.$GCINFO = "B_MinusD_IntegralD_int"; + memset(B_MinusD_IntegralD_intD_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_intD_gcbm)); + B_MinusD_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_int)); + B_MinusD_IntegralD_intG_methods.$name = "B_MinusD_IntegralD_int"; B_MinusD_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_int))B_valueG_methods.__bool__; B_MinusD_IntegralD_intG_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_int))B_valueG_methods.__str__; @@ -5304,7 +5584,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_intG_methods); } { - B_LogicalD_IntegralD_intG_methods.$GCINFO = "B_LogicalD_IntegralD_int"; + memset(B_LogicalD_IntegralD_intD_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_intD_gcbm)); + B_LogicalD_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_int)); + B_LogicalD_IntegralD_intG_methods.$name = "B_LogicalD_IntegralD_int"; B_LogicalD_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_int))B_valueG_methods.__bool__; B_LogicalD_IntegralD_intG_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_int))B_valueG_methods.__str__; @@ -5321,7 +5603,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_intG_methods); } { - B_DivD_intG_methods.$GCINFO = "B_DivD_int"; + memset(B_DivD_intD_gcbm, 0xFF, sizeof(B_DivD_intD_gcbm)); + B_DivD_intG_methods.$GCdescr = GC_make_descriptor(B_DivD_intD_gcbm, GC_WORD_LEN(struct B_DivD_int)); + B_DivD_intG_methods.$name = "B_DivD_int"; B_DivD_intG_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_intG_methods.__bool__ = (B_bool (*) (B_DivD_int))B_valueG_methods.__bool__; B_DivD_intG_methods.__str__ = (B_str (*) (B_DivD_int))B_valueG_methods.__str__; @@ -5334,7 +5618,9 @@ void B___init__ () { $register(&B_DivD_intG_methods); } { - B_OrdD_intG_methods.$GCINFO = "B_OrdD_int"; + memset(B_OrdD_intD_gcbm, 0xFF, sizeof(B_OrdD_intD_gcbm)); + B_OrdD_intG_methods.$GCdescr = GC_make_descriptor(B_OrdD_intD_gcbm, GC_WORD_LEN(struct B_OrdD_int)); + B_OrdD_intG_methods.$name = "B_OrdD_int"; B_OrdD_intG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_intG_methods.__bool__ = (B_bool (*) (B_OrdD_int))B_valueG_methods.__bool__; B_OrdD_intG_methods.__str__ = (B_str (*) (B_OrdD_int))B_valueG_methods.__str__; @@ -5351,7 +5637,9 @@ void B___init__ () { $register(&B_OrdD_intG_methods); } { - B_HashableD_intG_methods.$GCINFO = "B_HashableD_int"; + memset(B_HashableD_intD_gcbm, 0xFF, sizeof(B_HashableD_intD_gcbm)); + B_HashableD_intG_methods.$GCdescr = GC_make_descriptor(B_HashableD_intD_gcbm, GC_WORD_LEN(struct B_HashableD_int)); + B_HashableD_intG_methods.$name = "B_HashableD_int"; B_HashableD_intG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_intG_methods.__bool__ = (B_bool (*) (B_HashableD_int))B_valueG_methods.__bool__; B_HashableD_intG_methods.__str__ = (B_str (*) (B_HashableD_int))B_valueG_methods.__str__; @@ -5371,7 +5659,9 @@ void B___init__ () { { - B_IntegralD_i64G_methods.$GCINFO = "B_IntegralD_i64"; + memset(B_IntegralD_i64D_gcbm, 0xFF, sizeof(B_IntegralD_i64D_gcbm)); + B_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_IntegralD_i64)); + B_IntegralD_i64G_methods.$name = "B_IntegralD_i64"; B_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_IntegralD_i64))B_valueG_methods.__bool__; B_IntegralD_i64G_methods.__str__ = (B_str (*) (B_IntegralD_i64))B_valueG_methods.__str__; @@ -5415,7 +5705,9 @@ void B___init__ () { $register(&B_IntegralD_i64G_methods); } { - B_MinusD_IntegralD_i64G_methods.$GCINFO = "B_MinusD_IntegralD_i64"; + memset(B_MinusD_IntegralD_i64D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i64D_gcbm)); + B_MinusD_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i64)); + B_MinusD_IntegralD_i64G_methods.$name = "B_MinusD_IntegralD_i64"; B_MinusD_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i64))B_valueG_methods.__bool__; B_MinusD_IntegralD_i64G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i64))B_valueG_methods.__str__; @@ -5428,7 +5720,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_i64G_methods); } { - B_LogicalD_IntegralD_i64G_methods.$GCINFO = "B_LogicalD_IntegralD_i64"; + memset(B_LogicalD_IntegralD_i64D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i64D_gcbm)); + B_LogicalD_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i64)); + B_LogicalD_IntegralD_i64G_methods.$name = "B_LogicalD_IntegralD_i64"; B_LogicalD_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i64))B_valueG_methods.__bool__; B_LogicalD_IntegralD_i64G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i64))B_valueG_methods.__str__; @@ -5445,7 +5739,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_i64G_methods); } { - B_DivD_i64G_methods.$GCINFO = "B_DivD_i64"; + memset(B_DivD_i64D_gcbm, 0xFF, sizeof(B_DivD_i64D_gcbm)); + B_DivD_i64G_methods.$GCdescr = GC_make_descriptor(B_DivD_i64D_gcbm, GC_WORD_LEN(struct B_DivD_i64)); + B_DivD_i64G_methods.$name = "B_DivD_i64"; B_DivD_i64G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_i64G_methods.__bool__ = (B_bool (*) (B_DivD_i64))B_valueG_methods.__bool__; B_DivD_i64G_methods.__str__ = (B_str (*) (B_DivD_i64))B_valueG_methods.__str__; @@ -5458,7 +5754,9 @@ void B___init__ () { $register(&B_DivD_i64G_methods); } { - B_OrdD_i64G_methods.$GCINFO = "B_OrdD_i64"; + memset(B_OrdD_i64D_gcbm, 0xFF, sizeof(B_OrdD_i64D_gcbm)); + B_OrdD_i64G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i64D_gcbm, GC_WORD_LEN(struct B_OrdD_i64)); + B_OrdD_i64G_methods.$name = "B_OrdD_i64"; B_OrdD_i64G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_i64G_methods.__bool__ = (B_bool (*) (B_OrdD_i64))B_valueG_methods.__bool__; B_OrdD_i64G_methods.__str__ = (B_str (*) (B_OrdD_i64))B_valueG_methods.__str__; @@ -5475,7 +5773,9 @@ void B___init__ () { $register(&B_OrdD_i64G_methods); } { - B_HashableD_i64G_methods.$GCINFO = "B_HashableD_i64"; + memset(B_HashableD_i64D_gcbm, 0xFF, sizeof(B_HashableD_i64D_gcbm)); + B_HashableD_i64G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i64D_gcbm, GC_WORD_LEN(struct B_HashableD_i64)); + B_HashableD_i64G_methods.$name = "B_HashableD_i64"; B_HashableD_i64G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_i64G_methods.__bool__ = (B_bool (*) (B_HashableD_i64))B_valueG_methods.__bool__; B_HashableD_i64G_methods.__str__ = (B_str (*) (B_HashableD_i64))B_valueG_methods.__str__; @@ -5492,7 +5792,9 @@ void B___init__ () { { - B_IntegralD_i32G_methods.$GCINFO = "B_IntegralD_i32"; + memset(B_IntegralD_i32D_gcbm, 0xFF, sizeof(B_IntegralD_i32D_gcbm)); + B_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_IntegralD_i32)); + B_IntegralD_i32G_methods.$name = "B_IntegralD_i32"; B_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_IntegralD_i32))B_valueG_methods.__bool__; B_IntegralD_i32G_methods.__str__ = (B_str (*) (B_IntegralD_i32))B_valueG_methods.__str__; @@ -5536,7 +5838,9 @@ void B___init__ () { $register(&B_IntegralD_i32G_methods); } { - B_MinusD_IntegralD_i32G_methods.$GCINFO = "B_MinusD_IntegralD_i32"; + memset(B_MinusD_IntegralD_i32D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i32D_gcbm)); + B_MinusD_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i32)); + B_MinusD_IntegralD_i32G_methods.$name = "B_MinusD_IntegralD_i32"; B_MinusD_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i32))B_valueG_methods.__bool__; B_MinusD_IntegralD_i32G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i32))B_valueG_methods.__str__; @@ -5549,7 +5853,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_i32G_methods); } { - B_LogicalD_IntegralD_i32G_methods.$GCINFO = "B_LogicalD_IntegralD_i32"; + memset(B_LogicalD_IntegralD_i32D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i32D_gcbm)); + B_LogicalD_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i32)); + B_LogicalD_IntegralD_i32G_methods.$name = "B_LogicalD_IntegralD_i32"; B_LogicalD_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i32))B_valueG_methods.__bool__; B_LogicalD_IntegralD_i32G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i32))B_valueG_methods.__str__; @@ -5566,7 +5872,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_i32G_methods); } { - B_DivD_i32G_methods.$GCINFO = "B_DivD_i32"; + memset(B_DivD_i32D_gcbm, 0xFF, sizeof(B_DivD_i32D_gcbm)); + B_DivD_i32G_methods.$GCdescr = GC_make_descriptor(B_DivD_i32D_gcbm, GC_WORD_LEN(struct B_DivD_i32)); + B_DivD_i32G_methods.$name = "B_DivD_i32"; B_DivD_i32G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_i32G_methods.__bool__ = (B_bool (*) (B_DivD_i32))B_valueG_methods.__bool__; B_DivD_i32G_methods.__str__ = (B_str (*) (B_DivD_i32))B_valueG_methods.__str__; @@ -5579,7 +5887,9 @@ void B___init__ () { $register(&B_DivD_i32G_methods); } { - B_OrdD_i32G_methods.$GCINFO = "B_OrdD_i32"; + memset(B_OrdD_i32D_gcbm, 0xFF, sizeof(B_OrdD_i32D_gcbm)); + B_OrdD_i32G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i32D_gcbm, GC_WORD_LEN(struct B_OrdD_i32)); + B_OrdD_i32G_methods.$name = "B_OrdD_i32"; B_OrdD_i32G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_i32G_methods.__bool__ = (B_bool (*) (B_OrdD_i32))B_valueG_methods.__bool__; B_OrdD_i32G_methods.__str__ = (B_str (*) (B_OrdD_i32))B_valueG_methods.__str__; @@ -5596,7 +5906,9 @@ void B___init__ () { $register(&B_OrdD_i32G_methods); } { - B_HashableD_i32G_methods.$GCINFO = "B_HashableD_i32"; + memset(B_HashableD_i32D_gcbm, 0xFF, sizeof(B_HashableD_i32D_gcbm)); + B_HashableD_i32G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i32D_gcbm, GC_WORD_LEN(struct B_HashableD_i32)); + B_HashableD_i32G_methods.$name = "B_HashableD_i32"; B_HashableD_i32G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_i32G_methods.__bool__ = (B_bool (*) (B_HashableD_i32))B_valueG_methods.__bool__; B_HashableD_i32G_methods.__str__ = (B_str (*) (B_HashableD_i32))B_valueG_methods.__str__; @@ -5613,7 +5925,9 @@ void B___init__ () { { - B_IntegralD_i16G_methods.$GCINFO = "B_IntegralD_i16"; + memset(B_IntegralD_i16D_gcbm, 0xFF, sizeof(B_IntegralD_i16D_gcbm)); + B_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_IntegralD_i16)); + B_IntegralD_i16G_methods.$name = "B_IntegralD_i16"; B_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_IntegralD_i16))B_valueG_methods.__bool__; B_IntegralD_i16G_methods.__str__ = (B_str (*) (B_IntegralD_i16))B_valueG_methods.__str__; @@ -5657,7 +5971,9 @@ void B___init__ () { $register(&B_IntegralD_i16G_methods); } { - B_MinusD_IntegralD_i16G_methods.$GCINFO = "B_MinusD_IntegralD_i16"; + memset(B_MinusD_IntegralD_i16D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i16D_gcbm)); + B_MinusD_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i16)); + B_MinusD_IntegralD_i16G_methods.$name = "B_MinusD_IntegralD_i16"; B_MinusD_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i16))B_valueG_methods.__bool__; B_MinusD_IntegralD_i16G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i16))B_valueG_methods.__str__; @@ -5670,7 +5986,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_i16G_methods); } { - B_LogicalD_IntegralD_i16G_methods.$GCINFO = "B_LogicalD_IntegralD_i16"; + memset(B_LogicalD_IntegralD_i16D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i16D_gcbm)); + B_LogicalD_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i16)); + B_LogicalD_IntegralD_i16G_methods.$name = "B_LogicalD_IntegralD_i16"; B_LogicalD_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i16))B_valueG_methods.__bool__; B_LogicalD_IntegralD_i16G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i16))B_valueG_methods.__str__; @@ -5687,7 +6005,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_i16G_methods); } { - B_DivD_i16G_methods.$GCINFO = "B_DivD_i16"; + memset(B_DivD_i16D_gcbm, 0xFF, sizeof(B_DivD_i16D_gcbm)); + B_DivD_i16G_methods.$GCdescr = GC_make_descriptor(B_DivD_i16D_gcbm, GC_WORD_LEN(struct B_DivD_i16)); + B_DivD_i16G_methods.$name = "B_DivD_i16"; B_DivD_i16G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_i16G_methods.__bool__ = (B_bool (*) (B_DivD_i16))B_valueG_methods.__bool__; B_DivD_i16G_methods.__str__ = (B_str (*) (B_DivD_i16))B_valueG_methods.__str__; @@ -5700,7 +6020,9 @@ void B___init__ () { $register(&B_DivD_i16G_methods); } { - B_OrdD_i16G_methods.$GCINFO = "B_OrdD_i16"; + memset(B_OrdD_i16D_gcbm, 0xFF, sizeof(B_OrdD_i16D_gcbm)); + B_OrdD_i16G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i16D_gcbm, GC_WORD_LEN(struct B_OrdD_i16)); + B_OrdD_i16G_methods.$name = "B_OrdD_i16"; B_OrdD_i16G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_i16G_methods.__bool__ = (B_bool (*) (B_OrdD_i16))B_valueG_methods.__bool__; B_OrdD_i16G_methods.__str__ = (B_str (*) (B_OrdD_i16))B_valueG_methods.__str__; @@ -5717,7 +6039,9 @@ void B___init__ () { $register(&B_OrdD_i16G_methods); } { - B_HashableD_i16G_methods.$GCINFO = "B_HashableD_i16"; + memset(B_HashableD_i16D_gcbm, 0xFF, sizeof(B_HashableD_i16D_gcbm)); + B_HashableD_i16G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i16D_gcbm, GC_WORD_LEN(struct B_HashableD_i16)); + B_HashableD_i16G_methods.$name = "B_HashableD_i16"; B_HashableD_i16G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_i16G_methods.__bool__ = (B_bool (*) (B_HashableD_i16))B_valueG_methods.__bool__; B_HashableD_i16G_methods.__str__ = (B_str (*) (B_HashableD_i16))B_valueG_methods.__str__; @@ -5736,7 +6060,9 @@ void B___init__ () { { - B_IntegralD_u64G_methods.$GCINFO = "B_IntegralD_u64"; + memset(B_IntegralD_u64D_gcbm, 0xFF, sizeof(B_IntegralD_u64D_gcbm)); + B_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_IntegralD_u64)); + B_IntegralD_u64G_methods.$name = "B_IntegralD_u64"; B_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_IntegralD_u64))B_valueG_methods.__bool__; B_IntegralD_u64G_methods.__str__ = (B_str (*) (B_IntegralD_u64))B_valueG_methods.__str__; @@ -5780,7 +6106,9 @@ void B___init__ () { $register(&B_IntegralD_u64G_methods); } { - B_MinusD_IntegralD_u64G_methods.$GCINFO = "B_MinusD_IntegralD_u64"; + memset(B_MinusD_IntegralD_u64D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u64D_gcbm)); + B_MinusD_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u64)); + B_MinusD_IntegralD_u64G_methods.$name = "B_MinusD_IntegralD_u64"; B_MinusD_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u64))B_valueG_methods.__bool__; B_MinusD_IntegralD_u64G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u64))B_valueG_methods.__str__; @@ -5793,7 +6121,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_u64G_methods); } { - B_LogicalD_IntegralD_u64G_methods.$GCINFO = "B_LogicalD_IntegralD_u64"; + memset(B_LogicalD_IntegralD_u64D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u64D_gcbm)); + B_LogicalD_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u64)); + B_LogicalD_IntegralD_u64G_methods.$name = "B_LogicalD_IntegralD_u64"; B_LogicalD_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u64))B_valueG_methods.__bool__; B_LogicalD_IntegralD_u64G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u64))B_valueG_methods.__str__; @@ -5810,7 +6140,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_u64G_methods); } { - B_DivD_u64G_methods.$GCINFO = "B_DivD_u64"; + memset(B_DivD_u64D_gcbm, 0xFF, sizeof(B_DivD_u64D_gcbm)); + B_DivD_u64G_methods.$GCdescr = GC_make_descriptor(B_DivD_u64D_gcbm, GC_WORD_LEN(struct B_DivD_u64)); + B_DivD_u64G_methods.$name = "B_DivD_u64"; B_DivD_u64G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_u64G_methods.__bool__ = (B_bool (*) (B_DivD_u64))B_valueG_methods.__bool__; B_DivD_u64G_methods.__str__ = (B_str (*) (B_DivD_u64))B_valueG_methods.__str__; @@ -5823,7 +6155,9 @@ void B___init__ () { $register(&B_DivD_u64G_methods); } { - B_OrdD_u64G_methods.$GCINFO = "B_OrdD_u64"; + memset(B_OrdD_u64D_gcbm, 0xFF, sizeof(B_OrdD_u64D_gcbm)); + B_OrdD_u64G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u64D_gcbm, GC_WORD_LEN(struct B_OrdD_u64)); + B_OrdD_u64G_methods.$name = "B_OrdD_u64"; B_OrdD_u64G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_u64G_methods.__bool__ = (B_bool (*) (B_OrdD_u64))B_valueG_methods.__bool__; B_OrdD_u64G_methods.__str__ = (B_str (*) (B_OrdD_u64))B_valueG_methods.__str__; @@ -5840,7 +6174,9 @@ void B___init__ () { $register(&B_OrdD_u64G_methods); } { - B_HashableD_u64G_methods.$GCINFO = "B_HashableD_u64"; + memset(B_HashableD_u64D_gcbm, 0xFF, sizeof(B_HashableD_u64D_gcbm)); + B_HashableD_u64G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u64D_gcbm, GC_WORD_LEN(struct B_HashableD_u64)); + B_HashableD_u64G_methods.$name = "B_HashableD_u64"; B_HashableD_u64G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_u64G_methods.__bool__ = (B_bool (*) (B_HashableD_u64))B_valueG_methods.__bool__; B_HashableD_u64G_methods.__str__ = (B_str (*) (B_HashableD_u64))B_valueG_methods.__str__; @@ -5860,7 +6196,9 @@ void B___init__ () { { - B_IntegralD_u32G_methods.$GCINFO = "B_IntegralD_u32"; + memset(B_IntegralD_u32D_gcbm, 0xFF, sizeof(B_IntegralD_u32D_gcbm)); + B_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_IntegralD_u32)); + B_IntegralD_u32G_methods.$name = "B_IntegralD_u32"; B_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_IntegralD_u32))B_valueG_methods.__bool__; B_IntegralD_u32G_methods.__str__ = (B_str (*) (B_IntegralD_u32))B_valueG_methods.__str__; @@ -5904,7 +6242,9 @@ void B___init__ () { $register(&B_IntegralD_u32G_methods); } { - B_MinusD_IntegralD_u32G_methods.$GCINFO = "B_MinusD_IntegralD_u32"; + memset(B_MinusD_IntegralD_u32D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u32D_gcbm)); + B_MinusD_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u32)); + B_MinusD_IntegralD_u32G_methods.$name = "B_MinusD_IntegralD_u32"; B_MinusD_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u32))B_valueG_methods.__bool__; B_MinusD_IntegralD_u32G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u32))B_valueG_methods.__str__; @@ -5917,7 +6257,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_u32G_methods); } { - B_LogicalD_IntegralD_u32G_methods.$GCINFO = "B_LogicalD_IntegralD_u32"; + memset(B_LogicalD_IntegralD_u32D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u32D_gcbm)); + B_LogicalD_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u32)); + B_LogicalD_IntegralD_u32G_methods.$name = "B_LogicalD_IntegralD_u32"; B_LogicalD_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u32))B_valueG_methods.__bool__; B_LogicalD_IntegralD_u32G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u32))B_valueG_methods.__str__; @@ -5934,7 +6276,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_u32G_methods); } { - B_DivD_u32G_methods.$GCINFO = "B_DivD_u32"; + memset(B_DivD_u32D_gcbm, 0xFF, sizeof(B_DivD_u32D_gcbm)); + B_DivD_u32G_methods.$GCdescr = GC_make_descriptor(B_DivD_u32D_gcbm, GC_WORD_LEN(struct B_DivD_u32)); + B_DivD_u32G_methods.$name = "B_DivD_u32"; B_DivD_u32G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_u32G_methods.__bool__ = (B_bool (*) (B_DivD_u32))B_valueG_methods.__bool__; B_DivD_u32G_methods.__str__ = (B_str (*) (B_DivD_u32))B_valueG_methods.__str__; @@ -5947,7 +6291,9 @@ void B___init__ () { $register(&B_DivD_u32G_methods); } { - B_OrdD_u32G_methods.$GCINFO = "B_OrdD_u32"; + memset(B_OrdD_u32D_gcbm, 0xFF, sizeof(B_OrdD_u32D_gcbm)); + B_OrdD_u32G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u32D_gcbm, GC_WORD_LEN(struct B_OrdD_u32)); + B_OrdD_u32G_methods.$name = "B_OrdD_u32"; B_OrdD_u32G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_u32G_methods.__bool__ = (B_bool (*) (B_OrdD_u32))B_valueG_methods.__bool__; B_OrdD_u32G_methods.__str__ = (B_str (*) (B_OrdD_u32))B_valueG_methods.__str__; @@ -5964,7 +6310,9 @@ void B___init__ () { $register(&B_OrdD_u32G_methods); } { - B_HashableD_u32G_methods.$GCINFO = "B_HashableD_u32"; + memset(B_HashableD_u32D_gcbm, 0xFF, sizeof(B_HashableD_u32D_gcbm)); + B_HashableD_u32G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u32D_gcbm, GC_WORD_LEN(struct B_HashableD_u32)); + B_HashableD_u32G_methods.$name = "B_HashableD_u32"; B_HashableD_u32G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_u32G_methods.__bool__ = (B_bool (*) (B_HashableD_u32))B_valueG_methods.__bool__; B_HashableD_u32G_methods.__str__ = (B_str (*) (B_HashableD_u32))B_valueG_methods.__str__; @@ -5984,7 +6332,9 @@ void B___init__ () { { - B_IntegralD_u16G_methods.$GCINFO = "B_IntegralD_u16"; + memset(B_IntegralD_u16D_gcbm, 0xFF, sizeof(B_IntegralD_u16D_gcbm)); + B_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_IntegralD_u16)); + B_IntegralD_u16G_methods.$name = "B_IntegralD_u16"; B_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods; B_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_IntegralD_u16))B_valueG_methods.__bool__; B_IntegralD_u16G_methods.__str__ = (B_str (*) (B_IntegralD_u16))B_valueG_methods.__str__; @@ -6028,7 +6378,9 @@ void B___init__ () { $register(&B_IntegralD_u16G_methods); } { - B_MinusD_IntegralD_u16G_methods.$GCINFO = "B_MinusD_IntegralD_u16"; + memset(B_MinusD_IntegralD_u16D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u16D_gcbm)); + B_MinusD_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u16)); + B_MinusD_IntegralD_u16G_methods.$name = "B_MinusD_IntegralD_u16"; B_MinusD_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods; B_MinusD_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u16))B_valueG_methods.__bool__; B_MinusD_IntegralD_u16G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u16))B_valueG_methods.__str__; @@ -6041,7 +6393,9 @@ void B___init__ () { $register(&B_MinusD_IntegralD_u16G_methods); } { - B_LogicalD_IntegralD_u16G_methods.$GCINFO = "B_LogicalD_IntegralD_u16"; + memset(B_LogicalD_IntegralD_u16D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u16D_gcbm)); + B_LogicalD_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u16)); + B_LogicalD_IntegralD_u16G_methods.$name = "B_LogicalD_IntegralD_u16"; B_LogicalD_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods; B_LogicalD_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u16))B_valueG_methods.__bool__; B_LogicalD_IntegralD_u16G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u16))B_valueG_methods.__str__; @@ -6058,7 +6412,9 @@ void B___init__ () { $register(&B_LogicalD_IntegralD_u16G_methods); } { - B_DivD_u16G_methods.$GCINFO = "B_DivD_u16"; + memset(B_DivD_u16D_gcbm, 0xFF, sizeof(B_DivD_u16D_gcbm)); + B_DivD_u16G_methods.$GCdescr = GC_make_descriptor(B_DivD_u16D_gcbm, GC_WORD_LEN(struct B_DivD_u16)); + B_DivD_u16G_methods.$name = "B_DivD_u16"; B_DivD_u16G_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_u16G_methods.__bool__ = (B_bool (*) (B_DivD_u16))B_valueG_methods.__bool__; B_DivD_u16G_methods.__str__ = (B_str (*) (B_DivD_u16))B_valueG_methods.__str__; @@ -6071,7 +6427,9 @@ void B___init__ () { $register(&B_DivD_u16G_methods); } { - B_OrdD_u16G_methods.$GCINFO = "B_OrdD_u16"; + memset(B_OrdD_u16D_gcbm, 0xFF, sizeof(B_OrdD_u16D_gcbm)); + B_OrdD_u16G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u16D_gcbm, GC_WORD_LEN(struct B_OrdD_u16)); + B_OrdD_u16G_methods.$name = "B_OrdD_u16"; B_OrdD_u16G_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_u16G_methods.__bool__ = (B_bool (*) (B_OrdD_u16))B_valueG_methods.__bool__; B_OrdD_u16G_methods.__str__ = (B_str (*) (B_OrdD_u16))B_valueG_methods.__str__; @@ -6088,7 +6446,9 @@ void B___init__ () { $register(&B_OrdD_u16G_methods); } { - B_HashableD_u16G_methods.$GCINFO = "B_HashableD_u16"; + memset(B_HashableD_u16D_gcbm, 0xFF, sizeof(B_HashableD_u16D_gcbm)); + B_HashableD_u16G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u16D_gcbm, GC_WORD_LEN(struct B_HashableD_u16)); + B_HashableD_u16G_methods.$name = "B_HashableD_u16"; B_HashableD_u16G_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_u16G_methods.__bool__ = (B_bool (*) (B_HashableD_u16))B_valueG_methods.__bool__; B_HashableD_u16G_methods.__str__ = (B_str (*) (B_HashableD_u16))B_valueG_methods.__str__; @@ -6107,7 +6467,9 @@ void B___init__ () { { - B_RealFloatD_floatG_methods.$GCINFO = "B_RealFloatD_float"; + memset(B_RealFloatD_floatD_gcbm, 0xFF, sizeof(B_RealFloatD_floatD_gcbm)); + B_RealFloatD_floatG_methods.$GCdescr = GC_make_descriptor(B_RealFloatD_floatD_gcbm, GC_WORD_LEN(struct B_RealFloatD_float)); + B_RealFloatD_floatG_methods.$name = "B_RealFloatD_float"; B_RealFloatD_floatG_methods.$superclass = ($SuperG_class)&B_RealFloatG_methods; B_RealFloatD_floatG_methods.__bool__ = (B_bool (*) (B_RealFloatD_float))B_valueG_methods.__bool__; B_RealFloatD_floatG_methods.__str__ = (B_str (*) (B_RealFloatD_float))B_valueG_methods.__str__; @@ -6137,7 +6499,9 @@ void B___init__ () { $register(&B_RealFloatD_floatG_methods); } { - B_MinusD_RealFloatD_floatG_methods.$GCINFO = "B_MinusD_RealFloatD_float"; + memset(B_MinusD_RealFloatD_floatD_gcbm, 0xFF, sizeof(B_MinusD_RealFloatD_floatD_gcbm)); + B_MinusD_RealFloatD_floatG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealFloatD_floatD_gcbm, GC_WORD_LEN(struct B_MinusD_RealFloatD_float)); + B_MinusD_RealFloatD_floatG_methods.$name = "B_MinusD_RealFloatD_float"; B_MinusD_RealFloatD_floatG_methods.$superclass = ($SuperG_class)&B_MinusD_RealFloatG_methods; B_MinusD_RealFloatD_floatG_methods.__bool__ = (B_bool (*) (B_MinusD_RealFloatD_float))B_valueG_methods.__bool__; B_MinusD_RealFloatD_floatG_methods.__str__ = (B_str (*) (B_MinusD_RealFloatD_float))B_valueG_methods.__str__; @@ -6150,7 +6514,9 @@ void B___init__ () { $register(&B_MinusD_RealFloatD_floatG_methods); } { - B_DivD_floatG_methods.$GCINFO = "B_DivD_float"; + memset(B_DivD_floatD_gcbm, 0xFF, sizeof(B_DivD_floatD_gcbm)); + B_DivD_floatG_methods.$GCdescr = GC_make_descriptor(B_DivD_floatD_gcbm, GC_WORD_LEN(struct B_DivD_float)); + B_DivD_floatG_methods.$name = "B_DivD_float"; B_DivD_floatG_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_floatG_methods.__bool__ = (B_bool (*) (B_DivD_float))B_valueG_methods.__bool__; B_DivD_floatG_methods.__str__ = (B_str (*) (B_DivD_float))B_valueG_methods.__str__; @@ -6163,7 +6529,9 @@ void B___init__ () { $register(&B_DivD_floatG_methods); } { - B_OrdD_floatG_methods.$GCINFO = "B_OrdD_float"; + memset(B_OrdD_floatD_gcbm, 0xFF, sizeof(B_OrdD_floatD_gcbm)); + B_OrdD_floatG_methods.$GCdescr = GC_make_descriptor(B_OrdD_floatD_gcbm, GC_WORD_LEN(struct B_OrdD_float)); + B_OrdD_floatG_methods.$name = "B_OrdD_float"; B_OrdD_floatG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_floatG_methods.__bool__ = (B_bool (*) (B_OrdD_float))B_valueG_methods.__bool__; B_OrdD_floatG_methods.__str__ = (B_str (*) (B_OrdD_float))B_valueG_methods.__str__; @@ -6180,7 +6548,9 @@ void B___init__ () { $register(&B_OrdD_floatG_methods); } { - B_HashableD_floatG_methods.$GCINFO = "B_HashableD_float"; + memset(B_HashableD_floatD_gcbm, 0xFF, sizeof(B_HashableD_floatD_gcbm)); + B_HashableD_floatG_methods.$GCdescr = GC_make_descriptor(B_HashableD_floatD_gcbm, GC_WORD_LEN(struct B_HashableD_float)); + B_HashableD_floatG_methods.$name = "B_HashableD_float"; B_HashableD_floatG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_floatG_methods.__bool__ = (B_bool (*) (B_HashableD_float))B_valueG_methods.__bool__; B_HashableD_floatG_methods.__str__ = (B_str (*) (B_HashableD_float))B_valueG_methods.__str__; @@ -6193,7 +6563,9 @@ void B___init__ () { $register(&B_HashableD_floatG_methods); } { - B_NumberD_complexG_methods.$GCINFO = "B_NumberD_complex"; + memset(B_NumberD_complexD_gcbm, 0xFF, sizeof(B_NumberD_complexD_gcbm)); + B_NumberD_complexG_methods.$GCdescr = GC_make_descriptor(B_NumberD_complexD_gcbm, GC_WORD_LEN(struct B_NumberD_complex)); + B_NumberD_complexG_methods.$name = "B_NumberD_complex"; B_NumberD_complexG_methods.$superclass = ($SuperG_class)&B_NumberG_methods; B_NumberD_complexG_methods.__bool__ = (B_bool (*) (B_NumberD_complex))B_valueG_methods.__bool__; B_NumberD_complexG_methods.__str__ = (B_str (*) (B_NumberD_complex))B_valueG_methods.__str__; @@ -6218,7 +6590,9 @@ void B___init__ () { $register(&B_NumberD_complexG_methods); } { - B_MinusD_NumberD_complexG_methods.$GCINFO = "B_MinusD_NumberD_complex"; + memset(B_MinusD_NumberD_complexD_gcbm, 0xFF, sizeof(B_MinusD_NumberD_complexD_gcbm)); + B_MinusD_NumberD_complexG_methods.$GCdescr = GC_make_descriptor(B_MinusD_NumberD_complexD_gcbm, GC_WORD_LEN(struct B_MinusD_NumberD_complex)); + B_MinusD_NumberD_complexG_methods.$name = "B_MinusD_NumberD_complex"; B_MinusD_NumberD_complexG_methods.$superclass = ($SuperG_class)&B_MinusD_NumberG_methods; B_MinusD_NumberD_complexG_methods.__bool__ = (B_bool (*) (B_MinusD_NumberD_complex))B_valueG_methods.__bool__; B_MinusD_NumberD_complexG_methods.__str__ = (B_str (*) (B_MinusD_NumberD_complex))B_valueG_methods.__str__; @@ -6231,7 +6605,9 @@ void B___init__ () { $register(&B_MinusD_NumberD_complexG_methods); } { - B_DivD_complexG_methods.$GCINFO = "B_DivD_complex"; + memset(B_DivD_complexD_gcbm, 0xFF, sizeof(B_DivD_complexD_gcbm)); + B_DivD_complexG_methods.$GCdescr = GC_make_descriptor(B_DivD_complexD_gcbm, GC_WORD_LEN(struct B_DivD_complex)); + B_DivD_complexG_methods.$name = "B_DivD_complex"; B_DivD_complexG_methods.$superclass = ($SuperG_class)&B_DivG_methods; B_DivD_complexG_methods.__bool__ = (B_bool (*) (B_DivD_complex))B_valueG_methods.__bool__; B_DivD_complexG_methods.__str__ = (B_str (*) (B_DivD_complex))B_valueG_methods.__str__; @@ -6244,7 +6620,9 @@ void B___init__ () { $register(&B_DivD_complexG_methods); } { - B_EqD_complexG_methods.$GCINFO = "B_EqD_complex"; + memset(B_EqD_complexD_gcbm, 0xFF, sizeof(B_EqD_complexD_gcbm)); + B_EqD_complexG_methods.$GCdescr = GC_make_descriptor(B_EqD_complexD_gcbm, GC_WORD_LEN(struct B_EqD_complex)); + B_EqD_complexG_methods.$name = "B_EqD_complex"; B_EqD_complexG_methods.$superclass = ($SuperG_class)&B_EqG_methods; B_EqD_complexG_methods.__bool__ = (B_bool (*) (B_EqD_complex))B_valueG_methods.__bool__; B_EqD_complexG_methods.__str__ = (B_str (*) (B_EqD_complex))B_valueG_methods.__str__; @@ -6257,7 +6635,9 @@ void B___init__ () { $register(&B_EqD_complexG_methods); } { - B_HashableD_complexG_methods.$GCINFO = "B_HashableD_complex"; + memset(B_HashableD_complexD_gcbm, 0xFF, sizeof(B_HashableD_complexD_gcbm)); + B_HashableD_complexG_methods.$GCdescr = GC_make_descriptor(B_HashableD_complexD_gcbm, GC_WORD_LEN(struct B_HashableD_complex)); + B_HashableD_complexG_methods.$name = "B_HashableD_complex"; B_HashableD_complexG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_complexG_methods.__bool__ = (B_bool (*) (B_HashableD_complex))B_valueG_methods.__bool__; B_HashableD_complexG_methods.__str__ = (B_str (*) (B_HashableD_complex))B_valueG_methods.__str__; @@ -6270,7 +6650,9 @@ void B___init__ () { $register(&B_HashableD_complexG_methods); } { - B_IndexedG_methods.$GCINFO = "B_Indexed"; + memset(B_IndexedD_gcbm, 0xFF, sizeof(B_IndexedD_gcbm)); + B_IndexedG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_gcbm, GC_WORD_LEN(struct B_Indexed)); + B_IndexedG_methods.$name = "B_Indexed"; B_IndexedG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_IndexedG_methods.__bool__ = (B_bool (*) (B_Indexed))B_valueG_methods.__bool__; B_IndexedG_methods.__str__ = (B_str (*) (B_Indexed))B_valueG_methods.__str__; @@ -6281,7 +6663,9 @@ void B___init__ () { $register(&B_IndexedG_methods); } { - B_SliceableG_methods.$GCINFO = "B_Sliceable"; + memset(B_SliceableD_gcbm, 0xFF, sizeof(B_SliceableD_gcbm)); + B_SliceableG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_gcbm, GC_WORD_LEN(struct B_Sliceable)); + B_SliceableG_methods.$name = "B_Sliceable"; B_SliceableG_methods.$superclass = ($SuperG_class)&B_IndexedG_methods; B_SliceableG_methods.__bool__ = (B_bool (*) (B_Sliceable))B_valueG_methods.__bool__; B_SliceableG_methods.__str__ = (B_str (*) (B_Sliceable))B_valueG_methods.__str__; @@ -6292,7 +6676,9 @@ void B___init__ () { $register(&B_SliceableG_methods); } { - B_CollectionG_methods.$GCINFO = "B_Collection"; + memset(B_CollectionD_gcbm, 0xFF, sizeof(B_CollectionD_gcbm)); + B_CollectionG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_gcbm, GC_WORD_LEN(struct B_Collection)); + B_CollectionG_methods.$name = "B_Collection"; B_CollectionG_methods.$superclass = ($SuperG_class)&B_IterableG_methods; B_CollectionG_methods.__bool__ = (B_bool (*) (B_Collection))B_valueG_methods.__bool__; B_CollectionG_methods.__str__ = (B_str (*) (B_Collection))B_valueG_methods.__str__; @@ -6303,7 +6689,9 @@ void B___init__ () { $register(&B_CollectionG_methods); } { - B_ContainerG_methods.$GCINFO = "B_Container"; + memset(B_ContainerD_gcbm, 0xFF, sizeof(B_ContainerD_gcbm)); + B_ContainerG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_gcbm, GC_WORD_LEN(struct B_Container)); + B_ContainerG_methods.$name = "B_Container"; B_ContainerG_methods.$superclass = ($SuperG_class)&B_CollectionG_methods; B_ContainerG_methods.__bool__ = (B_bool (*) (B_Container))B_valueG_methods.__bool__; B_ContainerG_methods.__str__ = (B_str (*) (B_Container))B_valueG_methods.__str__; @@ -6314,7 +6702,9 @@ void B___init__ () { $register(&B_ContainerG_methods); } { - B_SequenceG_methods.$GCINFO = "B_Sequence"; + memset(B_SequenceD_gcbm, 0xFF, sizeof(B_SequenceD_gcbm)); + B_SequenceG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_gcbm, GC_WORD_LEN(struct B_Sequence)); + B_SequenceG_methods.$name = "B_Sequence"; B_SequenceG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods; B_SequenceG_methods.__bool__ = (B_bool (*) (B_Sequence))B_valueG_methods.__bool__; B_SequenceG_methods.__str__ = (B_str (*) (B_Sequence))B_valueG_methods.__str__; @@ -6325,7 +6715,9 @@ void B___init__ () { $register(&B_SequenceG_methods); } { - B_CollectionD_SequenceG_methods.$GCINFO = "B_CollectionD_Sequence"; + memset(B_CollectionD_SequenceD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_gcbm)); + B_CollectionD_SequenceG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_gcbm, GC_WORD_LEN(struct B_CollectionD_Sequence)); + B_CollectionD_SequenceG_methods.$name = "B_CollectionD_Sequence"; B_CollectionD_SequenceG_methods.$superclass = ($SuperG_class)&B_CollectionG_methods; B_CollectionD_SequenceG_methods.__bool__ = (B_bool (*) (B_CollectionD_Sequence))B_valueG_methods.__bool__; B_CollectionD_SequenceG_methods.__str__ = (B_str (*) (B_CollectionD_Sequence))B_valueG_methods.__str__; @@ -6336,7 +6728,9 @@ void B___init__ () { $register(&B_CollectionD_SequenceG_methods); } { - B_TimesD_SequenceG_methods.$GCINFO = "B_TimesD_Sequence"; + memset(B_TimesD_SequenceD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_gcbm)); + B_TimesD_SequenceG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_gcbm, GC_WORD_LEN(struct B_TimesD_Sequence)); + B_TimesD_SequenceG_methods.$name = "B_TimesD_Sequence"; B_TimesD_SequenceG_methods.$superclass = ($SuperG_class)&B_TimesG_methods; B_TimesD_SequenceG_methods.__bool__ = (B_bool (*) (B_TimesD_Sequence))B_valueG_methods.__bool__; B_TimesD_SequenceG_methods.__str__ = (B_str (*) (B_TimesD_Sequence))B_valueG_methods.__str__; @@ -6349,7 +6743,9 @@ void B___init__ () { $register(&B_TimesD_SequenceG_methods); } { - B_MappingG_methods.$GCINFO = "B_Mapping"; + memset(B_MappingD_gcbm, 0xFF, sizeof(B_MappingD_gcbm)); + B_MappingG_methods.$GCdescr = GC_make_descriptor(B_MappingD_gcbm, GC_WORD_LEN(struct B_Mapping)); + B_MappingG_methods.$name = "B_Mapping"; B_MappingG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_MappingG_methods.__bool__ = (B_bool (*) (B_Mapping))B_valueG_methods.__bool__; B_MappingG_methods.__str__ = (B_str (*) (B_Mapping))B_valueG_methods.__str__; @@ -6360,7 +6756,9 @@ void B___init__ () { $register(&B_MappingG_methods); } { - B_IndexedD_MappingG_methods.$GCINFO = "B_IndexedD_Mapping"; + memset(B_IndexedD_MappingD_gcbm, 0xFF, sizeof(B_IndexedD_MappingD_gcbm)); + B_IndexedD_MappingG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_MappingD_gcbm, GC_WORD_LEN(struct B_IndexedD_Mapping)); + B_IndexedD_MappingG_methods.$name = "B_IndexedD_Mapping"; B_IndexedD_MappingG_methods.$superclass = ($SuperG_class)&B_IndexedG_methods; B_IndexedD_MappingG_methods.__bool__ = (B_bool (*) (B_IndexedD_Mapping))B_valueG_methods.__bool__; B_IndexedD_MappingG_methods.__str__ = (B_str (*) (B_IndexedD_Mapping))B_valueG_methods.__str__; @@ -6371,7 +6769,9 @@ void B___init__ () { $register(&B_IndexedD_MappingG_methods); } { - B_SetG_methods.$GCINFO = "B_Set"; + memset(B_SetD_gcbm, 0xFF, sizeof(B_SetD_gcbm)); + B_SetG_methods.$GCdescr = GC_make_descriptor(B_SetD_gcbm, GC_WORD_LEN(struct B_Set)); + B_SetG_methods.$name = "B_Set"; B_SetG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_SetG_methods.__bool__ = (B_bool (*) (B_Set))B_valueG_methods.__bool__; B_SetG_methods.__str__ = (B_str (*) (B_Set))B_valueG_methods.__str__; @@ -6382,7 +6782,9 @@ void B___init__ () { $register(&B_SetG_methods); } { - B_OrdD_SetG_methods.$GCINFO = "B_OrdD_Set"; + memset(B_OrdD_SetD_gcbm, 0xFF, sizeof(B_OrdD_SetD_gcbm)); + B_OrdD_SetG_methods.$GCdescr = GC_make_descriptor(B_OrdD_SetD_gcbm, GC_WORD_LEN(struct B_OrdD_Set)); + B_OrdD_SetG_methods.$name = "B_OrdD_Set"; B_OrdD_SetG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_SetG_methods.__bool__ = (B_bool (*) (B_OrdD_Set))B_valueG_methods.__bool__; B_OrdD_SetG_methods.__str__ = (B_str (*) (B_OrdD_Set))B_valueG_methods.__str__; @@ -6397,7 +6799,9 @@ void B___init__ () { $register(&B_OrdD_SetG_methods); } { - B_LogicalD_SetG_methods.$GCINFO = "B_LogicalD_Set"; + memset(B_LogicalD_SetD_gcbm, 0xFF, sizeof(B_LogicalD_SetD_gcbm)); + B_LogicalD_SetG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_SetD_gcbm, GC_WORD_LEN(struct B_LogicalD_Set)); + B_LogicalD_SetG_methods.$name = "B_LogicalD_Set"; B_LogicalD_SetG_methods.$superclass = ($SuperG_class)&B_LogicalG_methods; B_LogicalD_SetG_methods.__bool__ = (B_bool (*) (B_LogicalD_Set))B_valueG_methods.__bool__; B_LogicalD_SetG_methods.__str__ = (B_str (*) (B_LogicalD_Set))B_valueG_methods.__str__; @@ -6411,7 +6815,9 @@ void B___init__ () { $register(&B_LogicalD_SetG_methods); } { - B_MinusD_SetG_methods.$GCINFO = "B_MinusD_Set"; + memset(B_MinusD_SetD_gcbm, 0xFF, sizeof(B_MinusD_SetD_gcbm)); + B_MinusD_SetG_methods.$GCdescr = GC_make_descriptor(B_MinusD_SetD_gcbm, GC_WORD_LEN(struct B_MinusD_Set)); + B_MinusD_SetG_methods.$name = "B_MinusD_Set"; B_MinusD_SetG_methods.$superclass = ($SuperG_class)&B_MinusG_methods; B_MinusD_SetG_methods.__bool__ = (B_bool (*) (B_MinusD_Set))B_valueG_methods.__bool__; B_MinusD_SetG_methods.__str__ = (B_str (*) (B_MinusD_Set))B_valueG_methods.__str__; @@ -6423,7 +6829,9 @@ void B___init__ () { $register(&B_MinusD_SetG_methods); } { - B_SequenceD_listG_methods.$GCINFO = "B_SequenceD_list"; + memset(B_SequenceD_listD_gcbm, 0xFF, sizeof(B_SequenceD_listD_gcbm)); + B_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_SequenceD_list)); + B_SequenceD_listG_methods.$name = "B_SequenceD_list"; B_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_SequenceG_methods; B_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_SequenceD_list))B_valueG_methods.__bool__; B_SequenceD_listG_methods.__str__ = (B_str (*) (B_SequenceD_list))B_valueG_methods.__str__; @@ -6444,7 +6852,9 @@ void B___init__ () { $register(&B_SequenceD_listG_methods); } { - B_CollectionD_SequenceD_listG_methods.$GCINFO = "B_CollectionD_SequenceD_list"; + memset(B_CollectionD_SequenceD_listD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_listD_gcbm)); + B_CollectionD_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_CollectionD_SequenceD_list)); + B_CollectionD_SequenceD_listG_methods.$name = "B_CollectionD_SequenceD_list"; B_CollectionD_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_CollectionD_SequenceG_methods; B_CollectionD_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_CollectionD_SequenceD_list))B_valueG_methods.__bool__; B_CollectionD_SequenceD_listG_methods.__str__ = (B_str (*) (B_CollectionD_SequenceD_list))B_valueG_methods.__str__; @@ -6458,7 +6868,9 @@ void B___init__ () { $register(&B_CollectionD_SequenceD_listG_methods); } { - B_TimesD_SequenceD_listG_methods.$GCINFO = "B_TimesD_SequenceD_list"; + memset(B_TimesD_SequenceD_listD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_listD_gcbm)); + B_TimesD_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_TimesD_SequenceD_list)); + B_TimesD_SequenceD_listG_methods.$name = "B_TimesD_SequenceD_list"; B_TimesD_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_TimesD_SequenceG_methods; B_TimesD_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_TimesD_SequenceD_list))B_valueG_methods.__bool__; B_TimesD_SequenceD_listG_methods.__str__ = (B_str (*) (B_TimesD_SequenceD_list))B_valueG_methods.__str__; @@ -6473,7 +6885,9 @@ void B___init__ () { $register(&B_TimesD_SequenceD_listG_methods); } { - B_ContainerD_listG_methods.$GCINFO = "B_ContainerD_list"; + memset(B_ContainerD_listD_gcbm, 0xFF, sizeof(B_ContainerD_listD_gcbm)); + B_ContainerD_listG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_listD_gcbm, GC_WORD_LEN(struct B_ContainerD_list)); + B_ContainerD_listG_methods.$name = "B_ContainerD_list"; B_ContainerD_listG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_ContainerD_listG_methods.__bool__ = (B_bool (*) (B_ContainerD_list))B_valueG_methods.__bool__; B_ContainerD_listG_methods.__str__ = (B_str (*) (B_ContainerD_list))B_valueG_methods.__str__; @@ -6486,7 +6900,9 @@ void B___init__ () { $register(&B_ContainerD_listG_methods); } { - B_OrdD_listG_methods.$GCINFO = "B_OrdD_list"; + memset(B_OrdD_listD_gcbm, 0xFF, sizeof(B_OrdD_listD_gcbm)); + B_OrdD_listG_methods.$GCdescr = GC_make_descriptor(B_OrdD_listD_gcbm, GC_WORD_LEN(struct B_OrdD_list)); + B_OrdD_listG_methods.$name = "B_OrdD_list"; B_OrdD_listG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_listG_methods.__bool__ = (B_bool (*) (B_OrdD_list))B_valueG_methods.__bool__; B_OrdD_listG_methods.__str__ = (B_str (*) (B_OrdD_list))B_valueG_methods.__str__; @@ -6503,7 +6919,9 @@ void B___init__ () { $register(&B_OrdD_listG_methods); } { - B_MappingD_dictG_methods.$GCINFO = "B_MappingD_dict"; + memset(B_MappingD_dictD_gcbm, 0xFF, sizeof(B_MappingD_dictD_gcbm)); + B_MappingD_dictG_methods.$GCdescr = GC_make_descriptor(B_MappingD_dictD_gcbm, GC_WORD_LEN(struct B_MappingD_dict)); + B_MappingD_dictG_methods.$name = "B_MappingD_dict"; B_MappingD_dictG_methods.$superclass = ($SuperG_class)&B_MappingG_methods; B_MappingD_dictG_methods.__bool__ = (B_bool (*) (B_MappingD_dict))B_valueG_methods.__bool__; B_MappingD_dictG_methods.__str__ = (B_str (*) (B_MappingD_dict))B_valueG_methods.__str__; @@ -6526,7 +6944,9 @@ void B___init__ () { $register(&B_MappingD_dictG_methods); } { - B_IndexedD_MappingD_dictG_methods.$GCINFO = "B_IndexedD_MappingD_dict"; + memset(B_IndexedD_MappingD_dictD_gcbm, 0xFF, sizeof(B_IndexedD_MappingD_dictD_gcbm)); + B_IndexedD_MappingD_dictG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_MappingD_dictD_gcbm, GC_WORD_LEN(struct B_IndexedD_MappingD_dict)); + B_IndexedD_MappingD_dictG_methods.$name = "B_IndexedD_MappingD_dict"; B_IndexedD_MappingD_dictG_methods.$superclass = ($SuperG_class)&B_IndexedD_MappingG_methods; B_IndexedD_MappingD_dictG_methods.__bool__ = (B_bool (*) (B_IndexedD_MappingD_dict))B_valueG_methods.__bool__; B_IndexedD_MappingD_dictG_methods.__str__ = (B_str (*) (B_IndexedD_MappingD_dict))B_valueG_methods.__str__; @@ -6540,7 +6960,9 @@ void B___init__ () { $register(&B_IndexedD_MappingD_dictG_methods); } { - B_OrdD_dictG_methods.$GCINFO = "B_OrdD_dict"; + memset(B_OrdD_dictD_gcbm, 0xFF, sizeof(B_OrdD_dictD_gcbm)); + B_OrdD_dictG_methods.$GCdescr = GC_make_descriptor(B_OrdD_dictD_gcbm, GC_WORD_LEN(struct B_OrdD_dict)); + B_OrdD_dictG_methods.$name = "B_OrdD_dict"; B_OrdD_dictG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_dictG_methods.__bool__ = (B_bool (*) (B_OrdD_dict))B_valueG_methods.__bool__; B_OrdD_dictG_methods.__str__ = (B_str (*) (B_OrdD_dict))B_valueG_methods.__str__; @@ -6557,7 +6979,9 @@ void B___init__ () { $register(&B_OrdD_dictG_methods); } { - B_SetD_setG_methods.$GCINFO = "B_SetD_set"; + memset(B_SetD_setD_gcbm, 0xFF, sizeof(B_SetD_setD_gcbm)); + B_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_SetD_setD_gcbm, GC_WORD_LEN(struct B_SetD_set)); + B_SetD_setG_methods.$name = "B_SetD_set"; B_SetD_setG_methods.$superclass = ($SuperG_class)&B_SetG_methods; B_SetD_setG_methods.__bool__ = (B_bool (*) (B_SetD_set))B_valueG_methods.__bool__; B_SetD_setG_methods.__str__ = (B_str (*) (B_SetD_set))B_valueG_methods.__str__; @@ -6577,7 +7001,9 @@ void B___init__ () { $register(&B_SetD_setG_methods); } { - B_OrdD_SetD_setG_methods.$GCINFO = "B_OrdD_SetD_set"; + memset(B_OrdD_SetD_setD_gcbm, 0xFF, sizeof(B_OrdD_SetD_setD_gcbm)); + B_OrdD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_OrdD_SetD_setD_gcbm, GC_WORD_LEN(struct B_OrdD_SetD_set)); + B_OrdD_SetD_setG_methods.$name = "B_OrdD_SetD_set"; B_OrdD_SetD_setG_methods.$superclass = ($SuperG_class)&B_OrdD_SetG_methods; B_OrdD_SetD_setG_methods.__bool__ = (B_bool (*) (B_OrdD_SetD_set))B_valueG_methods.__bool__; B_OrdD_SetD_setG_methods.__str__ = (B_str (*) (B_OrdD_SetD_set))B_valueG_methods.__str__; @@ -6594,7 +7020,9 @@ void B___init__ () { $register(&B_OrdD_SetD_setG_methods); } { - B_LogicalD_SetD_setG_methods.$GCINFO = "B_LogicalD_SetD_set"; + memset(B_LogicalD_SetD_setD_gcbm, 0xFF, sizeof(B_LogicalD_SetD_setD_gcbm)); + B_LogicalD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_SetD_setD_gcbm, GC_WORD_LEN(struct B_LogicalD_SetD_set)); + B_LogicalD_SetD_setG_methods.$name = "B_LogicalD_SetD_set"; B_LogicalD_SetD_setG_methods.$superclass = ($SuperG_class)&B_LogicalD_SetG_methods; B_LogicalD_SetD_setG_methods.__bool__ = (B_bool (*) (B_LogicalD_SetD_set))B_valueG_methods.__bool__; B_LogicalD_SetD_setG_methods.__str__ = (B_str (*) (B_LogicalD_SetD_set))B_valueG_methods.__str__; @@ -6611,7 +7039,9 @@ void B___init__ () { $register(&B_LogicalD_SetD_setG_methods); } { - B_MinusD_SetD_setG_methods.$GCINFO = "B_MinusD_SetD_set"; + memset(B_MinusD_SetD_setD_gcbm, 0xFF, sizeof(B_MinusD_SetD_setD_gcbm)); + B_MinusD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_MinusD_SetD_setD_gcbm, GC_WORD_LEN(struct B_MinusD_SetD_set)); + B_MinusD_SetD_setG_methods.$name = "B_MinusD_SetD_set"; B_MinusD_SetD_setG_methods.$superclass = ($SuperG_class)&B_MinusD_SetG_methods; B_MinusD_SetD_setG_methods.__bool__ = (B_bool (*) (B_MinusD_SetD_set))B_valueG_methods.__bool__; B_MinusD_SetD_setG_methods.__str__ = (B_str (*) (B_MinusD_SetD_set))B_valueG_methods.__str__; @@ -6624,7 +7054,9 @@ void B___init__ () { $register(&B_MinusD_SetD_setG_methods); } { - B_IterableD_IteratorG_methods.$GCINFO = "B_IterableD_Iterator"; + memset(B_IterableD_IteratorD_gcbm, 0xFF, sizeof(B_IterableD_IteratorD_gcbm)); + B_IterableD_IteratorG_methods.$GCdescr = GC_make_descriptor(B_IterableD_IteratorD_gcbm, GC_WORD_LEN(struct B_IterableD_Iterator)); + B_IterableD_IteratorG_methods.$name = "B_IterableD_Iterator"; B_IterableD_IteratorG_methods.$superclass = ($SuperG_class)&B_IterableG_methods; B_IterableD_IteratorG_methods.__bool__ = (B_bool (*) (B_IterableD_Iterator))B_valueG_methods.__bool__; B_IterableD_IteratorG_methods.__str__ = (B_str (*) (B_IterableD_Iterator))B_valueG_methods.__str__; @@ -6636,7 +7068,9 @@ void B___init__ () { $register(&B_IterableD_IteratorG_methods); } { - B_IterableD_rangeG_methods.$GCINFO = "B_IterableD_range"; + memset(B_IterableD_rangeD_gcbm, 0xFF, sizeof(B_IterableD_rangeD_gcbm)); + B_IterableD_rangeG_methods.$GCdescr = GC_make_descriptor(B_IterableD_rangeD_gcbm, GC_WORD_LEN(struct B_IterableD_range)); + B_IterableD_rangeG_methods.$name = "B_IterableD_range"; B_IterableD_rangeG_methods.$superclass = ($SuperG_class)&B_IterableG_methods; B_IterableD_rangeG_methods.__bool__ = (B_bool (*) (B_IterableD_range))B_valueG_methods.__bool__; B_IterableD_rangeG_methods.__str__ = (B_str (*) (B_IterableD_range))B_valueG_methods.__str__; @@ -6648,7 +7082,9 @@ void B___init__ () { $register(&B_IterableD_rangeG_methods); } { - B_OrdD_strG_methods.$GCINFO = "B_OrdD_str"; + memset(B_OrdD_strD_gcbm, 0xFF, sizeof(B_OrdD_strD_gcbm)); + B_OrdD_strG_methods.$GCdescr = GC_make_descriptor(B_OrdD_strD_gcbm, GC_WORD_LEN(struct B_OrdD_str)); + B_OrdD_strG_methods.$name = "B_OrdD_str"; B_OrdD_strG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_strG_methods.__bool__ = (B_bool (*) (B_OrdD_str))B_valueG_methods.__bool__; B_OrdD_strG_methods.__str__ = (B_str (*) (B_OrdD_str))B_valueG_methods.__str__; @@ -6665,7 +7101,9 @@ void B___init__ () { $register(&B_OrdD_strG_methods); } { - B_ContainerD_strG_methods.$GCINFO = "B_ContainerD_str"; + memset(B_ContainerD_strD_gcbm, 0xFF, sizeof(B_ContainerD_strD_gcbm)); + B_ContainerD_strG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_strD_gcbm, GC_WORD_LEN(struct B_ContainerD_str)); + B_ContainerD_strG_methods.$name = "B_ContainerD_str"; B_ContainerD_strG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_ContainerD_strG_methods.__bool__ = (B_bool (*) (B_ContainerD_str))B_valueG_methods.__bool__; B_ContainerD_strG_methods.__str__ = (B_str (*) (B_ContainerD_str))B_valueG_methods.__str__; @@ -6681,7 +7119,9 @@ void B___init__ () { $register(&B_ContainerD_strG_methods); } { - B_SliceableD_strG_methods.$GCINFO = "B_SliceableD_str"; + memset(B_SliceableD_strD_gcbm, 0xFF, sizeof(B_SliceableD_strD_gcbm)); + B_SliceableD_strG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_strD_gcbm, GC_WORD_LEN(struct B_SliceableD_str)); + B_SliceableD_strG_methods.$name = "B_SliceableD_str"; B_SliceableD_strG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods; B_SliceableD_strG_methods.__bool__ = (B_bool (*) (B_SliceableD_str))B_valueG_methods.__bool__; B_SliceableD_strG_methods.__str__ = (B_str (*) (B_SliceableD_str))B_valueG_methods.__str__; @@ -6698,7 +7138,9 @@ void B___init__ () { $register(&B_SliceableD_strG_methods); } { - B_TimesD_strG_methods.$GCINFO = "B_TimesD_str"; + memset(B_TimesD_strD_gcbm, 0xFF, sizeof(B_TimesD_strD_gcbm)); + B_TimesD_strG_methods.$GCdescr = GC_make_descriptor(B_TimesD_strD_gcbm, GC_WORD_LEN(struct B_TimesD_str)); + B_TimesD_strG_methods.$name = "B_TimesD_str"; B_TimesD_strG_methods.$superclass = ($SuperG_class)&B_TimesG_methods; B_TimesD_strG_methods.__bool__ = (B_bool (*) (B_TimesD_str))B_valueG_methods.__bool__; B_TimesD_strG_methods.__str__ = (B_str (*) (B_TimesD_str))B_valueG_methods.__str__; @@ -6713,7 +7155,9 @@ void B___init__ () { $register(&B_TimesD_strG_methods); } { - B_HashableD_strG_methods.$GCINFO = "B_HashableD_str"; + memset(B_HashableD_strD_gcbm, 0xFF, sizeof(B_HashableD_strD_gcbm)); + B_HashableD_strG_methods.$GCdescr = GC_make_descriptor(B_HashableD_strD_gcbm, GC_WORD_LEN(struct B_HashableD_str)); + B_HashableD_strG_methods.$name = "B_HashableD_str"; B_HashableD_strG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_strG_methods.__bool__ = (B_bool (*) (B_HashableD_str))B_valueG_methods.__bool__; B_HashableD_strG_methods.__str__ = (B_str (*) (B_HashableD_str))B_valueG_methods.__str__; @@ -6727,7 +7171,9 @@ void B___init__ () { $register(&B_HashableD_strG_methods); } { - B_OrdD_bytearrayG_methods.$GCINFO = "B_OrdD_bytearray"; + memset(B_OrdD_bytearrayD_gcbm, 0xFF, sizeof(B_OrdD_bytearrayD_gcbm)); + B_OrdD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_OrdD_bytearrayD_gcbm, GC_WORD_LEN(struct B_OrdD_bytearray)); + B_OrdD_bytearrayG_methods.$name = "B_OrdD_bytearray"; B_OrdD_bytearrayG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_bytearrayG_methods.__bool__ = (B_bool (*) (B_OrdD_bytearray))B_valueG_methods.__bool__; B_OrdD_bytearrayG_methods.__str__ = (B_str (*) (B_OrdD_bytearray))B_valueG_methods.__str__; @@ -6744,7 +7190,9 @@ void B___init__ () { $register(&B_OrdD_bytearrayG_methods); } { - B_SequenceD_bytearrayG_methods.$GCINFO = "B_SequenceD_bytearray"; + memset(B_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_SequenceD_bytearrayD_gcbm)); + B_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_SequenceD_bytearray)); + B_SequenceD_bytearrayG_methods.$name = "B_SequenceD_bytearray"; B_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_SequenceG_methods; B_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_SequenceD_bytearray))B_valueG_methods.__bool__; B_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_SequenceD_bytearray))B_valueG_methods.__str__; @@ -6765,7 +7213,9 @@ void B___init__ () { $register(&B_SequenceD_bytearrayG_methods); } { - B_CollectionD_SequenceD_bytearrayG_methods.$GCINFO = "B_CollectionD_SequenceD_bytearray"; + memset(B_CollectionD_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_bytearrayD_gcbm)); + B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_CollectionD_SequenceD_bytearray)); + B_CollectionD_SequenceD_bytearrayG_methods.$name = "B_CollectionD_SequenceD_bytearray"; B_CollectionD_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_CollectionD_SequenceG_methods; B_CollectionD_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_CollectionD_SequenceD_bytearray))B_valueG_methods.__bool__; B_CollectionD_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_CollectionD_SequenceD_bytearray))B_valueG_methods.__str__; @@ -6779,7 +7229,9 @@ void B___init__ () { $register(&B_CollectionD_SequenceD_bytearrayG_methods); } { - B_TimesD_SequenceD_bytearrayG_methods.$GCINFO = "B_TimesD_SequenceD_bytearray"; + memset(B_TimesD_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_bytearrayD_gcbm)); + B_TimesD_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_TimesD_SequenceD_bytearray)); + B_TimesD_SequenceD_bytearrayG_methods.$name = "B_TimesD_SequenceD_bytearray"; B_TimesD_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_TimesD_SequenceG_methods; B_TimesD_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_TimesD_SequenceD_bytearray))B_valueG_methods.__bool__; B_TimesD_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_TimesD_SequenceD_bytearray))B_valueG_methods.__str__; @@ -6794,7 +7246,9 @@ void B___init__ () { $register(&B_TimesD_SequenceD_bytearrayG_methods); } { - B_ContainerD_bytearrayG_methods.$GCINFO = "B_ContainerD_bytearray"; + memset(B_ContainerD_bytearrayD_gcbm, 0xFF, sizeof(B_ContainerD_bytearrayD_gcbm)); + B_ContainerD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_bytearrayD_gcbm, GC_WORD_LEN(struct B_ContainerD_bytearray)); + B_ContainerD_bytearrayG_methods.$name = "B_ContainerD_bytearray"; B_ContainerD_bytearrayG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_ContainerD_bytearrayG_methods.__bool__ = (B_bool (*) (B_ContainerD_bytearray))B_valueG_methods.__bool__; B_ContainerD_bytearrayG_methods.__str__ = (B_str (*) (B_ContainerD_bytearray))B_valueG_methods.__str__; @@ -6807,7 +7261,9 @@ void B___init__ () { $register(&B_ContainerD_bytearrayG_methods); } { - B_OrdD_bytesG_methods.$GCINFO = "B_OrdD_bytes"; + memset(B_OrdD_bytesD_gcbm, 0xFF, sizeof(B_OrdD_bytesD_gcbm)); + B_OrdD_bytesG_methods.$GCdescr = GC_make_descriptor(B_OrdD_bytesD_gcbm, GC_WORD_LEN(struct B_OrdD_bytes)); + B_OrdD_bytesG_methods.$name = "B_OrdD_bytes"; B_OrdD_bytesG_methods.$superclass = ($SuperG_class)&B_OrdG_methods; B_OrdD_bytesG_methods.__bool__ = (B_bool (*) (B_OrdD_bytes))B_valueG_methods.__bool__; B_OrdD_bytesG_methods.__str__ = (B_str (*) (B_OrdD_bytes))B_valueG_methods.__str__; @@ -6824,7 +7280,9 @@ void B___init__ () { $register(&B_OrdD_bytesG_methods); } { - B_SliceableD_bytesG_methods.$GCINFO = "B_SliceableD_bytes"; + memset(B_SliceableD_bytesD_gcbm, 0xFF, sizeof(B_SliceableD_bytesD_gcbm)); + B_SliceableD_bytesG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_bytesD_gcbm, GC_WORD_LEN(struct B_SliceableD_bytes)); + B_SliceableD_bytesG_methods.$name = "B_SliceableD_bytes"; B_SliceableD_bytesG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods; B_SliceableD_bytesG_methods.__bool__ = (B_bool (*) (B_SliceableD_bytes))B_valueG_methods.__bool__; B_SliceableD_bytesG_methods.__str__ = (B_str (*) (B_SliceableD_bytes))B_valueG_methods.__str__; @@ -6841,7 +7299,9 @@ void B___init__ () { $register(&B_SliceableD_bytesG_methods); } { - B_ContainerD_bytesG_methods.$GCINFO = "B_ContainerD_bytes"; + memset(B_ContainerD_bytesD_gcbm, 0xFF, sizeof(B_ContainerD_bytesD_gcbm)); + B_ContainerD_bytesG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_bytesD_gcbm, GC_WORD_LEN(struct B_ContainerD_bytes)); + B_ContainerD_bytesG_methods.$name = "B_ContainerD_bytes"; B_ContainerD_bytesG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods; B_ContainerD_bytesG_methods.__bool__ = (B_bool (*) (B_ContainerD_bytes))B_valueG_methods.__bool__; B_ContainerD_bytesG_methods.__str__ = (B_str (*) (B_ContainerD_bytes))B_valueG_methods.__str__; @@ -6857,7 +7317,9 @@ void B___init__ () { $register(&B_ContainerD_bytesG_methods); } { - B_TimesD_bytesG_methods.$GCINFO = "B_TimesD_bytes"; + memset(B_TimesD_bytesD_gcbm, 0xFF, sizeof(B_TimesD_bytesD_gcbm)); + B_TimesD_bytesG_methods.$GCdescr = GC_make_descriptor(B_TimesD_bytesD_gcbm, GC_WORD_LEN(struct B_TimesD_bytes)); + B_TimesD_bytesG_methods.$name = "B_TimesD_bytes"; B_TimesD_bytesG_methods.$superclass = ($SuperG_class)&B_TimesG_methods; B_TimesD_bytesG_methods.__bool__ = (B_bool (*) (B_TimesD_bytes))B_valueG_methods.__bool__; B_TimesD_bytesG_methods.__str__ = (B_str (*) (B_TimesD_bytes))B_valueG_methods.__str__; @@ -6872,7 +7334,9 @@ void B___init__ () { $register(&B_TimesD_bytesG_methods); } { - B_HashableD_bytesG_methods.$GCINFO = "B_HashableD_bytes"; + memset(B_HashableD_bytesD_gcbm, 0xFF, sizeof(B_HashableD_bytesD_gcbm)); + B_HashableD_bytesG_methods.$GCdescr = GC_make_descriptor(B_HashableD_bytesD_gcbm, GC_WORD_LEN(struct B_HashableD_bytes)); + B_HashableD_bytesG_methods.$name = "B_HashableD_bytes"; B_HashableD_bytesG_methods.$superclass = ($SuperG_class)&B_HashableG_methods; B_HashableD_bytesG_methods.__bool__ = (B_bool (*) (B_HashableD_bytes))B_valueG_methods.__bool__; B_HashableD_bytesG_methods.__str__ = (B_str (*) (B_HashableD_bytes))B_valueG_methods.__str__; @@ -6886,7 +7350,9 @@ void B___init__ () { } /* { - B_L_1procG_methods.$GCINFO = "B_L_1proc"; + memset(B_L_1procD_gcbm, 0xFF, sizeof(B_L_1procD_gcbm)); + B_L_1procG_methods.$GCdescr = GC_make_descriptor(B_L_1procD_gcbm, GC_WORD_LEN(struct B_L_1proc)); + B_L_1procG_methods.$name = "B_L_1proc"; B_L_1procG_methods.$superclass = ($SuperG_class)&$procG_methods; B_L_1procG_methods.__bool__ = (B_bool (*) (B_L_1proc))B_valueG_methods.__bool__; B_L_1procG_methods.__str__ = (B_str (*) (B_L_1proc))B_valueG_methods.__str__; @@ -6899,7 +7365,9 @@ void B___init__ () { $register(&B_L_1procG_methods); } { - B_L_2procG_methods.$GCINFO = "B_L_2proc"; + memset(B_L_2procD_gcbm, 0xFF, sizeof(B_L_2procD_gcbm)); + B_L_2procG_methods.$GCdescr = GC_make_descriptor(B_L_2procD_gcbm, GC_WORD_LEN(struct B_L_2proc)); + B_L_2procG_methods.$name = "B_L_2proc"; B_L_2procG_methods.$superclass = ($SuperG_class)&$procG_methods; B_L_2procG_methods.__bool__ = (B_bool (*) (B_L_2proc))B_valueG_methods.__bool__; B_L_2procG_methods.__str__ = (B_str (*) (B_L_2proc))B_valueG_methods.__str__; @@ -6912,7 +7380,9 @@ void B___init__ () { $register(&B_L_2procG_methods); } { - B_L_3procG_methods.$GCINFO = "B_L_3proc"; + memset(B_L_3procD_gcbm, 0xFF, sizeof(B_L_3procD_gcbm)); + B_L_3procG_methods.$GCdescr = GC_make_descriptor(B_L_3procD_gcbm, GC_WORD_LEN(struct B_L_3proc)); + B_L_3procG_methods.$name = "B_L_3proc"; B_L_3procG_methods.$superclass = ($SuperG_class)&$procG_methods; B_L_3procG_methods.__bool__ = (B_bool (*) (B_L_3proc))B_valueG_methods.__bool__; B_L_3procG_methods.__str__ = (B_str (*) (B_L_3proc))B_valueG_methods.__str__; @@ -6925,7 +7395,9 @@ void B___init__ () { $register(&B_L_3procG_methods); } { - B_L_5ContG_methods.$GCINFO = "B_L_5Cont"; + memset(B_L_5ContD_gcbm, 0xFF, sizeof(B_L_5ContD_gcbm)); + B_L_5ContG_methods.$GCdescr = GC_make_descriptor(B_L_5ContD_gcbm, GC_WORD_LEN(struct B_L_5Cont)); + B_L_5ContG_methods.$name = "B_L_5Cont"; B_L_5ContG_methods.$superclass = ($SuperG_class)&$ContG_methods; B_L_5ContG_methods.__bool__ = (B_bool (*) (B_L_5Cont))B_valueG_methods.__bool__; B_L_5ContG_methods.__str__ = (B_str (*) (B_L_5Cont))B_valueG_methods.__str__; @@ -6937,7 +7409,9 @@ void B___init__ () { $register(&B_L_5ContG_methods); } { - B_L_6procG_methods.$GCINFO = "B_L_6proc"; + memset(B_L_6procD_gcbm, 0xFF, sizeof(B_L_6procD_gcbm)); + B_L_6procG_methods.$GCdescr = GC_make_descriptor(B_L_6procD_gcbm, GC_WORD_LEN(struct B_L_6proc)); + B_L_6procG_methods.$name = "B_L_6proc"; B_L_6procG_methods.$superclass = ($SuperG_class)&$procG_methods; B_L_6procG_methods.__bool__ = (B_bool (*) (B_L_6proc))B_valueG_methods.__bool__; B_L_6procG_methods.__str__ = (B_str (*) (B_L_6proc))B_valueG_methods.__str__; @@ -6950,7 +7424,9 @@ void B___init__ () { $register(&B_L_6procG_methods); } { - B_WorldAuthG_methods.$GCINFO = "B_WorldAuth"; + memset(B_WorldAuthD_gcbm, 0xFF, sizeof(B_WorldAuthD_gcbm)); + B_WorldAuthG_methods.$GCdescr = GC_make_descriptor(B_WorldAuthD_gcbm, GC_WORD_LEN(struct B_WorldAuth)); + B_WorldAuthG_methods.$name = "B_WorldAuth"; B_WorldAuthG_methods.$superclass = ($SuperG_class)&B_valueG_methods; B_WorldAuthG_methods.__bool__ = (B_bool (*) (B_WorldAuth))B_valueG_methods.__bool__; B_WorldAuthG_methods.__str__ = (B_str (*) (B_WorldAuth))B_valueG_methods.__str__; @@ -6961,7 +7437,9 @@ void B___init__ () { $register(&B_WorldAuthG_methods); } { - B_EnvG_methods.$GCINFO = "B_Env"; + memset(B_EnvD_gcbm, 0xFF, sizeof(B_EnvD_gcbm)); + B_EnvG_methods.$GCdescr = GC_make_descriptor(B_EnvD_gcbm, GC_WORD_LEN(struct B_Env)); + B_EnvG_methods.$name = "B_Env"; B_EnvG_methods.$superclass = ($SuperG_class)&$ActorG_methods; B_EnvG_methods.__bool__ = (B_bool (*) (B_Env))$ActorG_methods.__bool__; B_EnvG_methods.__str__ = (B_str (*) (B_Env))$ActorG_methods.__str__; diff --git a/builtin/__builtin__.h b/builtin/__builtin__.h index 457e7498b..39e928a05 100644 --- a/builtin/__builtin__.h +++ b/builtin/__builtin__.h @@ -1,3 +1,4 @@ +#include "gc/gc_typed.h" /* Building project in /Users/sydow/acton/builtin/ty Compiling __builtin__.act for release in stub mode @@ -306,7 +307,8 @@ typedef struct B_ContainerD_bytes *B_ContainerD_bytes; typedef struct B_TimesD_bytes *B_TimesD_bytes; typedef struct B_HashableD_bytes *B_HashableD_bytes; struct B_valueG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_value); @@ -319,8 +321,10 @@ struct B_valueG_class { struct B_value { struct B_valueG_class *$class; }; +extern GC_word B_valueD_gcbm[GC_BITMAP_SIZE(struct B_value)]; struct B_objectG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_object); @@ -333,8 +337,10 @@ struct B_objectG_class { struct B_object { struct B_objectG_class *$class; }; +extern GC_word B_objectD_gcbm[GC_BITMAP_SIZE(struct B_object)]; struct B_atomG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_atom); @@ -347,8 +353,10 @@ struct B_atomG_class { struct B_atom { struct B_atomG_class *$class; }; +extern GC_word B_atomD_gcbm[GC_BITMAP_SIZE(struct B_atom)]; struct B_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_int, B_atom); @@ -359,7 +367,8 @@ struct B_intG_class { B_str (*__repr__) (B_int); }; struct B_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_i64, B_atom); @@ -370,7 +379,8 @@ struct B_i64G_class { B_str (*__repr__) (B_i64); }; struct B_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_i32, B_atom); @@ -381,7 +391,8 @@ struct B_i32G_class { B_str (*__repr__) (B_i32); }; struct B_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_i16, B_atom); @@ -392,7 +403,8 @@ struct B_i16G_class { B_str (*__repr__) (B_i16); }; struct B_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_u64, B_atom); @@ -403,7 +415,8 @@ struct B_u64G_class { B_str (*__repr__) (B_u64); }; struct B_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_u32, B_atom); @@ -414,7 +427,8 @@ struct B_u32G_class { B_str (*__repr__) (B_u32); }; struct B_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_u16, B_atom); @@ -425,7 +439,8 @@ struct B_u16G_class { B_str (*__repr__) (B_u16); }; struct B_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_float, B_atom); @@ -436,7 +451,8 @@ struct B_floatG_class { B_str (*__repr__) (B_float); }; struct B_boolG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_bool, B_value); @@ -447,7 +463,8 @@ struct B_boolG_class { B_str (*__repr__) (B_bool); }; struct B_sliceG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_slice, B_int, B_int, B_int); @@ -458,7 +475,8 @@ struct B_sliceG_class { B_str (*__repr__) (B_slice); }; struct B_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_list, B_Iterable, $WORD); @@ -473,7 +491,8 @@ struct B_listG_class { $WORD (*pop) (B_list, B_int); }; struct B_rangeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_range, B_int, B_int, B_int); @@ -484,7 +503,8 @@ struct B_rangeG_class { B_str (*__repr__) (B_range); }; struct B_IteratorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Iterator); @@ -498,8 +518,10 @@ struct B_IteratorG_class { struct B_Iterator { struct B_IteratorG_class *$class; }; +extern GC_word B_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_Iterator)]; struct B_IterableG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Iterable); @@ -513,8 +535,10 @@ struct B_IterableG_class { struct B_Iterable { struct B_IterableG_class *$class; }; +extern GC_word B_IterableD_gcbm[GC_BITMAP_SIZE(struct B_Iterable)]; struct B_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_str, B_value); @@ -559,7 +583,8 @@ struct B_strG_class { B_str (*zfill) (B_str, B_int); }; struct B_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_bytes, B_Iterable, $WORD); @@ -603,7 +628,8 @@ struct B_bytesG_class { B_bytes (*zfill) (B_bytes, B_int); }; struct B_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_bytearray, B_bytes); @@ -648,7 +674,8 @@ struct B_bytearrayG_class { }; /* struct B_MsgG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Msg); @@ -661,9 +688,11 @@ struct B_MsgG_class { struct B_Msg { struct B_MsgG_class *$class; }; +extern GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)]; */ struct B_BaseExceptionG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_BaseException, B_str); @@ -677,8 +706,10 @@ struct B_BaseException { struct B_BaseExceptionG_class *$class; B_str error_message; }; +extern GC_word B_BaseExceptionD_gcbm[GC_BITMAP_SIZE(struct B_BaseException)]; struct B_SystemExitG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SystemExit, B_str); @@ -692,8 +723,10 @@ struct B_SystemExit { struct B_SystemExitG_class *$class; B_str error_message; }; +extern GC_word B_SystemExitD_gcbm[GC_BITMAP_SIZE(struct B_SystemExit)]; struct B_KeyboardInterruptG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_KeyboardInterrupt, B_str); @@ -707,8 +740,10 @@ struct B_KeyboardInterrupt { struct B_KeyboardInterruptG_class *$class; B_str error_message; }; +extern GC_word B_KeyboardInterruptD_gcbm[GC_BITMAP_SIZE(struct B_KeyboardInterrupt)]; struct B_ExceptionG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Exception, B_str); @@ -722,8 +757,10 @@ struct B_Exception { struct B_ExceptionG_class *$class; B_str error_message; }; +extern GC_word B_ExceptionD_gcbm[GC_BITMAP_SIZE(struct B_Exception)]; struct B_AssertionErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_AssertionError, B_str); @@ -737,8 +774,10 @@ struct B_AssertionError { struct B_AssertionErrorG_class *$class; B_str error_message; }; +extern GC_word B_AssertionErrorD_gcbm[GC_BITMAP_SIZE(struct B_AssertionError)]; struct B_LookupErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LookupError, B_str); @@ -752,8 +791,10 @@ struct B_LookupError { struct B_LookupErrorG_class *$class; B_str error_message; }; +extern GC_word B_LookupErrorD_gcbm[GC_BITMAP_SIZE(struct B_LookupError)]; struct B_IndexErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IndexError, B_str); @@ -767,8 +808,10 @@ struct B_IndexError { struct B_IndexErrorG_class *$class; B_str error_message; }; +extern GC_word B_IndexErrorD_gcbm[GC_BITMAP_SIZE(struct B_IndexError)]; struct B_KeyErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_KeyError, B_str); @@ -782,8 +825,10 @@ struct B_KeyError { struct B_KeyErrorG_class *$class; B_str error_message; }; +extern GC_word B_KeyErrorD_gcbm[GC_BITMAP_SIZE(struct B_KeyError)]; struct B_MemoryErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MemoryError, B_str); @@ -797,8 +842,10 @@ struct B_MemoryError { struct B_MemoryErrorG_class *$class; B_str error_message; }; +extern GC_word B_MemoryErrorD_gcbm[GC_BITMAP_SIZE(struct B_MemoryError)]; struct B_OSErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OSError, B_str); @@ -812,8 +859,10 @@ struct B_OSError { struct B_OSErrorG_class *$class; B_str error_message; }; +extern GC_word B_OSErrorD_gcbm[GC_BITMAP_SIZE(struct B_OSError)]; struct B_RuntimeErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_RuntimeError, B_str); @@ -827,8 +876,10 @@ struct B_RuntimeError { struct B_RuntimeErrorG_class *$class; B_str error_message; }; +extern GC_word B_RuntimeErrorD_gcbm[GC_BITMAP_SIZE(struct B_RuntimeError)]; struct B_NotImplementedErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_NotImplementedError, B_str); @@ -842,8 +893,10 @@ struct B_NotImplementedError { struct B_NotImplementedErrorG_class *$class; B_str error_message; }; +extern GC_word B_NotImplementedErrorD_gcbm[GC_BITMAP_SIZE(struct B_NotImplementedError)]; struct B_ValueErrorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_ValueError, B_str); @@ -857,8 +910,10 @@ struct B_ValueError { struct B_ValueErrorG_class *$class; B_str error_message; }; +extern GC_word B_ValueErrorD_gcbm[GC_BITMAP_SIZE(struct B_ValueError)]; struct B_IdentityG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Identity); @@ -873,8 +928,10 @@ struct B_IdentityG_class { struct B_Identity { struct B_IdentityG_class *$class; }; +extern GC_word B_IdentityD_gcbm[GC_BITMAP_SIZE(struct B_Identity)]; struct B_EqG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Eq); @@ -889,8 +946,10 @@ struct B_EqG_class { struct B_Eq { struct B_EqG_class *$class; }; +extern GC_word B_EqD_gcbm[GC_BITMAP_SIZE(struct B_Eq)]; struct B_OrdG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Ord); @@ -909,8 +968,10 @@ struct B_OrdG_class { struct B_Ord { struct B_OrdG_class *$class; }; +extern GC_word B_OrdD_gcbm[GC_BITMAP_SIZE(struct B_Ord)]; struct B_LogicalG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Logical); @@ -929,8 +990,10 @@ struct B_LogicalG_class { struct B_Logical { struct B_LogicalG_class *$class; }; +extern GC_word B_LogicalD_gcbm[GC_BITMAP_SIZE(struct B_Logical)]; struct B_PlusG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Plus); @@ -945,8 +1008,10 @@ struct B_PlusG_class { struct B_Plus { struct B_PlusG_class *$class; }; +extern GC_word B_PlusD_gcbm[GC_BITMAP_SIZE(struct B_Plus)]; struct B_MinusG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Minus); @@ -961,8 +1026,10 @@ struct B_MinusG_class { struct B_Minus { struct B_MinusG_class *$class; }; +extern GC_word B_MinusD_gcbm[GC_BITMAP_SIZE(struct B_Minus)]; struct B_TimesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Times); @@ -979,8 +1046,10 @@ struct B_TimesG_class { struct B_Times { struct B_TimesG_class *$class; }; +extern GC_word B_TimesD_gcbm[GC_BITMAP_SIZE(struct B_Times)]; struct B_DivG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Div); @@ -995,8 +1064,10 @@ struct B_DivG_class { struct B_Div { struct B_DivG_class *$class; }; +extern GC_word B_DivD_gcbm[GC_BITMAP_SIZE(struct B_Div)]; struct B_HashableG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Hashable); @@ -1012,8 +1083,10 @@ struct B_HashableG_class { struct B_Hashable { struct B_HashableG_class *$class; }; +extern GC_word B_HashableD_gcbm[GC_BITMAP_SIZE(struct B_Hashable)]; struct B_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_complex, B_Number, $WORD); @@ -1024,7 +1097,8 @@ struct B_complexG_class { B_str (*__repr__) (B_complex); }; struct B_dictG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_dict, B_Hashable, B_Iterable, $WORD); @@ -1035,7 +1109,8 @@ struct B_dictG_class { B_str (*__repr__) (B_dict); }; struct B_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_set, B_Hashable, B_Iterable, $WORD); @@ -1046,7 +1121,8 @@ struct B_setG_class { B_str (*__repr__) (B_set); }; struct B_NumberG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Number, B_Minus); @@ -1074,8 +1150,10 @@ struct B_Number { struct B_NumberG_class *$class; B_Minus W_Minus; }; +extern GC_word B_NumberD_gcbm[GC_BITMAP_SIZE(struct B_Number)]; struct B_MinusD_NumberG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_Number, B_Number); @@ -1091,8 +1169,10 @@ struct B_MinusD_Number { struct B_MinusD_NumberG_class *$class; B_Number W_Number; }; +extern GC_word B_MinusD_NumberD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Number)]; struct B_RealG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Real, B_Minus); @@ -1125,8 +1205,10 @@ struct B_Real { struct B_RealG_class *$class; B_Minus W_Minus; }; +extern GC_word B_RealD_gcbm[GC_BITMAP_SIZE(struct B_Real)]; struct B_MinusD_RealG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_Real, B_Real); @@ -1143,8 +1225,10 @@ struct B_MinusD_Real { B_Number W_Number; B_Real W_Real; }; +extern GC_word B_MinusD_RealD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Real)]; struct B_RealFloatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_RealFloat, B_Minus); @@ -1177,8 +1261,10 @@ struct B_RealFloat { struct B_RealFloatG_class *$class; B_Minus W_Minus; }; +extern GC_word B_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloat)]; struct B_MinusD_RealFloatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_RealFloat, B_RealFloat); @@ -1196,8 +1282,10 @@ struct B_MinusD_RealFloat { B_Real W_Real; B_RealFloat W_RealFloat; }; +extern GC_word B_MinusD_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloat)]; struct B_RationalG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Rational, B_Minus); @@ -1232,8 +1320,10 @@ struct B_Rational { struct B_RationalG_class *$class; B_Minus W_Minus; }; +extern GC_word B_RationalD_gcbm[GC_BITMAP_SIZE(struct B_Rational)]; struct B_MinusD_RationalG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_Rational, B_Rational); @@ -1251,8 +1341,10 @@ struct B_MinusD_Rational { B_Real W_Real; B_Rational W_Rational; }; +extern GC_word B_MinusD_RationalD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Rational)]; struct B_IntegralG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Integral, B_Minus, B_Logical); @@ -1300,8 +1392,10 @@ struct B_Integral { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_Integral)]; struct B_MinusD_IntegralG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_Integral, B_Integral); @@ -1320,8 +1414,10 @@ struct B_MinusD_Integral { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Integral)]; struct B_LogicalD_IntegralG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_Integral, B_Integral); @@ -1341,8 +1437,10 @@ struct B_LogicalD_Integral { struct B_LogicalD_IntegralG_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Integral)]; struct B_HashableD_boolG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_bool); @@ -1358,8 +1456,10 @@ struct B_HashableD_boolG_class { struct B_HashableD_bool { struct B_HashableD_boolG_class *$class; }; +extern GC_word B_HashableD_boolD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bool)]; struct B_IntegralD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_int); @@ -1407,8 +1507,10 @@ struct B_IntegralD_int { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_int)]; struct B_MinusD_IntegralD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_int, B_Integral); @@ -1427,8 +1529,10 @@ struct B_MinusD_IntegralD_int { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_int)]; struct B_LogicalD_IntegralD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_int, B_Integral); @@ -1448,8 +1552,10 @@ struct B_LogicalD_IntegralD_int { struct B_LogicalD_IntegralD_intG_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_int)]; struct B_DivD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_int); @@ -1464,8 +1570,10 @@ struct B_DivD_intG_class { struct B_DivD_int { struct B_DivD_intG_class *$class; }; +extern GC_word B_DivD_intD_gcbm[GC_BITMAP_SIZE(struct B_DivD_int)]; struct B_OrdD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_int); @@ -1484,8 +1592,10 @@ struct B_OrdD_intG_class { struct B_OrdD_int { struct B_OrdD_intG_class *$class; }; +extern GC_word B_OrdD_intD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_int)]; struct B_HashableD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_int); @@ -1501,8 +1611,10 @@ struct B_HashableD_intG_class { struct B_HashableD_int { struct B_HashableD_intG_class *$class; }; +extern GC_word B_HashableD_intD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_int)]; struct B_IntegralD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_i64); @@ -1550,8 +1662,10 @@ struct B_IntegralD_i64 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i64)]; struct B_MinusD_IntegralD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_i64, B_Integral); @@ -1570,8 +1684,10 @@ struct B_MinusD_IntegralD_i64 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i64)]; struct B_LogicalD_IntegralD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_i64, B_Integral); @@ -1591,8 +1707,10 @@ struct B_LogicalD_IntegralD_i64 { struct B_LogicalD_IntegralD_i64G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i64)]; struct B_DivD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_i64); @@ -1607,8 +1725,10 @@ struct B_DivD_i64G_class { struct B_DivD_i64 { struct B_DivD_i64G_class *$class; }; +extern GC_word B_DivD_i64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i64)]; struct B_OrdD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_i64); @@ -1627,8 +1747,10 @@ struct B_OrdD_i64G_class { struct B_OrdD_i64 { struct B_OrdD_i64G_class *$class; }; +extern GC_word B_OrdD_i64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i64)]; struct B_HashableD_i64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_i64); @@ -1644,6 +1766,7 @@ struct B_HashableD_i64G_class { struct B_HashableD_i64 { struct B_HashableD_i64G_class *$class; }; +extern GC_word B_HashableD_i64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i64)]; @@ -1652,7 +1775,8 @@ struct B_HashableD_i64 { struct B_IntegralD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_i32); @@ -1700,8 +1824,10 @@ struct B_IntegralD_i32 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i32)]; struct B_MinusD_IntegralD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_i32, B_Integral); @@ -1720,8 +1846,10 @@ struct B_MinusD_IntegralD_i32 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i32)]; struct B_LogicalD_IntegralD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_i32, B_Integral); @@ -1741,8 +1869,10 @@ struct B_LogicalD_IntegralD_i32 { struct B_LogicalD_IntegralD_i32G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i32)]; struct B_DivD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_i32); @@ -1757,8 +1887,10 @@ struct B_DivD_i32G_class { struct B_DivD_i32 { struct B_DivD_i32G_class *$class; }; +extern GC_word B_DivD_i32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i32)]; struct B_OrdD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_i32); @@ -1777,8 +1909,10 @@ struct B_OrdD_i32G_class { struct B_OrdD_i32 { struct B_OrdD_i32G_class *$class; }; +extern GC_word B_OrdD_i32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i32)]; struct B_HashableD_i32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_i32); @@ -1794,6 +1928,7 @@ struct B_HashableD_i32G_class { struct B_HashableD_i32 { struct B_HashableD_i32G_class *$class; }; +extern GC_word B_HashableD_i32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i32)]; @@ -1802,7 +1937,8 @@ struct B_HashableD_i32 { struct B_IntegralD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_i16); @@ -1850,8 +1986,10 @@ struct B_IntegralD_i16 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i16)]; struct B_MinusD_IntegralD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_i16, B_Integral); @@ -1870,8 +2008,10 @@ struct B_MinusD_IntegralD_i16 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i16)]; struct B_LogicalD_IntegralD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_i16, B_Integral); @@ -1891,8 +2031,10 @@ struct B_LogicalD_IntegralD_i16 { struct B_LogicalD_IntegralD_i16G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i16)]; struct B_DivD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_i16); @@ -1907,8 +2049,10 @@ struct B_DivD_i16G_class { struct B_DivD_i16 { struct B_DivD_i16G_class *$class; }; +extern GC_word B_DivD_i16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i16)]; struct B_OrdD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_i16); @@ -1927,8 +2071,10 @@ struct B_OrdD_i16G_class { struct B_OrdD_i16 { struct B_OrdD_i16G_class *$class; }; +extern GC_word B_OrdD_i16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i16)]; struct B_HashableD_i16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_i16); @@ -1944,6 +2090,7 @@ struct B_HashableD_i16G_class { struct B_HashableD_i16 { struct B_HashableD_i16G_class *$class; }; +extern GC_word B_HashableD_i16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i16)]; @@ -1952,7 +2099,8 @@ struct B_HashableD_i16 { struct B_IntegralD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_u64); @@ -2000,8 +2148,10 @@ struct B_IntegralD_u64 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u64)]; struct B_MinusD_IntegralD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_u64, B_Integral); @@ -2020,8 +2170,10 @@ struct B_MinusD_IntegralD_u64 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u64)]; struct B_LogicalD_IntegralD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_u64, B_Integral); @@ -2041,8 +2193,10 @@ struct B_LogicalD_IntegralD_u64 { struct B_LogicalD_IntegralD_u64G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u64)]; struct B_DivD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_u64); @@ -2057,8 +2211,10 @@ struct B_DivD_u64G_class { struct B_DivD_u64 { struct B_DivD_u64G_class *$class; }; +extern GC_word B_DivD_u64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u64)]; struct B_OrdD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_u64); @@ -2077,8 +2233,10 @@ struct B_OrdD_u64G_class { struct B_OrdD_u64 { struct B_OrdD_u64G_class *$class; }; +extern GC_word B_OrdD_u64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u64)]; struct B_HashableD_u64G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_u64); @@ -2094,6 +2252,7 @@ struct B_HashableD_u64G_class { struct B_HashableD_u64 { struct B_HashableD_u64G_class *$class; }; +extern GC_word B_HashableD_u64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u64)]; @@ -2101,7 +2260,8 @@ struct B_HashableD_u64 { struct B_IntegralD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_u32); @@ -2149,8 +2309,10 @@ struct B_IntegralD_u32 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u32)]; struct B_MinusD_IntegralD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_u32, B_Integral); @@ -2169,8 +2331,10 @@ struct B_MinusD_IntegralD_u32 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u32)]; struct B_LogicalD_IntegralD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_u32, B_Integral); @@ -2190,8 +2354,10 @@ struct B_LogicalD_IntegralD_u32 { struct B_LogicalD_IntegralD_u32G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u32)]; struct B_DivD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_u32); @@ -2206,8 +2372,10 @@ struct B_DivD_u32G_class { struct B_DivD_u32 { struct B_DivD_u32G_class *$class; }; +extern GC_word B_DivD_u32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u32)]; struct B_OrdD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_u32); @@ -2226,8 +2394,10 @@ struct B_OrdD_u32G_class { struct B_OrdD_u32 { struct B_OrdD_u32G_class *$class; }; +extern GC_word B_OrdD_u32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u32)]; struct B_HashableD_u32G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_u32); @@ -2243,6 +2413,7 @@ struct B_HashableD_u32G_class { struct B_HashableD_u32 { struct B_HashableD_u32G_class *$class; }; +extern GC_word B_HashableD_u32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u32)]; @@ -2250,7 +2421,8 @@ struct B_HashableD_u32 { struct B_IntegralD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IntegralD_u16); @@ -2298,8 +2470,10 @@ struct B_IntegralD_u16 { B_Minus W_Minus; B_Logical W_Logical; }; +extern GC_word B_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u16)]; struct B_MinusD_IntegralD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_IntegralD_u16, B_Integral); @@ -2318,8 +2492,10 @@ struct B_MinusD_IntegralD_u16 { B_Rational W_Rational; B_Integral W_Integral; }; +extern GC_word B_MinusD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u16)]; struct B_LogicalD_IntegralD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_IntegralD_u16, B_Integral); @@ -2339,8 +2515,10 @@ struct B_LogicalD_IntegralD_u16 { struct B_LogicalD_IntegralD_u16G_class *$class; B_Integral W_Integral; }; +extern GC_word B_LogicalD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u16)]; struct B_DivD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_u16); @@ -2355,8 +2533,10 @@ struct B_DivD_u16G_class { struct B_DivD_u16 { struct B_DivD_u16G_class *$class; }; +extern GC_word B_DivD_u16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u16)]; struct B_OrdD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_u16); @@ -2375,8 +2555,10 @@ struct B_OrdD_u16G_class { struct B_OrdD_u16 { struct B_OrdD_u16G_class *$class; }; +extern GC_word B_OrdD_u16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u16)]; struct B_HashableD_u16G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_u16); @@ -2392,6 +2574,7 @@ struct B_HashableD_u16G_class { struct B_HashableD_u16 { struct B_HashableD_u16G_class *$class; }; +extern GC_word B_HashableD_u16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u16)]; @@ -2400,7 +2583,8 @@ struct B_HashableD_u16 { struct B_RealFloatD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_RealFloatD_float); @@ -2433,8 +2617,10 @@ struct B_RealFloatD_float { struct B_RealFloatD_floatG_class *$class; B_Minus W_Minus; }; +extern GC_word B_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloatD_float)]; struct B_MinusD_RealFloatD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_RealFloatD_float, B_RealFloat); @@ -2452,8 +2638,10 @@ struct B_MinusD_RealFloatD_float { B_Real W_Real; B_RealFloat W_RealFloat; }; +extern GC_word B_MinusD_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloatD_float)]; struct B_DivD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_float); @@ -2468,8 +2656,10 @@ struct B_DivD_floatG_class { struct B_DivD_float { struct B_DivD_floatG_class *$class; }; +extern GC_word B_DivD_floatD_gcbm[GC_BITMAP_SIZE(struct B_DivD_float)]; struct B_OrdD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_float); @@ -2488,8 +2678,10 @@ struct B_OrdD_floatG_class { struct B_OrdD_float { struct B_OrdD_floatG_class *$class; }; +extern GC_word B_OrdD_floatD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_float)]; struct B_HashableD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_float); @@ -2505,8 +2697,10 @@ struct B_HashableD_floatG_class { struct B_HashableD_float { struct B_HashableD_floatG_class *$class; }; +extern GC_word B_HashableD_floatD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_float)]; struct B_NumberD_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_NumberD_complex); @@ -2534,8 +2728,10 @@ struct B_NumberD_complex { struct B_NumberD_complexG_class *$class; B_Minus W_Minus; }; +extern GC_word B_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_NumberD_complex)]; struct B_MinusD_NumberD_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_NumberD_complex, B_Number); @@ -2551,8 +2747,10 @@ struct B_MinusD_NumberD_complex { struct B_MinusD_NumberD_complexG_class *$class; B_Number W_Number; }; +extern GC_word B_MinusD_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_NumberD_complex)]; struct B_DivD_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_DivD_complex); @@ -2567,8 +2765,10 @@ struct B_DivD_complexG_class { struct B_DivD_complex { struct B_DivD_complexG_class *$class; }; +extern GC_word B_DivD_complexD_gcbm[GC_BITMAP_SIZE(struct B_DivD_complex)]; struct B_EqD_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_EqD_complex); @@ -2583,8 +2783,10 @@ struct B_EqD_complexG_class { struct B_EqD_complex { struct B_EqD_complexG_class *$class; }; +extern GC_word B_EqD_complexD_gcbm[GC_BITMAP_SIZE(struct B_EqD_complex)]; struct B_HashableD_complexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_complex); @@ -2600,8 +2802,10 @@ struct B_HashableD_complexG_class { struct B_HashableD_complex { struct B_HashableD_complexG_class *$class; }; +extern GC_word B_HashableD_complexD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_complex)]; struct B_IndexedG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Indexed, B_Eq); @@ -2618,8 +2822,10 @@ struct B_Indexed { struct B_IndexedG_class *$class; B_Eq W_EqD_AD_Indexed; }; +extern GC_word B_IndexedD_gcbm[GC_BITMAP_SIZE(struct B_Indexed)]; struct B_SliceableG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Sliceable); @@ -2639,8 +2845,10 @@ struct B_Sliceable { struct B_SliceableG_class *$class; B_Eq W_EqD_AD_Indexed; }; +extern GC_word B_SliceableD_gcbm[GC_BITMAP_SIZE(struct B_Sliceable)]; struct B_CollectionG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Collection); @@ -2656,8 +2864,10 @@ struct B_CollectionG_class { struct B_Collection { struct B_CollectionG_class *$class; }; +extern GC_word B_CollectionD_gcbm[GC_BITMAP_SIZE(struct B_Collection)]; struct B_ContainerG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Container, B_Eq); @@ -2676,8 +2886,10 @@ struct B_Container { struct B_ContainerG_class *$class; B_Eq W_EqD_AD_Container; }; +extern GC_word B_ContainerD_gcbm[GC_BITMAP_SIZE(struct B_Container)]; struct B_SequenceG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Sequence, B_Collection, B_Times); @@ -2703,8 +2915,10 @@ struct B_Sequence { B_Collection W_Collection; B_Times W_Times; }; +extern GC_word B_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_Sequence)]; struct B_CollectionD_SequenceG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_CollectionD_Sequence, B_Sequence); @@ -2721,8 +2935,10 @@ struct B_CollectionD_Sequence { struct B_CollectionD_SequenceG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_CollectionD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_Sequence)]; struct B_TimesD_SequenceG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_TimesD_Sequence, B_Sequence); @@ -2740,8 +2956,10 @@ struct B_TimesD_Sequence { struct B_TimesD_SequenceG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_TimesD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_Sequence)]; struct B_MappingG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Mapping, B_Eq, B_Indexed); @@ -2769,8 +2987,10 @@ struct B_Mapping { B_Eq W_EqD_AD_Mapping; B_Indexed W_Indexed; }; +extern GC_word B_MappingD_gcbm[GC_BITMAP_SIZE(struct B_Mapping)]; struct B_IndexedD_MappingG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IndexedD_Mapping, B_Eq, B_Mapping); @@ -2789,8 +3009,10 @@ struct B_IndexedD_Mapping { B_Eq W_EqD_AD_Mapping; B_Mapping W_Mapping; }; +extern GC_word B_IndexedD_MappingD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_Mapping)]; struct B_SetG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Set, B_Eq, B_Ord, B_Logical, B_Minus); @@ -2817,8 +3039,10 @@ struct B_Set { B_Logical W_Logical; B_Minus W_Minus; }; +extern GC_word B_SetD_gcbm[GC_BITMAP_SIZE(struct B_Set)]; struct B_OrdD_SetG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_Set, B_Eq, B_Set); @@ -2839,8 +3063,10 @@ struct B_OrdD_Set { B_Eq W_EqD_AD_Set; B_Set W_Set; }; +extern GC_word B_OrdD_SetD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_Set)]; struct B_LogicalD_SetG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_Set, B_Eq, B_Set); @@ -2861,8 +3087,10 @@ struct B_LogicalD_Set { B_Eq W_EqD_AD_Set; B_Set W_Set; }; +extern GC_word B_LogicalD_SetD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Set)]; struct B_MinusD_SetG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_Set, B_Eq, B_Set); @@ -2879,8 +3107,10 @@ struct B_MinusD_Set { B_Eq W_EqD_AD_Set; B_Set W_Set; }; +extern GC_word B_MinusD_SetD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Set)]; struct B_SequenceD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SequenceD_list); @@ -2906,8 +3136,10 @@ struct B_SequenceD_list { B_Collection W_Collection; B_Times W_Times; }; +extern GC_word B_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_list)]; struct B_CollectionD_SequenceD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_CollectionD_SequenceD_list, B_Sequence); @@ -2924,8 +3156,10 @@ struct B_CollectionD_SequenceD_list { struct B_CollectionD_SequenceD_listG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_CollectionD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_list)]; struct B_TimesD_SequenceD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_TimesD_SequenceD_list, B_Sequence); @@ -2943,8 +3177,10 @@ struct B_TimesD_SequenceD_list { struct B_TimesD_SequenceD_listG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_TimesD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_list)]; struct B_ContainerD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_ContainerD_list, B_Eq); @@ -2964,8 +3200,10 @@ struct B_ContainerD_list { B_Eq W_EqD_AD_Container; B_Eq W_EqD_AD_ContainerD_list; }; +extern GC_word B_ContainerD_listD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_list)]; struct B_OrdD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_list, B_Ord); @@ -2985,8 +3223,10 @@ struct B_OrdD_list { struct B_OrdD_listG_class *$class; B_Ord W_OrdD_AD_OrdD_list; }; +extern GC_word B_OrdD_listD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_list)]; struct B_MappingD_dictG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MappingD_dict, B_Hashable); @@ -3015,8 +3255,10 @@ struct B_MappingD_dict { B_Indexed W_Indexed; B_Hashable W_HashableD_AD_MappingD_dict; }; +extern GC_word B_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_MappingD_dict)]; struct B_IndexedD_MappingD_dictG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IndexedD_MappingD_dict, B_Hashable, B_Mapping); @@ -3036,8 +3278,10 @@ struct B_IndexedD_MappingD_dict { B_Mapping W_Mapping; B_Hashable W_HashableD_AD_MappingD_dict; }; +extern GC_word B_IndexedD_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_MappingD_dict)]; struct B_OrdD_dictG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_dict, B_Hashable, B_Eq); @@ -3058,8 +3302,10 @@ struct B_OrdD_dict { B_Hashable W_HashableD_AD_OrdD_dict; B_Eq W_EqD_BD_OrdD_dict; }; +extern GC_word B_OrdD_dictD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_dict)]; struct B_SetD_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SetD_set, B_Hashable); @@ -3087,8 +3333,10 @@ struct B_SetD_set { B_Minus W_Minus; B_Hashable W_HashableD_AD_SetD_set; }; +extern GC_word B_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_SetD_set)]; struct B_OrdD_SetD_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_SetD_set, B_Hashable, B_Set); @@ -3110,8 +3358,10 @@ struct B_OrdD_SetD_set { B_Set W_Set; B_Hashable W_HashableD_AD_SetD_set; }; +extern GC_word B_OrdD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_SetD_set)]; struct B_LogicalD_SetD_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_LogicalD_SetD_set, B_Hashable, B_Set); @@ -3133,8 +3383,10 @@ struct B_LogicalD_SetD_set { B_Set W_Set; B_Hashable W_HashableD_AD_SetD_set; }; +extern GC_word B_LogicalD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_SetD_set)]; struct B_MinusD_SetD_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_MinusD_SetD_set, B_Hashable, B_Set); @@ -3152,8 +3404,10 @@ struct B_MinusD_SetD_set { B_Set W_Set; B_Hashable W_HashableD_AD_SetD_set; }; +extern GC_word B_MinusD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_SetD_set)]; struct B_IterableD_IteratorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IterableD_Iterator); @@ -3167,8 +3421,10 @@ struct B_IterableD_IteratorG_class { struct B_IterableD_Iterator { struct B_IterableD_IteratorG_class *$class; }; +extern GC_word B_IterableD_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_Iterator)]; struct B_IterableD_rangeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_IterableD_range); @@ -3182,8 +3438,10 @@ struct B_IterableD_rangeG_class { struct B_IterableD_range { struct B_IterableD_rangeG_class *$class; }; +extern GC_word B_IterableD_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_range)]; struct B_OrdD_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_str); @@ -3202,8 +3460,10 @@ struct B_OrdD_strG_class { struct B_OrdD_str { struct B_OrdD_strG_class *$class; }; +extern GC_word B_OrdD_strD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_str)]; struct B_ContainerD_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_ContainerD_str); @@ -3222,8 +3482,10 @@ struct B_ContainerD_str { struct B_ContainerD_strG_class *$class; B_Eq W_EqD_AD_Container; }; +extern GC_word B_ContainerD_strD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_str)]; struct B_SliceableD_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SliceableD_str); @@ -3243,8 +3505,10 @@ struct B_SliceableD_str { struct B_SliceableD_strG_class *$class; B_Eq W_EqD_AD_Indexed; }; +extern GC_word B_SliceableD_strD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_str)]; struct B_TimesD_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_TimesD_str); @@ -3261,8 +3525,10 @@ struct B_TimesD_strG_class { struct B_TimesD_str { struct B_TimesD_strG_class *$class; }; +extern GC_word B_TimesD_strD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_str)]; struct B_HashableD_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_str); @@ -3278,8 +3544,10 @@ struct B_HashableD_strG_class { struct B_HashableD_str { struct B_HashableD_strG_class *$class; }; +extern GC_word B_HashableD_strD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_str)]; struct B_OrdD_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_bytearray); @@ -3298,8 +3566,10 @@ struct B_OrdD_bytearrayG_class { struct B_OrdD_bytearray { struct B_OrdD_bytearrayG_class *$class; }; +extern GC_word B_OrdD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytearray)]; struct B_SequenceD_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SequenceD_bytearray); @@ -3325,8 +3595,10 @@ struct B_SequenceD_bytearray { B_Collection W_Collection; B_Times W_Times; }; +extern GC_word B_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_bytearray)]; struct B_CollectionD_SequenceD_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_CollectionD_SequenceD_bytearray, B_Sequence); @@ -3343,8 +3615,10 @@ struct B_CollectionD_SequenceD_bytearray { struct B_CollectionD_SequenceD_bytearrayG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_CollectionD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_bytearray)]; struct B_TimesD_SequenceD_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_TimesD_SequenceD_bytearray, B_Sequence); @@ -3362,8 +3636,10 @@ struct B_TimesD_SequenceD_bytearray { struct B_TimesD_SequenceD_bytearrayG_class *$class; B_Sequence W_Sequence; }; +extern GC_word B_TimesD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_bytearray)]; struct B_ContainerD_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_ContainerD_bytearray); @@ -3382,8 +3658,10 @@ struct B_ContainerD_bytearray { struct B_ContainerD_bytearrayG_class *$class; B_Eq W_EqD_AD_Container; }; +extern GC_word B_ContainerD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytearray)]; struct B_OrdD_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_OrdD_bytes); @@ -3402,8 +3680,10 @@ struct B_OrdD_bytesG_class { struct B_OrdD_bytes { struct B_OrdD_bytesG_class *$class; }; +extern GC_word B_OrdD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytes)]; struct B_SliceableD_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_SliceableD_bytes); @@ -3423,8 +3703,10 @@ struct B_SliceableD_bytes { struct B_SliceableD_bytesG_class *$class; B_Eq W_EqD_AD_Indexed; }; +extern GC_word B_SliceableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_bytes)]; struct B_ContainerD_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_ContainerD_bytes); @@ -3443,8 +3725,10 @@ struct B_ContainerD_bytes { struct B_ContainerD_bytesG_class *$class; B_Eq W_EqD_AD_Container; }; +extern GC_word B_ContainerD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytes)]; struct B_TimesD_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_TimesD_bytes); @@ -3461,8 +3745,10 @@ struct B_TimesD_bytesG_class { struct B_TimesD_bytes { struct B_TimesD_bytesG_class *$class; }; +extern GC_word B_TimesD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_bytes)]; struct B_HashableD_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_HashableD_bytes); @@ -3478,6 +3764,7 @@ struct B_HashableD_bytesG_class { struct B_HashableD_bytes { struct B_HashableD_bytesG_class *$class; }; +extern GC_word B_HashableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bytes)]; extern struct B_valueG_class B_valueG_methods; B_value B_valueG_new(); extern struct B_objectG_class B_objectG_methods; @@ -3795,7 +4082,8 @@ typedef struct B_L_6proc *B_L_6proc; typedef struct B_WorldAuth *B_WorldAuth; typedef struct B_Env *B_Env; struct B_L_1procG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_L_1proc, B_Env, B_str); @@ -3812,8 +4100,10 @@ struct B_L_1proc { B_Env self; B_str s; }; +extern GC_word B_L_1procD_gcbm[GC_BITMAP_SIZE(struct B_L_1proc)]; struct B_L_2procG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_L_2proc, B_Env, $action); @@ -3830,8 +4120,10 @@ struct B_L_2proc { B_Env self; $action cb; }; +extern GC_word B_L_2procD_gcbm[GC_BITMAP_SIZE(struct B_L_2proc)]; struct B_L_3procG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_L_3proc, B_Env, B_int); @@ -3848,9 +4140,11 @@ struct B_L_3proc { B_Env self; B_int n; }; +extern GC_word B_L_3procD_gcbm[GC_BITMAP_SIZE(struct B_L_3proc)]; $R B_L_4C_1cont (B_Env, $Cont, B_NoneType); struct B_L_5ContG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_L_5Cont, B_Env, $Cont); @@ -3866,8 +4160,10 @@ struct B_L_5Cont { B_Env G_act; $Cont C_cont; }; +extern GC_word B_L_5ContD_gcbm[GC_BITMAP_SIZE(struct B_L_5Cont)]; struct B_L_6procG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_L_6proc, B_Env, B_WorldAuth, B_list); @@ -3885,8 +4181,10 @@ struct B_L_6proc { B_WorldAuth token; B_list args; }; +extern GC_word B_L_6procD_gcbm[GC_BITMAP_SIZE(struct B_L_6proc)]; struct B_WorldAuthG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_WorldAuth); @@ -3899,8 +4197,10 @@ struct B_WorldAuthG_class { struct B_WorldAuth { struct B_WorldAuthG_class *$class; }; +extern GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)]; struct B_EnvG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; $R (*__init__) (B_Env, $Cont, B_WorldAuth, B_list); @@ -3933,6 +4233,7 @@ struct B_Env { B_WorldAuth auth; B_list argv; }; +extern GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)]; $R B_EnvG_newact ($Cont, B_WorldAuth, B_list); extern struct B_L_1procG_class B_L_1procG_methods; B_L_1proc B_L_1procG_new(B_Env, B_str); diff --git a/builtin/atom.c b/builtin/atom.c index 32e0cd8ab..9e53b4a81 100644 --- a/builtin/atom.c +++ b/builtin/atom.c @@ -13,6 +13,7 @@ */ struct B_atomG_class B_atomG_methods = { + 0, "B_atom", UNASSIGNED, ($SuperG_class)&B_valueG_methods diff --git a/builtin/bool.h b/builtin/bool.h index a135ed82d..2d1577dd4 100644 --- a/builtin/bool.h +++ b/builtin/bool.h @@ -2,6 +2,7 @@ struct B_bool { struct B_boolG_class *$class; long val; }; +extern GC_word B_boolD_gcbm[GC_BITMAP_SIZE(struct B_bool)]; B_bool toB_bool(long b); long fromB_bool(B_bool b); diff --git a/builtin/builtin_functions.c b/builtin/builtin_functions.c index 575e50cd5..4e1690512 100644 --- a/builtin/builtin_functions.c +++ b/builtin/builtin_functions.c @@ -91,8 +91,7 @@ B_IteratorD_enumerate B_IteratorD_enumerate$_deserialize(B_IteratorD_enumerate r return NULL; } -struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods = {"B_IteratorD_enumerate",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_enumerate_init, - B_IteratorD_enumerate_serialize, B_IteratorD_enumerate$_deserialize, +struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods = {0,"B_IteratorD_enumerate",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_enumerate_init, B_IteratorD_enumerate_serialize, B_IteratorD_enumerate$_deserialize, B_IteratorD_enumerate_bool,B_IteratorD_enumerate_str,B_IteratorD_enumerate_str, B_IteratorD_enumerate_next}; @@ -143,8 +142,7 @@ B_IteratorD_filter B_IteratorD_filter$_deserialize(B_IteratorD_filter res, $Seri return w; } -struct B_IteratorD_filterG_class B_IteratorD_filterG_methods = {"B_IteratorD_filter",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_filter_init, - B_IteratorD_filter_serialize, B_IteratorD_filter$_deserialize, +struct B_IteratorD_filterG_class B_IteratorD_filterG_methods = {0,"B_IteratorD_filter",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_filter_init, B_IteratorD_filter_serialize, B_IteratorD_filter$_deserialize, B_IteratorD_filter_bool,B_IteratorD_filter_str,B_IteratorD_filter_str, B_IteratorD_filter_next}; B_IteratorD_filter B_IteratorD_filterG_new(B_Iterator it, $pure f) { @@ -192,8 +190,7 @@ B_IteratorD_map B_IteratorD_map$_deserialize(B_IteratorD_map res, $Serial$state return NULL; } -struct B_IteratorD_mapG_class B_IteratorD_mapG_methods = {"B_IteratorD_map",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_map_init, - B_IteratorD_map_serialize, B_IteratorD_map$_deserialize, +struct B_IteratorD_mapG_class B_IteratorD_mapG_methods = {0,"B_IteratorD_map",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_map_init, B_IteratorD_map_serialize, B_IteratorD_map$_deserialize, B_IteratorD_map_bool,B_IteratorD_map_str,B_IteratorD_map_str, B_IteratorD_map_next}; B_IteratorD_map B_IteratorD_mapG_new(B_Iterator it, $pure f) { @@ -293,8 +290,7 @@ B_IteratorD_zip B_IteratorD_zip$_deserialize(B_IteratorD_zip res, $Serial$state return NULL; } -struct B_IteratorD_zipG_class B_IteratorD_zipG_methods = {" B_IteratorD_zip",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_zip_init, - B_IteratorD_zip_serialize, B_IteratorD_zip$_deserialize, +struct B_IteratorD_zipG_class B_IteratorD_zipG_methods = {0," B_IteratorD_zip",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_zip_init, B_IteratorD_zip_serialize, B_IteratorD_zip$_deserialize, B_IteratorD_zip_bool,B_IteratorD_zip_str,B_IteratorD_zip_str, B_IteratorD_zip_next}; B_IteratorD_zip B_IteratorD_zipG_new(B_Iterator iter1, B_Iterator iter2) { @@ -325,8 +321,7 @@ B_bool B_EqOptD___ne__(B_EqOpt wit, $WORD a, $WORD b) { return (!a && !b) ? B_False : B_True; } -struct B_EqOptG_class B_EqOptG_methods = {"B_EqOpt", UNASSIGNED, NULL, B_EqOptD___init__, B_EqOptD___eq__, B_EqOptD___ne__}; - +struct B_EqOptG_class B_EqOptG_methods = {0,"B_EqOpt", UNASSIGNED, NULL, B_EqOptD___init__, B_EqOptD___eq__, B_EqOptD___ne__}; B_EqOpt B_EqOptG_new(B_Eq W_Eq$A) { return $NEW(B_EqOpt, W_Eq$A); diff --git a/builtin/builtin_functions.h b/builtin/builtin_functions.h index c9637682b..3ca5237d7 100644 --- a/builtin/builtin_functions.h +++ b/builtin/builtin_functions.h @@ -8,7 +8,8 @@ struct B_IteratorD_enumerate; typedef struct B_IteratorD_enumerate *B_IteratorD_enumerate; struct B_IteratorD_enumerateG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_enumerate, B_Iterator,B_int); @@ -25,6 +26,7 @@ struct B_IteratorD_enumerate { B_Iterator it; int nxt; }; +extern GC_word B_IteratorD_enumerateD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_enumerate)]; extern struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods; B_IteratorD_enumerate B_IteratorD_enumerateG_new(B_Iterator,B_int); @@ -38,7 +40,8 @@ struct B_IteratorD_filter; typedef struct B_IteratorD_filter *B_IteratorD_filter; struct B_IteratorD_filterG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_filter, B_Iterator, $pure); @@ -55,6 +58,7 @@ struct B_IteratorD_filter { B_Iterator it; $pure f; }; +extern GC_word B_IteratorD_filterD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_filter)]; extern struct B_IteratorD_filterG_class B_IteratorD_filterG_methods; B_IteratorD_filter B_IteratorD_filterG_new(B_Iterator, $pure); @@ -67,7 +71,8 @@ struct B_IteratorD_map; typedef struct B_IteratorD_map *B_IteratorD_map; struct B_IteratorD_mapG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_map, B_Iterator, $pure); @@ -84,6 +89,7 @@ struct B_IteratorD_map { B_Iterator it; $pure f; }; +extern GC_word B_IteratorD_mapD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_map)]; extern struct B_IteratorD_mapG_class B_IteratorD_mapG_methods; B_IteratorD_map B_IteratorD_mapG_new(B_Iterator, $pure); @@ -94,7 +100,8 @@ struct B_IteratorD_zip; typedef struct B_IteratorD_zip *B_IteratorD_zip; struct B_IteratorD_zipG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_zip, B_Iterator, B_Iterator); @@ -111,6 +118,7 @@ struct B_IteratorD_zip { B_Iterator it1; B_Iterator it2; }; +extern GC_word B_IteratorD_zipD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_zip)]; extern struct B_IteratorD_zipG_class B_IteratorD_zipG_methods; B_IteratorD_zip B_IteratorD_zipG_new(B_Iterator, B_Iterator); @@ -124,7 +132,8 @@ struct B_EqOpt; typedef struct B_EqOpt *B_EqOpt; struct B_EqOptG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_EqOpt, B_Eq); @@ -136,6 +145,7 @@ struct B_EqOpt { struct B_EqOptG_class *$class; B_Eq W_Eq$A; }; +extern GC_word B_EqOptD_gcbm[GC_BITMAP_SIZE(struct B_EqOpt)]; B_EqOpt B_EqOptG_new(B_Eq); diff --git a/builtin/class_hierarchy.c b/builtin/class_hierarchy.c index 526a0c456..0118faaec 100644 --- a/builtin/class_hierarchy.c +++ b/builtin/class_hierarchy.c @@ -38,13 +38,13 @@ B_NoneType B_objectD___init__ (B_object self) { */ B_str B_valueD___str__(B_value self) { char *s; - asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self); + asprintf(&s,"<%s object at %p>",self->$class->$name,self); return to$str(s); } B_str B_objectD___str__(B_object self) { char *s; - asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self); + asprintf(&s,"<%s object at %p>",self->$class->$name,self); return to$str(s); } @@ -55,8 +55,7 @@ B_bool B_objectD___bool__(B_object self) { return B_True; } -struct $SerializableG_class $SerializableG_methods = {"$Serializable",UNASSIGNED,NULL, $SerializableD___init__,NULL,NULL}; - +struct $SerializableG_class $SerializableG_methods = {0,"$Serializable",UNASSIGNED,NULL, $SerializableD___init__,NULL,NULL}; //struct B_valueG_class B_valueG_methods = {"B_value",UNASSIGNED,($SuperG_class)&$SerializableG_methods,B_valueD___init__,NULL,NULL, B_valueD___bool__,B_valueD___str__,B_valueD___str__}; //struct B_objectG_class B_objectG_methods = {"B_object",UNASSIGNED,($SuperG_class)&B_valueG_methods,B_objectD___init__,NULL,NULL,B_objectD___bool__,B_objectD___str__,B_objectD___str__}; diff --git a/builtin/class_hierarchy.h b/builtin/class_hierarchy.h index 086807897..3eb1883a7 100644 --- a/builtin/class_hierarchy.h +++ b/builtin/class_hierarchy.h @@ -4,7 +4,8 @@ struct $SuperG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; }; @@ -12,6 +13,7 @@ struct $SuperG_class { struct $Super { $SuperG_class $class; }; +extern GC_word $SuperD_gcbm[GC_BITMAP_SIZE(struct $Super)]; /* typedef struct $InitializableG_class *$InitializableG_class; @@ -19,7 +21,8 @@ typedef struct $InitializableG_class *$InitializableG_class; typedef struct $Initializable *$Initializable; struct $InitializableG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; // = NULL B_NoneType (*__init__)($Initializable); @@ -28,6 +31,7 @@ struct $InitializableG_class { struct $Initializable { struct $InitializableG_class *$class; }; +extern GC_word $InitializableD_gcbm[GC_BITMAP_SIZE(struct $Initializable)]; extern struct $InitializableG_class $InitializableG_methods; $Initializable $InitializableG_new(); @@ -36,7 +40,8 @@ extern struct $InitializableG_class $InitializableG_methods; // Serializable ////////////////////////////////////////////////////// struct $SerializableG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; // = InitializableG_methods B_NoneType (*__init__)($Serializable); @@ -47,6 +52,7 @@ struct $SerializableG_class { struct $Serializable { struct $SerializableG_class *$class; }; +extern GC_word $SerializableD_gcbm[GC_BITMAP_SIZE(struct $Serializable)]; extern struct $SerializableG_class $SerializableG_methods; $Serializable $SerializableG_new(); diff --git a/builtin/complex.c b/builtin/complex.c index dce5ca084..95315da73 100644 --- a/builtin/complex.c +++ b/builtin/complex.c @@ -185,6 +185,7 @@ struct B_EqD_complex B_EqD_complex_instance; struct B_HashableD_complex B_HashableD_complex_instance; struct B_NumberD_complexG_class B_NumberD_complexG_methods = { + 0, "B_NumberD_complex", UNASSIGNED, ($SuperG_class)&B_NumberG_methods, @@ -213,6 +214,7 @@ struct B_NumberD_complex B_NumberD_complex_instance = {&B_NumberD_complexG_metho B_NumberD_complex B_NumberD_complexG_witness = &B_NumberD_complex_instance; struct B_DivD_complexG_class B_DivD_complexG_methods = { + 0, "B_DivD_complex", UNASSIGNED, ($SuperG_class)&B_DivG_methods, @@ -230,6 +232,7 @@ struct B_DivD_complex B_DivD_complex_instance = {&B_DivD_complexG_methods}; B_DivD_complex B_DivD_complexG_witness = &B_DivD_complex_instance; struct B_MinusD_NumberD_complexG_class B_MinusD_NumberD_complexG_methods = { + 0, "B_MinusD_NumberD_complex", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -246,6 +249,7 @@ struct B_MinusD_NumberD_complex B_MinusD_NumberD_complex_instance = {&B_MinusD_N B_MinusD_NumberD_complex B_MinusD_NumberD_complexG_witness = &B_MinusD_NumberD_complex_instance; struct B_EqD_complexG_class B_EqD_complexG_methods = { + 0, "B_EqD_complex", UNASSIGNED, ($SuperG_class)&B_EqG_methods, @@ -262,6 +266,7 @@ struct B_EqD_complex B_EqD_complex_instance = {&B_EqD_complexG_methods}; B_EqD_complex B_EqD_complexG_witness = &B_EqD_complex_instance; struct B_HashableD_complexG_class B_HashableD_complexG_methods = { + 0, "B_HashableD_complex", UNASSIGNED, ($SuperG_class)&B_HashableG_methods, diff --git a/builtin/complx.h b/builtin/complx.h index 6c7f56738..7dc965436 100644 --- a/builtin/complx.h +++ b/builtin/complx.h @@ -9,6 +9,7 @@ struct B_complex { struct B_complexG_class *$class; complex double val; }; +extern GC_word B_complexD_gcbm[GC_BITMAP_SIZE(struct B_complex)]; B_complex toB_complex(complex double c); diff --git a/builtin/dict.c b/builtin/dict.c index 6722eb5e2..07519ecb0 100644 --- a/builtin/dict.c +++ b/builtin/dict.c @@ -394,8 +394,7 @@ B_IteratorD_dict B_IteratorD_dict__deserialize(B_IteratorD_dict res, $Serial$sta } -struct B_IteratorD_dictG_class B_IteratorD_dictG_methods = {"B_IteratorD_dict",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dictD_init, - B_IteratorD_dictD_serialize, B_IteratorD_dict__deserialize, B_IteratorD_dictD_bool,B_IteratorD_dictD_str,B_IteratorD_dictD_str, B_IteratorD_dictD_next}; +struct B_IteratorD_dictG_class B_IteratorD_dictG_methods = {0,"B_IteratorD_dict",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dictD_init, B_IteratorD_dictD_serialize, B_IteratorD_dict__deserialize, B_IteratorD_dictD_bool,B_IteratorD_dictD_str,B_IteratorD_dictD_str, B_IteratorD_dictD_next}; B_Iterator B_MappingD_dictD___iter__ (B_MappingD_dict wit, B_dict dict) { @@ -500,8 +499,7 @@ B_IteratorD_dict_values B_IteratorD_dict_values_deserialize(B_IteratorD_dict_val return res; } -struct B_IteratorD_dict_valuesG_class B_IteratorD_dict_valuesG_methods = {"B_IteratorD_dict_values",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_values_init, - B_IteratorD_dict_values_serialize, B_IteratorD_dict_values_deserialize, B_IteratorD_dict_values_bool, B_IteratorD_dict_values_str,B_IteratorD_dict_values_str, +struct B_IteratorD_dict_valuesG_class B_IteratorD_dict_valuesG_methods = {0,"B_IteratorD_dict_values",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_values_init, B_IteratorD_dict_values_serialize, B_IteratorD_dict_values_deserialize, B_IteratorD_dict_values_bool, B_IteratorD_dict_values_str,B_IteratorD_dict_values_str, B_IteratorD_dict_values_next}; // items iterator @@ -556,8 +554,7 @@ B_IteratorD_dict_items B_IteratorD_dict_items_deserialize(B_IteratorD_dict_items -struct B_IteratorD_dict_itemsG_class B_IteratorD_dict_itemsG_methods = {"B_IteratorD_dict_items",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_items_init, - B_IteratorD_dict_items_serialize, B_IteratorD_dict_items_deserialize,B_IteratorD_dict_items_bool, B_IteratorD_dict_items_str, B_IteratorD_dict_items_str, B_IteratorD_dict_items_next}; +struct B_IteratorD_dict_itemsG_class B_IteratorD_dict_itemsG_methods = {0,"B_IteratorD_dict_items",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_items_init, B_IteratorD_dict_items_serialize, B_IteratorD_dict_items_deserialize,B_IteratorD_dict_items_bool, B_IteratorD_dict_items_str, B_IteratorD_dict_items_str, B_IteratorD_dict_items_next}; B_Iterator B_MappingD_dictD_values (B_MappingD_dict wit, B_dict dict) { @@ -704,6 +701,7 @@ struct B_MappingD_dictG_class B_MappingD_dictG_methods = { }; struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods = { + 0, "B_IndexedD_MappingD_dict", UNASSIGNED, ($SuperG_class)&B_IndexedG_methods, @@ -720,6 +718,7 @@ struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods = { struct B_OrdD_dictG_class B_OrdD_dictG_methods = { + 0, "B_OrdD_dict", UNASSIGNED, ($SuperG_class)&B_OrdG_methods, diff --git a/builtin/dict.h b/builtin/dict.h index 1dae6acdc..513c016f9 100644 --- a/builtin/dict.h +++ b/builtin/dict.h @@ -5,6 +5,7 @@ struct B_dict { long numelements; // nr of elements in dictionary $table table; // the hashtable }; +extern GC_word B_dictD_gcbm[GC_BITMAP_SIZE(struct B_dict)]; // Iterators over dicts /////////////////////////////////////////////////////// @@ -13,7 +14,8 @@ struct B_dict { typedef struct B_IteratorD_dict *B_IteratorD_dict; struct B_IteratorD_dictG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_dict, B_dict); @@ -30,6 +32,7 @@ struct B_IteratorD_dict { B_dict src; int nxt; }; +extern GC_word B_IteratorD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict)]; extern struct B_IteratorD_dictG_class B_IteratorD_dictG_methods; B_IteratorD_dict B_IteratorD_dictG_new(B_dict); @@ -39,7 +42,8 @@ B_IteratorD_dict B_IteratorD_dictG_new(B_dict); typedef struct B_IteratorD_dict_values *B_IteratorD_dict_values; struct B_IteratorD_dict_valuesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_dict_values, B_dict); @@ -56,6 +60,7 @@ struct B_IteratorD_dict_values { B_dict src; int nxt; }; +extern GC_word B_IteratorD_dict_valuesD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict_values)]; extern struct B_IteratorD_dict_valuesG_class B_IteratorD_dict_valuesG_methods; B_IteratorD_dict_values B_IteratorD_dict_valuesG_new(B_dict); @@ -65,7 +70,8 @@ B_IteratorD_dict_values B_IteratorD_dict_valuesG_new(B_dict); typedef struct B_IteratorD_dict_items *B_IteratorD_dict_items; struct B_IteratorD_dict_itemsG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_dict_items, B_dict); @@ -82,6 +88,7 @@ struct B_IteratorD_dict_items { B_dict src; int nxt; }; +extern GC_word B_IteratorD_dict_itemsD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict_items)]; extern struct B_IteratorD_dict_itemsG_class B_IteratorD_dict_itemsG_methods; B_IteratorD_dict_items B_IteratorD_dict_itemsG_new(B_dict); diff --git a/builtin/env.c b/builtin/env.c index 9ae71a88f..a6bb2525a 100644 --- a/builtin/env.c +++ b/builtin/env.c @@ -46,7 +46,7 @@ void $l$1contD___serialize__ ($l$1cont self, $Serial$state state) { $l$1cont $l$1contD___deserialize__ ($l$1cont self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct $l$1cont)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$1cont), $l$1contG_methods.$GCdescr); self->$class = &$l$1contG_methods; return self; } @@ -57,12 +57,13 @@ void $l$1contD___serialize__ ($l$1cont self, $Serial$state state) { return self; } $l$1cont $l$1contG_new(B_Env p$1, B_str p$2) { - $l$1cont $tmp = malloc(sizeof(struct $l$1cont)); + $l$1cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$1cont), $l$1contG_methods.$GCdescr); $tmp->$class = &$l$1contG_methods; $l$1contG_methods.__init__($tmp, p$1, p$2); return $tmp; } struct $l$1contG_class $l$1contG_methods; +GC_word $l$1contD_gcbm[GC_BITMAP_SIZE(struct $l$1cont)]; B_NoneType $l$2contD___init__ ($l$2cont p$self, B_Env self, $action cb) { p$self->self = self; @@ -81,7 +82,7 @@ void $l$2contD___serialize__ ($l$2cont self, $Serial$state state) { $l$2cont $l$2contD___deserialize__ ($l$2cont self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct $l$2cont)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$2cont), $l$2contG_methods.$GCdescr); self->$class = &$l$2contG_methods; return self; } @@ -92,12 +93,13 @@ void $l$2contD___serialize__ ($l$2cont self, $Serial$state state) { return self; } $l$2cont $l$2contG_new(B_Env p$1, $action p$2) { - $l$2cont $tmp = malloc(sizeof(struct $l$2cont)); + $l$2cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$2cont), $l$2contG_methods.$GCdescr); $tmp->$class = &$l$2contG_methods; $l$2contG_methods.__init__($tmp, p$1, p$2); return $tmp; } struct $l$2contG_class $l$2contG_methods; +GC_word $l$2contD_gcbm[GC_BITMAP_SIZE(struct $l$2cont)]; B_NoneType $l$3contD___init__ ($l$3cont p$self, B_Env self, B_int n) { p$self->self = self; @@ -116,7 +118,7 @@ void $l$3contD___serialize__ ($l$3cont self, $Serial$state state) { $l$3cont $l$3contD___deserialize__ ($l$3cont self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct $l$3cont)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$3cont), $l$3contG_methods.$GCdescr); self->$class = &$l$3contG_methods; return self; } @@ -127,12 +129,13 @@ void $l$3contD___serialize__ ($l$3cont self, $Serial$state state) { return self; } $l$3cont $l$3contG_new(B_Env p$1, B_int p$2) { - $l$3cont $tmp = malloc(sizeof(struct $l$3cont)); + $l$3cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$3cont), $l$3contG_methods.$GCdescr); $tmp->$class = &$l$3contG_methods; $l$3contG_methods.__init__($tmp, p$1, p$2); return $tmp; } struct $l$3contG_class $l$3contG_methods; +GC_word $l$3contD_gcbm[GC_BITMAP_SIZE(struct $l$3cont)]; B_NoneType B_WorldAuthD___init__ (B_WorldAuth self) { return B_None; } @@ -141,7 +144,7 @@ void B_WorldAuthD___serialize__ (B_WorldAuth self, $Serial$state state) { B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_WorldAuth)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr); self->$class = &B_WorldAuthG_methods; return self; } @@ -150,6 +153,7 @@ B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) return self; } struct B_WorldAuthG_class B_WorldAuthG_methods; +GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)]; B_Msg B_Env$stdout_write (B_Env self, B_str s) { return $ASYNC((($Actor)self), (($Cont)$l$1contG_new(((B_Env)self), s))); } @@ -164,7 +168,7 @@ B_Msg B_Env$exit (B_Env self, B_int n) { B_WorldAuth B_WorldAuthG_new() { - B_WorldAuth $tmp = malloc(sizeof(struct B_WorldAuth)); + B_WorldAuth $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr); $tmp->$class = &B_WorldAuthG_methods; B_WorldAuthG_methods.__init__($tmp); return $tmp; @@ -221,7 +225,7 @@ void B_EnvD___serialize__ (B_Env self, $Serial$state state) { B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) { if (!self) { if (!state) { - self = malloc(sizeof(struct B_Env)); + self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr); self->$class = &B_EnvG_methods; return self; } @@ -238,6 +242,7 @@ B_Env B_EnvG_newact(B_WorldAuth token, B_list p$1) { return $tmp; } struct B_EnvG_class B_EnvG_methods; +GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)]; int $done$ = 0; @@ -247,7 +252,9 @@ void D___init__ () { /////////////////////////////////////////////////////////////////////////////////////// // START GENERATED __builtin__.act D___init__ { - $l$1contG_methods.$GCINFO = "$l$1cont"; + memset($l$1contD_gcbm, 0xFF, sizeof($l$1contD_gcbm)); + $l$1contG_methods.$GCdescr = GC_make_descriptor($l$1contD_gcbm, GC_WORD_LEN(struct $l$1cont)); + $l$1contG_methods.$name = "$l$1cont"; $l$1contG_methods.$superclass = ($SuperG_class)&$ContG_methods; $l$1contG_methods.__init__ = $l$1contD___init__; $l$1contG_methods.__call__ = $l$1contD___call__; @@ -256,7 +263,9 @@ void D___init__ () { $register(&$l$1contG_methods); } { - $l$2contG_methods.$GCINFO = "$l$2cont"; + memset($l$2contD_gcbm, 0xFF, sizeof($l$2contD_gcbm)); + $l$2contG_methods.$GCdescr = GC_make_descriptor($l$2contD_gcbm, GC_WORD_LEN(struct $l$2cont)); + $l$2contG_methods.$name = "$l$2cont"; $l$2contG_methods.$superclass = ($SuperG_class)&$ContG_methods; $l$2contG_methods.__init__ = $l$2contD___init__; $l$2contG_methods.__call__ = $l$2contD___call__; @@ -265,7 +274,9 @@ void D___init__ () { $register(&$l$2contG_methods); } { - $l$3contG_methods.$GCINFO = "$l$3cont"; + memset($l$3contD_gcbm, 0xFF, sizeof($l$3contD_gcbm)); + $l$3contG_methods.$GCdescr = GC_make_descriptor($l$3contD_gcbm, GC_WORD_LEN(struct $l$3cont)); + $l$3contG_methods.$name = "$l$3cont"; $l$3contG_methods.$superclass = ($SuperG_class)&$ContG_methods; $l$3contG_methods.__init__ = $l$3contD___init__; $l$3contG_methods.__call__ = $l$3contD___call__; @@ -274,7 +285,9 @@ void D___init__ () { $register(&$l$3contG_methods); } { - B_WorldAuthG_methods.$GCINFO = "B_WorldAuth"; + memset(B_WorldAuthD_gcbm, 0xFF, sizeof(B_WorldAuthD_gcbm)); + B_WorldAuthG_methods.$GCdescr = GC_make_descriptor(B_WorldAuthD_gcbm, GC_WORD_LEN(struct B_WorldAuth)); + B_WorldAuthG_methods.$name = "B_WorldAuth"; B_WorldAuthG_methods.$superclass = ($SuperG_class)&B_valueG_methods; ; B_WorldAuthG_methods.__init__ = B_WorldAuthD___init__; @@ -283,7 +296,9 @@ void D___init__ () { $register(&B_WorldAuthG_methods); } { - B_EnvG_methods.$GCINFO = "B_Env"; + memset(B_EnvD_gcbm, 0xFF, sizeof(B_EnvD_gcbm)); + B_EnvG_methods.$GCdescr = GC_make_descriptor(B_EnvD_gcbm, GC_WORD_LEN(struct B_Env)); + B_EnvG_methods.$name = "B_Env"; B_EnvG_methods.$superclass = ($SuperG_class)&$ActorG_methods; B_EnvG_methods.__bool__ = (B_bool (*) (B_Env))$ActorG_methods.__bool__; B_EnvG_methods.__str__ = (B_str (*) (B_Env))$ActorG_methods.__str__; diff --git a/builtin/env.h b/builtin/env.h index c8dc298e7..77c921ac9 100644 --- a/builtin/env.h +++ b/builtin/env.h @@ -44,7 +44,8 @@ typedef struct $l$3cont *$l$3cont; typedef struct B_WorldAuth *B_WorldAuth; typedef struct B_Env *B_Env; struct $l$1contG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) ($l$1cont, B_Env, B_str); @@ -60,8 +61,10 @@ struct $l$1cont { B_Env self; B_str s; }; +extern GC_word $l$1contD_gcbm[GC_BITMAP_SIZE(struct $l$1cont)]; struct $l$2contG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) ($l$2cont, B_Env, $action); @@ -77,8 +80,10 @@ struct $l$2cont { B_Env self; $action cb; }; +extern GC_word $l$2contD_gcbm[GC_BITMAP_SIZE(struct $l$2cont)]; struct $l$3contG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) ($l$3cont, B_Env, B_int); @@ -94,8 +99,10 @@ struct $l$3cont { B_Env self; B_int n; }; +extern GC_word $l$3contD_gcbm[GC_BITMAP_SIZE(struct $l$3cont)]; struct B_WorldAuthG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_WorldAuth); @@ -108,6 +115,7 @@ struct B_WorldAuthG_class { struct B_WorldAuth { struct B_WorldAuthG_class *$class; }; +extern GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)]; B_WorldAuth B_WorldAuthG_new(); extern struct $l$1contG_class $l$1contG_methods; $l$1cont $l$1contG_new(B_Env, B_str); @@ -120,7 +128,8 @@ extern struct B_WorldAuthG_class B_WorldAuthG_methods; /////////////////////////////////////////////////////////////////////////////////////////// struct B_EnvG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (B_Env, B_WorldAuth, B_list); @@ -151,6 +160,7 @@ struct B_Env { B_WorldAuth auth; B_list argv; }; +extern GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)]; extern struct B_EnvG_class B_EnvG_methods; B_Env B_EnvG_newact(B_WorldAuth, B_list); diff --git a/builtin/float.c b/builtin/float.c index f37e7991a..63b50371a 100644 --- a/builtin/float.c +++ b/builtin/float.c @@ -262,6 +262,7 @@ struct B_OrdD_float B_OrdD_float_instance; struct B_HashableD_float B_HashableD_float_instance; struct B_RealFloatD_floatG_class B_RealFloatD_floatG_methods = { + 0, "B_RealFloatD_float", UNASSIGNED, ($SuperG_class)&B_RealG_methods, @@ -295,6 +296,7 @@ struct B_RealFloatD_float B_RealFloatD_float_instance = {&B_RealFloatD_floatG_me B_RealFloatD_float B_RealFloatD_floatG_witness = &B_RealFloatD_float_instance; struct B_MinusD_RealFloatD_floatG_class B_MinusD_RealFloatD_floatG_methods = { + 0, "B_MinusD_RealFloatD_float", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -312,6 +314,7 @@ struct B_MinusD_RealFloatD_float B_MinusD_RealFloatD_float_instance = {&B_MinusD B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatG_witness = &B_MinusD_RealFloatD_float_instance; struct B_DivD_floatG_class B_DivD_floatG_methods = { + 0, "B_DivD_float", UNASSIGNED, ($SuperG_class)&B_DivG_methods, @@ -330,6 +333,7 @@ B_DivD_float B_DivD_floatG_witness = &B_DivD_float_instance; struct B_OrdD_floatG_class B_OrdD_floatG_methods = { + 0, "B_OrdD_float", UNASSIGNED, ($SuperG_class)&B_OrdG_methods, @@ -350,6 +354,7 @@ struct B_OrdD_float B_OrdD_float_instance = {&B_OrdD_floatG_methods}; B_OrdD_float B_OrdD_floatG_witness = &B_OrdD_float_instance; struct B_HashableD_floatG_class B_HashableD_floatG_methods = { + 0, "B_HashableD_float", UNASSIGNED, ($SuperG_class)&B_HashableG_methods, diff --git a/builtin/float.h b/builtin/float.h index 8ea58722c..9b04d9a37 100644 --- a/builtin/float.h +++ b/builtin/float.h @@ -3,6 +3,7 @@ struct B_float { struct B_floatG_class *$class; double val; }; +extern GC_word B_floatD_gcbm[GC_BITMAP_SIZE(struct B_float)]; // #define B_RealD_floatG_new(...) B_RealFloatG_new(__VA_ARGS__) // #define B_RealD_float B_RealFloat diff --git a/builtin/function.c b/builtin/function.c index 9f5e7be57..c048c5241 100644 --- a/builtin/function.c +++ b/builtin/function.c @@ -69,6 +69,7 @@ void $ContD___serialize__($Cont self, $Serial$state state) { } struct $ContG_class $ContG_methods = { + 0, "$Cont", UNASSIGNED, NULL, @@ -81,6 +82,7 @@ struct $ContG_class $ContG_methods = { NULL /* __call__ */ }; struct $procG_class $procG_methods = { + 0, "$proc", UNASSIGNED, NULL, @@ -94,6 +96,7 @@ struct $procG_class $procG_methods = { NULL /* __exec__ */ }; struct $actionG_class $actionG_methods = { + 0, "$action", UNASSIGNED, NULL, @@ -108,6 +111,7 @@ struct $actionG_class $actionG_methods = { NULL /* __asyn__ */ }; struct $mutG_class $mutG_methods = { + 0, "$mut", UNASSIGNED, NULL, @@ -122,6 +126,7 @@ struct $mutG_class $mutG_methods = { NULL /* __eval__ */ }; struct $pureG_class $pureG_methods = { + 0, "$pure", UNASSIGNED, NULL, diff --git a/builtin/function.h b/builtin/function.h index 489330eca..bf1cc0290 100644 --- a/builtin/function.h +++ b/builtin/function.h @@ -35,7 +35,8 @@ typedef struct $R $R; struct $ContG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($Cont); @@ -49,6 +50,7 @@ struct $ContG_class { struct $Cont { struct $ContG_class *$class; }; +extern GC_word $ContD_gcbm[GC_BITMAP_SIZE(struct $Cont)]; extern struct $ContG_class $ContG_methods; void $ContD___init__($Cont); @@ -59,7 +61,8 @@ void $ContD___serialize__($Cont, $Serial$state); struct $procG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($proc); @@ -74,11 +77,13 @@ struct $procG_class { struct $proc { struct $procG_class *$class; }; +extern GC_word $procD_gcbm[GC_BITMAP_SIZE(struct $proc)]; extern struct $procG_class $procG_methods; struct $actionG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($action); @@ -94,11 +99,13 @@ struct $actionG_class { struct $action { struct $actionG_class *$class; }; +extern GC_word $actionD_gcbm[GC_BITMAP_SIZE(struct $action)]; extern struct $actionG_class $actionG_methods; struct $mutG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($mut); @@ -114,11 +121,13 @@ struct $mutG_class { struct $mut { struct $mutG_class *$class; }; +extern GC_word $mutD_gcbm[GC_BITMAP_SIZE(struct $mut)]; extern struct $mutG_class $mutG_methods; struct $pureG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($pure); @@ -134,6 +143,7 @@ struct $pureG_class { struct $pure { struct $pureG_class *$class; }; +extern GC_word $pureD_gcbm[GC_BITMAP_SIZE(struct $pure)]; extern struct $pureG_class $pureG_methods; @@ -141,7 +151,8 @@ extern struct $pureG_class $pureG_methods; struct $action2; typedef struct $action2 *$action2; struct $action2G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($action2); @@ -157,11 +168,13 @@ struct $action2G_class { struct $action2 { struct $action2G_class *$class; }; +extern GC_word $action2D_gcbm[GC_BITMAP_SIZE(struct $action2)]; struct $action3; typedef struct $action3 *$action3; struct $action3G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($action3); @@ -177,3 +190,4 @@ struct $action3G_class { struct $action3 { struct $action3G_class *$class; }; +extern GC_word $action3D_gcbm[GC_BITMAP_SIZE(struct $action3)]; diff --git a/builtin/i16.h b/builtin/i16.h index e05ad66c3..8de22a4f9 100644 --- a/builtin/i16.h +++ b/builtin/i16.h @@ -2,6 +2,7 @@ struct B_i16 { struct B_i16G_class *$class; short val; }; +extern GC_word B_i16D_gcbm[GC_BITMAP_SIZE(struct B_i16)]; B_i16 toB_i16(short n); diff --git a/builtin/i32.h b/builtin/i32.h index 37e4a10b2..81c37edad 100644 --- a/builtin/i32.h +++ b/builtin/i32.h @@ -2,6 +2,7 @@ struct B_i32 { struct B_i32G_class *$class; int val; }; +extern GC_word B_i32D_gcbm[GC_BITMAP_SIZE(struct B_i32)]; B_i32 toB_i32(int n); diff --git a/builtin/i64.h b/builtin/i64.h index 47d31454a..c9aa56b2a 100644 --- a/builtin/i64.h +++ b/builtin/i64.h @@ -2,6 +2,7 @@ struct B_i64 { struct B_i64G_class *$class; long val; }; +extern GC_word B_i64D_gcbm[GC_BITMAP_SIZE(struct B_i64)]; B_i64 toB_i64(long n); diff --git a/builtin/int.c b/builtin/int.c index b96eab018..04d8b118a 100644 --- a/builtin/int.c +++ b/builtin/int.c @@ -476,6 +476,7 @@ struct B_DivD_int B_DivD_int_instance; struct B_HashableD_int B_HashableD_int_instance; /* struct B_IntegralD_intG_class B_IntegralD_intG_methods = { + 0, "B_IntegralD_int", UNASSIGNED, ($SuperG_class)&B_IntegralG_methods, @@ -545,6 +546,7 @@ struct B_LogicalD_IntegralD_int B_LogicalD_IntegralD_int_instance = {&B_LogicalD B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intG_witness = &B_LogicalD_IntegralD_int_instance; /* struct B_MinusD_IntegralD_intG_class B_MinusD_IntegralD_intG_methods = { + 0, "B_MinusD_IntegralD_int", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -562,6 +564,7 @@ struct B_MinusD_IntegralD_int B_MinusD_IntegralD_int_instance = {&B_MinusD_Integ B_MinusD_IntegralD_int B_MinusD_IntegralD_intG_witness = &B_MinusD_IntegralD_int_instance; /* struct B_OrdD_intG_class B_OrdD_intG_methods = { + 0, "B_OrdD_int", UNASSIGNED, ($SuperG_class)&B_OrdG_methods, @@ -583,6 +586,7 @@ struct B_OrdD_int B_OrdD_int_instance = {&B_OrdD_intG_methods}; B_OrdD_int B_OrdD_intG_witness = &B_OrdD_int_instance; /* struct B_DivD_intG_class B_DivD_intG_methods = { + 0, "B_DivD_int", UNASSIGNED, ($SuperG_class)&B_DivG_methods, @@ -600,6 +604,7 @@ struct B_DivD_int B_DivD_int_instance = {&B_DivD_intG_methods}; B_DivD_int B_DivD_intG_witness = &B_DivD_int_instance; /* struct B_HashableD_intG_class B_HashableD_intG_methods = { + 0, "B_HashableD_int", UNASSIGNED, ($SuperG_class)&B_HashableG_methods, diff --git a/builtin/int.h b/builtin/int.h index b0166671d..a23c56cc2 100644 --- a/builtin/int.h +++ b/builtin/int.h @@ -4,6 +4,7 @@ struct B_int { struct B_intG_class *$class; zz_struct val; }; +extern GC_word B_intD_gcbm[GC_BITMAP_SIZE(struct B_int)]; extern struct B_IntegralD_int *B_IntegralD_intG_witness; extern struct B_HashableD_int *B_HashableD_intG_witness; diff --git a/builtin/list.c b/builtin/list.c index d6940becd..d16136395 100644 --- a/builtin/list.c +++ b/builtin/list.c @@ -291,8 +291,7 @@ B_IteratorD_list B_IteratorD_list$_deserialize(B_IteratorD_list res, $Serial$sta return res; } -struct B_IteratorD_listG_class B_IteratorD_listG_methods = {"B_IteratorD_list",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_listD_init, - B_IteratorD_listD_serialize, B_IteratorD_list$_deserialize,B_IteratorD_listD_bool,B_IteratorD_listD_str,B_IteratorD_listD_str,B_IteratorD_listD_next}; +struct B_IteratorD_listG_class B_IteratorD_listG_methods = {0,"B_IteratorD_list",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_listD_init, B_IteratorD_listD_serialize, B_IteratorD_list$_deserialize,B_IteratorD_listD_bool,B_IteratorD_listD_str,B_IteratorD_listD_str,B_IteratorD_listD_next}; // Now, we can define the protocol methods @@ -490,6 +489,7 @@ B_bool B_ContainerD_listD___containsnot__(B_ContainerD_list wit, B_list lst, $WO // so we need to initialize the below method table here, even if it is done in B___init__. struct B_SequenceD_listG_class B_SequenceD_listG_methods = { + 0, "B_SequenceD_list", UNASSIGNED, ($SuperG_class)&B_SequenceG_methods, diff --git a/builtin/list.h b/builtin/list.h index 546f020ee..9d76ab092 100644 --- a/builtin/list.h +++ b/builtin/list.h @@ -5,6 +5,7 @@ struct B_list { int length; int capacity; }; +extern GC_word B_listD_gcbm[GC_BITMAP_SIZE(struct B_list)]; extern struct B_SequenceD_list *B_SequenceD_listG_witness; extern struct B_CollectionD_SequenceD_list *B_CollectionD_SequenceD_listG_witness; @@ -17,7 +18,8 @@ extern struct B_CollectionD_SequenceD_list *B_CollectionD_SequenceD_listG_witnes typedef struct B_IteratorD_list *B_IteratorD_list; ; struct B_IteratorD_listG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_list, B_list); @@ -34,6 +36,7 @@ struct B_IteratorD_list { B_list src; int nxt; }; +extern GC_word B_IteratorD_listD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_list)]; extern struct B_IteratorD_listG_class B_IteratorD_listG_methods; B_IteratorD_list B_IteratorD_listG_new(B_list); diff --git a/builtin/none.c b/builtin/none.c index df80b8a8c..b0109c862 100644 --- a/builtin/none.c +++ b/builtin/none.c @@ -35,5 +35,4 @@ B_str B_NoneTypeD__str__(B_NoneType self) { return to$str("None"); } -struct B_NoneTypeG_class B_NoneTypeG_methods = {"B_NoneType",UNASSIGNED,($SuperG_class)&B_valueG_methods,(void (*)(B_NoneType))$default__init__, - B_NoneTypeD__serialize__, B_NoneTypeD__deserialize__, B_NoneTypeD__bool__, B_NoneTypeD__str__, B_NoneTypeD__str__}; +struct B_NoneTypeG_class B_NoneTypeG_methods = {0,"B_NoneType",UNASSIGNED,($SuperG_class)&B_valueG_methods,(void (*)(B_NoneType))$default__init__, B_NoneTypeD__serialize__, B_NoneTypeD__deserialize__, B_NoneTypeD__bool__, B_NoneTypeD__str__, B_NoneTypeD__str__}; diff --git a/builtin/none.h b/builtin/none.h index 3796d69c4..103fab030 100644 --- a/builtin/none.h +++ b/builtin/none.h @@ -1,5 +1,6 @@ struct B_NoneTypeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_NoneType); @@ -13,6 +14,7 @@ struct B_NoneTypeG_class { struct B_NoneType { struct B_NoneTypeG_class *$class; }; +extern GC_word B_NoneTypeD_gcbm[GC_BITMAP_SIZE(struct B_NoneType)]; extern struct B_NoneTypeG_class B_NoneTypeG_methods; B_NoneType B_NoneTypeG_new(); diff --git a/builtin/range.c b/builtin/range.c index 3b8e57120..331335f22 100644 --- a/builtin/range.c +++ b/builtin/range.c @@ -103,6 +103,7 @@ B_IteratorB_range B_IteratorB_range$_deserialize(B_IteratorB_range self, $Serial } struct B_IteratorB_rangeG_class B_IteratorB_rangeG_methods = { + 0, "B_IteratorB_range", UNASSIGNED, ($SuperG_class)&B_IteratorG_methods, diff --git a/builtin/range.h b/builtin/range.h index 3ca93e9fd..e85bef69a 100644 --- a/builtin/range.h +++ b/builtin/range.h @@ -5,13 +5,15 @@ struct B_range { long stop; long step; }; +extern GC_word B_rangeD_gcbm[GC_BITMAP_SIZE(struct B_range)]; // Iterators over ranges /////////////////////////////////////////////////////// typedef struct B_IteratorB_range *B_IteratorB_range; struct B_IteratorB_rangeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorB_range, B_range); @@ -28,6 +30,7 @@ struct B_IteratorB_range { B_range src; int nxt; }; +extern GC_word B_IteratorB_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_range)]; extern struct B_IteratorB_rangeG_class B_IteratorB_rangeG_methods; B_IteratorB_range B_IteratorB_rangeG_new(B_range); diff --git a/builtin/serialization_tests/ActorRing.c b/builtin/serialization_tests/ActorRing.c index 1de9f3f42..61559262a 100644 --- a/builtin/serialization_tests/ActorRing.c +++ b/builtin/serialization_tests/ActorRing.c @@ -45,6 +45,7 @@ lambda$1 lambda$1D___deserialize__(B_NoneType state) { } struct lambda$1G_class lambda$1G_methods = { + 0, "lambda$1", UNASSIGNED, NULL, @@ -94,6 +95,7 @@ lambda$2 lambda$2D___deserialize__(B_NoneType state) { } struct lambda$2G_class lambda$2G_methods = { + 0, "lambda$2", UNASSIGNED, NULL, @@ -160,6 +162,7 @@ Act ActD___deserialize__(B_NoneType state) { } struct ActG_class ActG_methods = { + 0, "Act", UNASSIGNED, NULL, @@ -209,6 +212,7 @@ lambda$3 lambda$3D___deserialize__(B_NoneType state) { } struct lambda$3G_class lambda$3G_methods = { + 0, "lambda$3", UNASSIGNED, NULL, @@ -251,6 +255,7 @@ lambda$4 lambda$4D___deserialize__(B_NoneType state) { } struct lambda$4G_class lambda$4G_methods = { + 0, "lambda$4", UNASSIGNED, NULL, @@ -311,6 +316,7 @@ Root RootD___deserialize__(B_NoneType state) { } struct RootG_class RootG_methods = { + 0, "Root", UNASSIGNED, NULL, @@ -322,7 +328,7 @@ struct RootG_class RootG_methods = { }; $R RootG_new(B_Env env, $Cont cont) { - Root $tmp = malloc(sizeof(struct Root)); + Root $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct Root), RootG_methods.$GCdescr); $tmp->$class = &RootG_methods; return RootG_methods.__init__($tmp, env, $CONSTCONT($tmp, cont)); } diff --git a/builtin/serialization_tests/ActorRing.h b/builtin/serialization_tests/ActorRing.h index ea31ae546..1f5422b05 100644 --- a/builtin/serialization_tests/ActorRing.h +++ b/builtin/serialization_tests/ActorRing.h @@ -19,7 +19,8 @@ typedef struct lambda$4 *lambda$4; typedef struct Root *Root; struct lambda$1G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$1, $Cont); @@ -33,9 +34,11 @@ struct lambda$1 { struct lambda$1G_class *$class; $Cont cont$0; }; +extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)]; struct lambda$2G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$2, Act, B_int, B_list); @@ -51,9 +54,11 @@ struct lambda$2 { B_int from; B_list table; }; +extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)]; struct ActG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; $R (*__init__)(Act, B_int, $Cont); @@ -74,9 +79,11 @@ struct Act { B_dict rcv_dict; B_dict snd_dict; }; +extern GC_word ActD_gcbm[GC_BITMAP_SIZE(struct Act)]; struct lambda$3G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$3, Root, B_Iterator, $Cont); @@ -92,9 +99,11 @@ struct lambda$3 { B_Iterator iter$1; $Cont cont$0; }; +extern GC_word lambda$3D_gcbm[GC_BITMAP_SIZE(struct lambda$3)]; struct lambda$4G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$4, $Cont); @@ -108,9 +117,11 @@ struct lambda$4 { struct lambda$4G_class *$class; $Cont cont$0; }; +extern GC_word lambda$4D_gcbm[GC_BITMAP_SIZE(struct lambda$4)]; struct RootG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; $R (*__init__)(Root, B_Env, $Cont); @@ -126,6 +137,7 @@ struct Root { }; B_list table; }; +extern GC_word RootD_gcbm[GC_BITMAP_SIZE(struct Root)]; $R loop$1(Root, B_Iterator, $Cont, $WORD); $R cont$1(Root, B_Iterator, $Cont, Act); diff --git a/builtin/serialization_tests/graph.c b/builtin/serialization_tests/graph.c index 70a8fcb56..4a179a289 100644 --- a/builtin/serialization_tests/graph.c +++ b/builtin/serialization_tests/graph.c @@ -38,8 +38,7 @@ B_str $Node__str__($Node self) { return res; } -struct $NodeG_class $NodeG_methods = {"",UNASSIGNED,NULL,$Node__init__,$Node__serialize__,$Node__deserialize__,$Node__bool__,$Node__str__}; - +struct $NodeG_class $NodeG_methods = {0,"",UNASSIGNED,NULL,$Node__init__,$Node__serialize__,$Node__deserialize__,$Node__bool__,$Node__str__}; // IntNodes (graph vertices) //////////////////////////////////////////////////////////////////////////// void $IntNode__init__($IntNode self, B_list nbors, B_int ival) { @@ -67,8 +66,7 @@ void $IntNode__serialize__($IntNode self,B_NoneType state) { return res; } -struct $IntNodeG_class $IntNodeG_methods = {"",UNASSIGNED,NULL,$IntNode__init__,$IntNode__serialize__,$IntNode__deserialize__,$IntNode__bool__,$IntNode__str__}; - +struct $IntNodeG_class $IntNodeG_methods = {0,"",UNASSIGNED,NULL,$IntNode__init__,$IntNode__serialize__,$IntNode__deserialize__,$IntNode__bool__,$IntNode__str__}; // FloatNodes (graph vertices) //////////////////////////////////////////////////////////////////////////// @@ -97,8 +95,7 @@ void $FloatNode__serialize__($FloatNode self,B_NoneType state) { return res; } -struct $FloatNodeG_class $FloatNodeG_methods = {"",UNASSIGNED,NULL,$FloatNode__init__,$FloatNode__serialize__,$FloatNode__deserialize__,$FloatNode__bool__,$FloatNode__str__}; - +struct $FloatNodeG_class $FloatNodeG_methods = {0,"",UNASSIGNED,NULL,$FloatNode__init__,$FloatNode__serialize__,$FloatNode__deserialize__,$FloatNode__bool__,$FloatNode__str__}; // Graphs //////////////////////////////////////////////////////////////////////////// @@ -125,8 +122,7 @@ void $Graph__serialize__($Graph self, B_NoneType state) { return res; } -struct $GraphG_class $GraphG_methods = {"",UNASSIGNED,NULL,$Graph__init__,$Graph__serialize__,$Graph__deserialize__,$Graph__bool__,$Graph__str__}; - +struct $GraphG_class $GraphG_methods = {0,"",UNASSIGNED,NULL,$Graph__init__,$Graph__serialize__,$Graph__deserialize__,$Graph__bool__,$Graph__str__}; void $register_graph(){ $register(&$NodeG_methods); $register(&$IntNodeG_methods); diff --git a/builtin/serialization_tests/graph.h b/builtin/serialization_tests/graph.h index 1f545e62d..5123be234 100644 --- a/builtin/serialization_tests/graph.h +++ b/builtin/serialization_tests/graph.h @@ -7,7 +7,8 @@ struct $Node; typedef struct $Node *$Node; struct $NodeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($Node, B_list); @@ -21,6 +22,7 @@ struct $Node { struct $NodeG_class *$class; B_list nbors; // list of Nodes }; +extern GC_word $NodeD_gcbm[GC_BITMAP_SIZE(struct $Node)]; extern struct $NodeG_class $NodeG_methods; @@ -31,7 +33,8 @@ struct $IntNode; typedef struct $IntNode *$IntNode; struct $IntNodeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($IntNode, B_list, B_int); @@ -46,6 +49,7 @@ struct $IntNode { B_list nbors; // list of Nodes B_int ival; }; +extern GC_word $IntNodeD_gcbm[GC_BITMAP_SIZE(struct $IntNode)]; extern struct $IntNodeG_class $IntNodeG_methods; @@ -56,7 +60,8 @@ struct $FloatNode; typedef struct $FloatNode *$FloatNode; struct $FloatNodeG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($FloatNode, B_list, B_float); @@ -71,6 +76,7 @@ struct $FloatNode { B_list nbors; // list of Nodes B_float fval; }; +extern GC_word $FloatNodeD_gcbm[GC_BITMAP_SIZE(struct $FloatNode)]; extern struct $FloatNodeG_class $FloatNodeG_methods; @@ -79,7 +85,8 @@ extern struct $FloatNodeG_class $FloatNodeG_methods; typedef struct $Graph *$Graph; struct $GraphG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($Graph, B_list); @@ -93,6 +100,7 @@ struct $Graph { struct $GraphG_class *$class; B_list nodes; }; +extern GC_word $GraphD_gcbm[GC_BITMAP_SIZE(struct $Graph)]; extern struct $GraphG_class $GraphG_methods; diff --git a/builtin/serialize.c b/builtin/serialize.c index 752355219..8ab8b1155 100644 --- a/builtin/serialize.c +++ b/builtin/serialize.c @@ -54,6 +54,7 @@ B_int B_HashableD_WORD_hash(B_HashableD_WORD wit, $WORD a) { } struct B_HashableD_WORDG_class B_HashableD_WORDG_methods = { + 0, "B_HashableD_WORD", UNASSIGNED, ($SuperG_class)&B_HashableG_methods, diff --git a/builtin/serialize.h b/builtin/serialize.h index 6d818e4be..04d6107b1 100644 --- a/builtin/serialize.h +++ b/builtin/serialize.h @@ -23,13 +23,15 @@ struct $ROWLISTHEADER { //typedef struct $Serial$state *$Serial$state; struct $Serial$state { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; B_dict done; $WORD (*globmap)($WORD); long row_no; $ROW row; $ROW fst; //not used in deserialization }; +extern GC_word $Serial$stateD_gcbm[GC_BITMAP_SIZE(struct $Serial$state)]; // small-step helpers for defining serializations ////////////////////////////////////////////////// @@ -64,7 +66,8 @@ void $serialize_file($Serializable s, char *file); typedef struct B_HashableD_WORD *B_HashableD_WORD; struct B_HashableD_WORDG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class superclass; void (*__init__)(B_HashableD_WORD); @@ -81,6 +84,7 @@ struct B_HashableD_WORDG_class { struct B_HashableD_WORD { struct B_HashableD_WORDG_class *$class; }; +extern GC_word B_HashableD_WORDD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_WORD)]; extern struct B_HashableD_WORDG_class B_HashableD_WORDG_methods; B_HashableD_WORD B_HashableD_WORDG_new(); diff --git a/builtin/set.c b/builtin/set.c index 6a14e5be4..69ca34330 100644 --- a/builtin/set.c +++ b/builtin/set.c @@ -353,8 +353,7 @@ B_IteratorD_set B_IteratorD_setD__deserialize(B_IteratorD_set res, $Serial$state return res; } -struct B_IteratorD_setG_class B_IteratorD_setG_methods = {"B_IteratorD_set",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_set_init, - B_IteratorD_set_serialize, B_IteratorD_setD__deserialize,B_IteratorD_set_bool,B_IteratorD_set_str,B_IteratorD_set_str, B_IteratorD_set_next}; +struct B_IteratorD_setG_class B_IteratorD_setG_methods = {0,"B_IteratorD_set",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_set_init, B_IteratorD_set_serialize, B_IteratorD_setD__deserialize,B_IteratorD_set_bool,B_IteratorD_set_str,B_IteratorD_set_str, B_IteratorD_set_next}; B_Iterator B_SetD_setD___iter__ (B_SetD_set wit, B_set set) { diff --git a/builtin/set.h b/builtin/set.h index 6e87a298c..580650c8b 100644 --- a/builtin/set.h +++ b/builtin/set.h @@ -12,6 +12,7 @@ struct B_set { long finger; // Search finger for pop() B_setentry *table; // the hashtable }; +extern GC_word B_setD_gcbm[GC_BITMAP_SIZE(struct B_set)]; // Iterators over sets /////////////////////////////////////////////////////// @@ -19,7 +20,8 @@ struct B_set { typedef struct B_IteratorD_set *B_IteratorD_set; ; struct B_IteratorD_setG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_IteratorD_set, B_set); @@ -36,6 +38,7 @@ struct B_IteratorD_set { B_set src; int nxt; }; +extern GC_word B_IteratorD_setD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_set)]; extern struct B_IteratorD_setG_class B_IteratorD_setG_methods; B_IteratorD_set B_IteratorD_setG_new(B_set); diff --git a/builtin/slice.h b/builtin/slice.h index 92f636e4b..c0f405ee1 100644 --- a/builtin/slice.h +++ b/builtin/slice.h @@ -5,5 +5,6 @@ struct B_slice { long *stop; long *step; }; +extern GC_word B_sliceD_gcbm[GC_BITMAP_SIZE(struct B_slice)]; void normalize_slice(B_slice slc, long len, long *slen, long *start, long *stop, long *step); diff --git a/builtin/str.c b/builtin/str.c index 5bb6f8df9..f204a3631 100644 --- a/builtin/str.c +++ b/builtin/str.c @@ -1256,8 +1256,7 @@ static B_str B_IteratorB_strD_next(B_IteratorB_str self) { } -struct B_IteratorB_strG_class B_IteratorB_strG_methods = {"B_IteratorB_str",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_strD_init, - B_IteratorB_strD_serialize, B_IteratorB_str$_deserialize, +struct B_IteratorB_strG_class B_IteratorB_strG_methods = {0,"B_IteratorB_str",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_strD_init, B_IteratorB_strD_serialize, B_IteratorB_str$_deserialize, B_IteratorB_strD_bool, B_IteratorB_strD_str, B_IteratorB_strD_str, B_IteratorB_strD_next}; // now, define __iter__ @@ -2085,6 +2084,7 @@ B_IteratorB_bytearray B_IteratorB_bytearray$_deserialize(B_IteratorB_bytearray r } struct B_IteratorB_bytearrayG_class B_IteratorB_bytearrayG_methods = { + 0, "", UNASSIGNED, ($SuperG_class)&B_IteratorG_methods, @@ -3097,8 +3097,7 @@ static B_int B_IteratorB_bytesD_next(B_IteratorB_bytes self) { return self->nxt >= self->src->nbytes ? NULL : to$int(self->src->str[self->nxt++]); } -struct B_IteratorB_bytesG_class B_IteratorB_bytesG_methods = {"B_IteratorB_bytes",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_bytesD_init, - B_IteratorB_bytesD_serialize, B_IteratorB_bytes$_deserialize, +struct B_IteratorB_bytesG_class B_IteratorB_bytesG_methods = {0,"B_IteratorB_bytes",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_bytesD_init, B_IteratorB_bytesD_serialize, B_IteratorB_bytes$_deserialize, B_IteratorB_bytesD_bool, B_IteratorB_bytesD_str, B_IteratorB_bytesD_str, B_IteratorB_bytesD_next}; B_Iterator B_ContainerD_bytesD___iter__ (B_ContainerD_bytes wit, B_bytes str) { @@ -3368,7 +3367,7 @@ B_str B_strD_join_par(char lpar, B_list elems, char rpar) { B_str $default__str__(B_value self) { char *s; - asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self); + asprintf(&s,"<%s object at %p>",self->$class->$name,self); return to$str(s); } diff --git a/builtin/str.h b/builtin/str.h index 5b3ab1232..eb65a7b6b 100644 --- a/builtin/str.h +++ b/builtin/str.h @@ -6,6 +6,7 @@ struct B_str { int nchars; // length of str in Unicode chars unsigned char *str; // str is UTF-8 encoded. }; +extern GC_word B_strD_gcbm[GC_BITMAP_SIZE(struct B_str)]; // Constructor; str must be a null-terminated, correctly UTF-8-encoded string. // The constructor checks this and returns a B_str value. @@ -18,7 +19,8 @@ unsigned char *fromB_str(B_str str); typedef struct B_IteratorB_str *B_IteratorB_str; ; struct B_IteratorB_strG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_IteratorB_str, B_str); @@ -35,6 +37,7 @@ struct B_IteratorB_str { B_str src; int nxt; }; +extern GC_word B_IteratorB_strD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_str)]; extern struct B_IteratorB_strG_class B_IteratorB_strG_methods; B_IteratorB_str B_IteratorB_strG_new(B_str); @@ -49,6 +52,7 @@ struct B_bytearray { unsigned char *str; int capacity; }; +extern GC_word B_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_bytearray)]; B_bytearray toB_bytearray(char *str); @@ -59,7 +63,8 @@ unsigned char *fromB_bytearray(B_bytearray b); typedef struct B_IteratorB_bytearray *B_IteratorB_bytearray; ; struct B_IteratorB_bytearrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_IteratorB_bytearray, B_bytearray); @@ -76,6 +81,7 @@ struct B_IteratorB_bytearray { B_bytearray src; int nxt; }; +extern GC_word B_IteratorB_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_bytearray)]; extern struct B_IteratorB_bytearrayG_class B_IteratorB_bytearrayG_methods; B_IteratorB_bytearray B_IteratorB_bytearrayG_new(B_bytearray); @@ -88,6 +94,7 @@ struct B_bytes { int nbytes; unsigned char *str; }; +extern GC_word B_bytesD_gcbm[GC_BITMAP_SIZE(struct B_bytes)]; B_bytes to$bytes(char *str); B_bytes to$bytesD_len(char *str, int len); @@ -100,7 +107,8 @@ unsigned char *fromB_bytes(B_bytes b); typedef struct B_IteratorB_bytes *B_IteratorB_bytes; ; struct B_IteratorB_bytesG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_IteratorB_bytes, B_bytes); @@ -117,6 +125,7 @@ struct B_IteratorB_bytes { B_bytes src; int nxt; }; +extern GC_word B_IteratorB_bytesD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_bytes)]; extern struct B_IteratorB_bytesG_class B_IteratorB_bytesG_methods; B_IteratorB_bytes B_IteratorB_bytesG_new(B_bytes); diff --git a/builtin/tests/Pingpong.c b/builtin/tests/Pingpong.c index 5ef0da095..c5d7c80f4 100644 --- a/builtin/tests/Pingpong.c +++ b/builtin/tests/Pingpong.c @@ -82,6 +82,7 @@ Pingpong PingpongD___deserialize__(B_NoneType state) { } struct lambda$1G_class lambda$1G_methods = { + 0, "lambda$1", NULL, lambda$1D___init__, @@ -90,6 +91,7 @@ struct lambda$1G_class lambda$1G_methods = { lambda$1D___call__ }; struct lambda$2G_class lambda$2G_methods = { + 0, "lambda$2", NULL, lambda$2D___init__, @@ -98,6 +100,7 @@ struct lambda$2G_class lambda$2G_methods = { lambda$2D___call__ }; struct PingpongG_class PingpongG_methods = { + 0, "Pingpong", NULL, PingpongD___init__, @@ -108,7 +111,7 @@ struct PingpongG_class PingpongG_methods = { }; $R PingpongG_new(B_Env env, $Cont cont) { - Pingpong $tmp = malloc(sizeof(struct Pingpong)); + Pingpong $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct Pingpong), PingpongG_methods.$GCdescr); $tmp->$class = &PingpongG_methods; return PingpongG_methods.__init__($tmp, env, $CONSTCONT($tmp, cont)); } diff --git a/builtin/tests/Pingpong.h b/builtin/tests/Pingpong.h index f79442e3b..e33eef484 100644 --- a/builtin/tests/Pingpong.h +++ b/builtin/tests/Pingpong.h @@ -13,7 +13,8 @@ typedef struct lambda$2 *lambda$2; typedef struct Pingpong *Pingpong; struct lambda$1G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; $SuperG_class $superclass; void (*__init__)(lambda$1, Pingpong, B_int); void (*__serialize__)(lambda$1, B_NoneType); @@ -28,9 +29,11 @@ struct lambda$1 { Pingpong self; B_int count; }; +extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)]; struct lambda$2G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; $SuperG_class $superclass; void (*__init__)(lambda$2, Pingpong); void (*__serialize__)(lambda$2, B_NoneType); @@ -44,9 +47,11 @@ struct lambda$2 { }; Pingpong self; }; +extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)]; struct PingpongG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; $SuperG_class $superclass; $R (*__init__)(Pingpong, B_Env, $Cont); void (*__serialize__)(Pingpong, B_NoneType); @@ -62,6 +67,7 @@ struct Pingpong { B_int i; B_int count; }; +extern GC_word PingpongD_gcbm[GC_BITMAP_SIZE(struct Pingpong)]; extern struct lambda$1G_class lambda$1G_methods; extern struct lambda$2G_class lambda$2G_methods; diff --git a/builtin/tuple.c b/builtin/tuple.c index a924ce265..2079de827 100644 --- a/builtin/tuple.c +++ b/builtin/tuple.c @@ -74,6 +74,7 @@ B_tuple B_tupleD___deserialize__(B_tuple self, $Serial$state state) { } struct B_tupleG_class B_tupleG_methods = { + 0, "tuple", UNASSIGNED, ($SuperG_class)&B_valueG_methods, @@ -118,8 +119,7 @@ B_IteratorD_tuple B_IteratorD_tuple$_deserialize(B_IteratorD_tuple res, $Serial$ return res; } -struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods = {"B_IteratorD_tuple",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_tupleD_init, - B_IteratorD_tupleD_serialize,B_IteratorD_tuple$_deserialize,B_IteratorD_tupleD_bool,B_IteratorD_tupleD_str,B_IteratorD_tupleD_str,B_IteratorD_tupleD_next}; +struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods = {0,"B_IteratorD_tuple",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_tupleD_init, B_IteratorD_tupleD_serialize,B_IteratorD_tuple$_deserialize,B_IteratorD_tupleD_bool,B_IteratorD_tupleD_str,B_IteratorD_tupleD_str,B_IteratorD_tupleD_next}; // Iterable /////////////////////////////////////////////////////////////// @@ -140,6 +140,7 @@ B_IterableD_tuple B_IterableD_tupleD___deserialize__(B_IterableD_tuple self, $Se return res; } struct B_IterableD_tupleG_class B_IterableD_tupleG_methods = { + 0, "B_IterableD_tuple", UNASSIGNED, ($SuperG_class)&B_IterableG_methods, @@ -219,6 +220,7 @@ B_NoneType B_SliceableD_tupleD___delslice__ (B_SliceableD_tuple wit, B_tuple sel } struct B_SliceableD_tupleG_class B_SliceableD_tupleG_methods = { + 0, "B_SliceableD_tuple", UNASSIGNED, ($SuperG_class)&B_SliceableG_methods, @@ -274,6 +276,7 @@ B_int B_HashableD_tupleD___hash__ (B_HashableD_tuple wit, B_tuple tup) { } struct B_HashableD_tupleG_class B_HashableD_tupleG_methods = { + 0, "B_HashableD_tuple", UNASSIGNED, ($SuperG_class)&B_HashableG_methods, diff --git a/builtin/tuple.h b/builtin/tuple.h index f0f86d81b..b8a0a5e9e 100644 --- a/builtin/tuple.h +++ b/builtin/tuple.h @@ -1,5 +1,6 @@ struct B_tupleG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_tuple,int,...); @@ -15,6 +16,7 @@ struct B_tuple { int size; $WORD *components; }; +extern GC_word B_tupleD_gcbm[GC_BITMAP_SIZE(struct B_tuple)]; extern struct B_tupleG_class B_tupleG_methods; B_tuple B_tupleG_new(int,...); @@ -57,9 +59,11 @@ typedef struct B_HashableD_tupleG_class *B_HashableD_tupleG_class; struct B_IterableD_tuple { B_IterableD_tupleG_class $class; }; +extern GC_word B_IterableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_tuple)]; struct B_IterableD_tupleG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_IterableD_tuple); @@ -86,9 +90,11 @@ B_IterableD_tuple B_IterableD_tupleG_new(); struct B_SliceableD_tuple { B_SliceableD_tupleG_class $class; }; +extern GC_word B_SliceableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_tuple)]; struct B_SliceableD_tupleG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_SliceableD_tuple); @@ -125,9 +131,11 @@ struct B_HashableD_tuple { int W_HashableB_tuple$size; B_Hashable *W_Hashable; }; +extern GC_word B_HashableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_tuple)]; struct B_HashableD_tupleG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_HashableD_tuple,int,B_Hashable*); @@ -165,7 +173,8 @@ extern struct B_HashableD_tuple *B_HashableD_tuple_new(int,B_Hashable*); typedef struct B_IteratorD_tuple *B_IteratorD_tuple; struct B_IteratorD_tupleG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(B_IteratorD_tuple, B_tuple); @@ -182,6 +191,7 @@ struct B_IteratorD_tuple { B_tuple src; int nxt; }; +extern GC_word B_IteratorD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_tuple)]; extern struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods; B_IteratorD_tuple B_IteratorD_tupleG_new(B_tuple); diff --git a/builtin/u16.h b/builtin/u16.h index 5b3929720..c4926ecbd 100644 --- a/builtin/u16.h +++ b/builtin/u16.h @@ -2,6 +2,7 @@ struct B_u16 { struct B_u16G_class *$class; unsigned short val; }; +extern GC_word B_u16D_gcbm[GC_BITMAP_SIZE(struct B_u16)]; B_u16 toB_u16(unsigned short n); unsigned short fromB_u16(B_u16 n); diff --git a/builtin/u32.h b/builtin/u32.h index 0c1490b22..75d8a4c01 100644 --- a/builtin/u32.h +++ b/builtin/u32.h @@ -2,6 +2,7 @@ struct B_u32 { struct B_u32G_class *$class; unsigned int val; }; +extern GC_word B_u32D_gcbm[GC_BITMAP_SIZE(struct B_u32)]; B_u32 toB_u32(unsigned int n); unsigned int fromB_u32(B_u32 n); diff --git a/builtin/u64.h b/builtin/u64.h index 2582053b5..e413985ac 100644 --- a/builtin/u64.h +++ b/builtin/u64.h @@ -2,6 +2,7 @@ struct B_u64 { struct B_u64G_class *$class; unsigned long val; }; +extern GC_word B_u64D_gcbm[GC_BITMAP_SIZE(struct B_u64)]; B_u64 toB_u64(unsigned long n); unsigned long fromB_u64(B_u64 n); diff --git a/rts/pingpong.c b/rts/pingpong.c index a2ac0df14..05cdb1de6 100644 --- a/rts/pingpong.c +++ b/rts/pingpong.c @@ -200,6 +200,7 @@ Pingpong PingpongD___deserialize__(Pingpong res, B_NoneType state) { //////////////////////////////////////////////////////////////////////////////////////// struct lambda$1G_class lambda$1G_methods = { + 0, "lambda$1", UNASSIGNED, ($SuperG_class)&$ContG_methods, @@ -211,6 +212,7 @@ struct lambda$1G_class lambda$1G_methods = { lambda$1D___call__ }; struct lambda$2G_class lambda$2G_methods = { + 0, "lambda$2", UNASSIGNED, ($SuperG_class)&$ContG_methods, @@ -222,6 +224,7 @@ struct lambda$2G_class lambda$2G_methods = { lambda$2D___call__ }; struct lambda$3G_class lambda$3G_methods = { + 0, "lambda$3", UNASSIGNED, ($SuperG_class)&$ContG_methods, @@ -233,6 +236,7 @@ struct lambda$3G_class lambda$3G_methods = { lambda$3D___call__ }; struct PingpongG_class PingpongG_methods = { + 0, "Pingpong", UNASSIGNED, ($SuperG_class)&$ActorG_methods, diff --git a/rts/pingpong.h b/rts/pingpong.h index 5909e3888..47f45fed5 100644 --- a/rts/pingpong.h +++ b/rts/pingpong.h @@ -13,7 +13,8 @@ typedef struct lambda$3 *lambda$3; typedef struct Pingpong *Pingpong; struct lambda$1G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$1, Pingpong, B_int, B_int); @@ -29,10 +30,12 @@ struct lambda$1 { B_int count; B_int q; }; +extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)]; lambda$1 lambda$1G_new(Pingpong, B_int, B_int); struct lambda$2G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$2, Pingpong, B_int); @@ -47,10 +50,12 @@ struct lambda$2 { Pingpong self; B_int q; }; +extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)]; lambda$2 lambda$2G_new(Pingpong, B_int); struct lambda$3G_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(lambda$3, $Cont); @@ -64,10 +69,12 @@ struct lambda$3 { struct lambda$3G_class *$class; $Cont cont; }; +extern GC_word lambda$3D_gcbm[GC_BITMAP_SIZE(struct lambda$3)]; lambda$3 lambda$3G_new($Cont); struct PingpongG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; $R (*__init__)(Pingpong, B_int, $Cont); @@ -92,6 +99,7 @@ struct Pingpong { B_int i; B_int count; }; +extern GC_word PingpongD_gcbm[GC_BITMAP_SIZE(struct Pingpong)]; $R PingpongG_new(B_int, $Cont); extern struct lambda$1G_class lambda$1G_methods; diff --git a/rts/rts.c b/rts/rts.c index 43b4e1dd3..0f4f2aece 100644 --- a/rts/rts.c +++ b/rts/rts.c @@ -230,7 +230,7 @@ pthread_cond_t rts_exit_signal = PTHREAD_COND_INITIALIZER; void pin_actor_affinity() { $Actor a = ($Actor)pthread_getspecific(self_key); int i = (int)pthread_getspecific(pkey_wtid); - log_debug("Pinning affinity for %s actor %ld to current WT %d", a->$class->$GCINFO, a->$globkey, i); + log_debug("Pinning affinity for %s actor %ld to current WT %d", a->$class->$name, a->$globkey, i); a->$affinity = i; } @@ -348,7 +348,7 @@ void $ActorD___init__($Actor a) { atomic_flag_clear(&a->B_Msg_lock); a->$globkey = get_next_key(); a->$affinity = 0; - rtsd_printf("# New Actor %ld at %p of class %s", a->$globkey, a, a->$class->$GCINFO); + rtsd_printf("# New Actor %ld at %p of class %s", a->$globkey, a, a->$class->$name); } B_bool $ActorD___bool__($Actor self) { @@ -357,7 +357,7 @@ B_bool $ActorD___bool__($Actor self) { B_str $ActorD___str__($Actor self) { char *s; - asprintf(&s,"<$Actor %ld %s at %p>", self->$globkey, self->$class->$GCINFO, self); + asprintf(&s,"<$Actor %ld %s at %p>", self->$globkey, self->$class->$name, self); return to$str(s); } @@ -463,6 +463,7 @@ void $ConstContD___serialize__($ConstCont self, $Serial$state state) { //////////////////////////////////////////////////////////////////////////////////////// struct B_MsgG_class B_MsgG_methods = { + 0, MSG_HEADER, UNASSIGNED, NULL, @@ -475,6 +476,7 @@ struct B_MsgG_class B_MsgG_methods = { }; struct $ActorG_class $ActorG_methods = { + 0, ACTOR_HEADER, UNASSIGNED, NULL, @@ -488,6 +490,7 @@ struct $ActorG_class $ActorG_methods = { }; struct $CatcherG_class $CatcherG_methods = { + 0, CATCHER_HEADER, UNASSIGNED, NULL, @@ -500,6 +503,7 @@ struct $CatcherG_class $CatcherG_methods = { }; struct $ConstContG_class $ConstContG_methods = { + 0, "$ConstCont", UNASSIGNED, NULL, @@ -703,6 +707,7 @@ void $Done__serialize__($Cont self, $Serial$state state) { } struct $ContG_class $DoneG_methods = { + 0, "$Done", UNASSIGNED, NULL, @@ -743,6 +748,7 @@ void $Fail__serialize__($Cont self, $Serial$state state) { } struct $ContG_class $FailG_methods = { + 0, "$Fail", UNASSIGNED, NULL, @@ -764,6 +770,7 @@ struct $Cont $Fail$instance = { } struct $ContG_class $InitRootG_methods = { + 0, "$InitRoot", UNASSIGNED, NULL, @@ -1163,7 +1170,7 @@ void deserialize_system(snode_t *actors_start) { B_Msg msg = (B_Msg)$GET_METHODS(head->class_id)->__deserialize__(NULL, NULL); msg->$globkey = key; B_dictD_setitem(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), msg); - rtsd_printf("# Allocated Msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$GCINFO, msg->$class->$class_id); + rtsd_printf("# Allocated Msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$name, msg->$class->$class_id); if (key < min_key) min_key = key; } @@ -1180,7 +1187,7 @@ void deserialize_system(snode_t *actors_start) { $Actor act = ($Actor)$GET_METHODS(head->class_id)->__deserialize__(NULL, NULL); act->$globkey = key; B_dictD_setitem(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), act); - rtsd_printf("# Allocated Actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id); + rtsd_printf("# Allocated Actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id); if (key < min_key) min_key = key; } @@ -1198,7 +1205,7 @@ void deserialize_system(snode_t *actors_start) { int blob_size = r2->last_blob_size; $ROW row = extract_row(blob, blob_size); B_Msg msg = (B_Msg)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL); - rtsd_printf("####### Deserializing msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$GCINFO, msg->$class->$class_id); + rtsd_printf("####### Deserializing msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$name, msg->$class->$class_id); print_rows(row); $glob_deserialize(($Serializable)msg, row, try_globdict); print_msg(msg); @@ -1215,7 +1222,7 @@ void deserialize_system(snode_t *actors_start) { int blob_size = r2->last_blob_size; $ROW row = extract_row(blob, blob_size); $Actor act = ($Actor)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL); - rtsd_printf("####### Deserializing actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id); + rtsd_printf("####### Deserializing actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id); print_rows(row); $glob_deserialize(($Serializable)act, row, try_globdict); @@ -1252,7 +1259,7 @@ void deserialize_system(snode_t *actors_start) { db_row_t* r = (db_row_t*) node->value; long key = (long)r->key; $Actor act = ($Actor)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL); - rtsd_printf("####### Resuming actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id); + rtsd_printf("####### Resuming actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id); act->$class->__resume__(act); } @@ -1526,7 +1533,7 @@ void wt_work_cb(uv_check_t *ev) { clock_gettime(CLOCK_MONOTONIC, &ts1); wt_stats[wtid].state = WT_Working; - rtsd_printf("## Running actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## Running actor %ld : %s", current->$globkey, current->$class->$name); $R r = cont->$class->__call__(cont, val); clock_gettime(CLOCK_MONOTONIC, &ts2); @@ -1557,10 +1564,10 @@ void wt_work_cb(uv_check_t *ev) { b->$waitsfor = NULL; $Actor c = b->$next; ENQ_ready(b); - rtsd_printf("## Waking up actor %ld : %s", b->$globkey, b->$class->$GCINFO); + rtsd_printf("## Waking up actor %ld : %s", b->$globkey, b->$class->$name); b = c; } - rtsd_printf("## DONE actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## DONE actor %ld : %s", current->$globkey, current->$class->$name); if (DEQ_msg(current)) { ENQ_ready(current); } @@ -1569,7 +1576,7 @@ void wt_work_cb(uv_check_t *ev) { case $RCONT: { m->$cont = r.cont; m->B_value = r.value; - rtsd_printf("## CONT actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## CONT actor %ld : %s", current->$globkey, current->$class->$name); ENQ_ready(current); break; } @@ -1578,7 +1585,7 @@ void wt_work_cb(uv_check_t *ev) { if (c) { // Normal exception handling m->$cont = c->$cont; m->B_value = r.value; - rtsd_printf("## FAIL/handle actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## FAIL/handle actor %ld : %s", current->$globkey, current->$class->$name); ENQ_ready(current); } else { // An unhandled exception save_actor_state(current, m); @@ -1590,10 +1597,10 @@ void wt_work_cb(uv_check_t *ev) { b->$waitsfor = NULL; $Actor c = b->$next; ENQ_ready(b); - rtsd_printf("## Propagating exception to actor %ld : %s", b->$globkey, b->$class->$GCINFO); + rtsd_printf("## Propagating exception to actor %ld : %s", b->$globkey, b->$class->$name); b = c; } - rtsd_printf("## FAIL actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## FAIL actor %ld : %s", current->$globkey, current->$class->$name); if (DEQ_msg(current)) { ENQ_ready(current); } @@ -1626,15 +1633,15 @@ void wt_work_cb(uv_check_t *ev) { m->$cont = r.cont; B_Msg x = (B_Msg)r.value; if (ADD_waiting(current, x)) { // x->cont is a proper $Cont: x is still being processed so current was added to x->waiting - rtsd_printf("## AWAIT actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## AWAIT actor %ld : %s", current->$globkey, current->$class->$name); current->$waitsfor = x; } else if (EXCEPTIONAL(x)) { // x->cont == MARK_EXCEPTION: x->value holds the raised exception, current is not in x->waiting - rtsd_printf("## AWAIT/fail actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## AWAIT/fail actor %ld : %s", current->$globkey, current->$class->$name); m->$cont = &$Fail$instance; m->B_value = x->B_value; ENQ_ready(current); } else { // x->cont == MARK_RESULT: x->value holds the final response, current is not in x->waiting - rtsd_printf("## AWAIT/wakeup actor %ld : %s", current->$globkey, current->$class->$GCINFO); + rtsd_printf("## AWAIT/wakeup actor %ld : %s", current->$globkey, current->$class->$name); m->B_value = x->B_value; ENQ_ready(current); } diff --git a/rts/rts.h b/rts/rts.h index dade10c4e..6f4c2d8c6 100644 --- a/rts/rts.h +++ b/rts/rts.h @@ -51,7 +51,8 @@ extern struct $ConstContG_class $ConstContG_methods; #define $Lock volatile atomic_flag struct B_MsgG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)(B_Msg, $Actor, $Cont, time_t, $WORD); @@ -72,9 +73,11 @@ struct B_Msg { $WORD B_value; $long $globkey; }; +extern GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)]; struct $ActorG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($Actor); @@ -97,9 +100,11 @@ struct $Actor { $long $globkey; $int64 $affinity; }; +extern GC_word $ActorD_gcbm[GC_BITMAP_SIZE(struct $Actor)]; struct $CatcherG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($Catcher, $Cont); @@ -114,10 +119,12 @@ struct $Catcher { $Catcher $next; $Cont $cont; }; +extern GC_word $CatcherD_gcbm[GC_BITMAP_SIZE(struct $Catcher)]; struct $ConstContG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; void (*__init__)($ConstCont, $WORD, $Cont); @@ -133,6 +140,7 @@ struct $ConstCont { $WORD val; $Cont cont; }; +extern GC_word $ConstContD_gcbm[GC_BITMAP_SIZE(struct $ConstCont)]; $Cont $CONSTCONT($WORD, $Cont); B_Msg $ASYNC($Actor, $Cont); diff --git a/stdlib/c_src/numpy/ndarray.c b/stdlib/c_src/numpy/ndarray.c index df0961cb7..8d169b0ff 100644 --- a/stdlib/c_src/numpy/ndarray.c +++ b/stdlib/c_src/numpy/ndarray.c @@ -363,6 +363,7 @@ numpyQ_ndarray numpyQ_ndarrayD___ndgetslice__(numpyQ_ndarray a, B_list ix) { } struct numpyQ_ndarrayG_class numpyQ_ndarrayG_methods = { + 0, "numpyQ_ndarray", UNASSIGNED, ($SuperG_class)&B_valueG_methods, @@ -849,8 +850,7 @@ numpyQ_IteratorD_ndarray numpyQ_IteratorD_ndarray$_deserialize(numpyQ_IteratorD_ return NULL; } -struct numpyQ_IteratorD_ndarrayG_class numpyQ_IteratorD_ndarrayG_methods = {"",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, numpyQ_IteratorD_init, - numpyQ_IteratorD_$serialize, numpyQ_IteratorD_ndarray$_deserialize,numpyQ_IteratorB_bool, +struct numpyQ_IteratorD_ndarrayG_class numpyQ_IteratorD_ndarrayG_methods = {0,"",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, numpyQ_IteratorD_init, numpyQ_IteratorD_$serialize, numpyQ_IteratorD_ndarray$_deserialize,numpyQ_IteratorB_bool, numpyQ_IteratorB_str,numpyQ_IteratorB_str,numpyQ_IteratorD_ndarrayD___next__}; numpyQ_ndarray numpyQ_roll(numpyQ_Primitive pwit, numpyQ_ndarray a, B_int n) { diff --git a/stdlib/c_src/numpy/ndselect.c b/stdlib/c_src/numpy/ndselect.c index 206921ac3..fd3ee43e2 100644 --- a/stdlib/c_src/numpy/ndselect.c +++ b/stdlib/c_src/numpy/ndselect.c @@ -25,6 +25,7 @@ numpyQ_ndselect numpyQ_ndselectD___deserialize__(numpyQ_ndselect wit, $Serial$st } struct numpyQ_ndselectG_class numpyQ_ndselectG_methods = { + 0, "numpyQ_ndselect", UNASSIGNED, ($SuperG_class)&B_valueG_methods, @@ -63,6 +64,7 @@ numpyQ_ndindex numpyQ_ndindexD___deserialize__(numpyQ_ndindex self, $Serial$stat } struct numpyQ_ndindexG_class numpyQ_ndindexG_methods = { + 0, "numpyQ_ndindex", UNASSIGNED, ($SuperG_class)&B_valueG_methods, @@ -100,6 +102,7 @@ numpyQ_ndslice numpyQ_ndsliceD___deserialize__(numpyQ_ndslice self, $Serial$stat } struct numpyQ_ndsliceG_class numpyQ_ndsliceG_methods = { + 0, "numpyQ_ndslice", UNASSIGNED, ($SuperG_class)&B_valueG_methods, diff --git a/stdlib/c_src/numpy/primitive.c b/stdlib/c_src/numpy/primitive.c index cdb0f7299..f3659a49b 100644 --- a/stdlib/c_src/numpy/primitive.c +++ b/stdlib/c_src/numpy/primitive.c @@ -180,16 +180,14 @@ numpyQ_PrimitiveD_float numpyQ_PrimitiveD_floatD_deserialize(numpyQ_PrimitiveD_f } -struct numpyQ_PrimitiveD_intG_class numpyQ_PrimitiveD_intG_methods = {"numpyQ_PrimitiveD_int",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_int))$default__init__, - numpyQ_PrimitiveD_intD_serialize,numpyQ_PrimitiveD_intD_deserialize,NULL,NULL,NULL, +struct numpyQ_PrimitiveD_intG_class numpyQ_PrimitiveD_intG_methods = {0,"numpyQ_PrimitiveD_int",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_int))$default__init__, numpyQ_PrimitiveD_intD_serialize,numpyQ_PrimitiveD_intD_deserialize,NULL,NULL,NULL, LongType,to$objB_int,from$objB_int,B_l_prim_str, B_l_add,B_l_sub,B_l_mul,B_l_truediv,B_l_floordiv,B_l_mod,B_l_land,B_l_lor,B_l_band,B_l_bor,B_l_bxor,B_l_lsh,B_l_rsh,lB_pow, B_l_iadd,B_l_isub,B_l_imul,B_l_itruediv,B_l_ifloordiv,B_l_imod,B_l_iband,B_l_ibor,B_l_ibxor,B_l_ilsh,B_l_irsh, B_l_eq,B_l_neq,B_l_lt,B_l_le,B_l_gt,B_l_ge,lB_abs,B_l_neg,B_l_lnot,B_l_bnot}; -struct numpyQ_PrimitiveD_floatG_class numpyQ_PrimitiveD_floatG_methods = {"numpyQ_PrimitiveD_float",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_float))$default__init__, - numpyQ_PrimitiveD_floatD_serialize,numpyQ_PrimitiveD_floatD_deserialize,NULL,NULL,NULL, +struct numpyQ_PrimitiveD_floatG_class numpyQ_PrimitiveD_floatG_methods = {0,"numpyQ_PrimitiveD_float",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_float))$default__init__, numpyQ_PrimitiveD_floatD_serialize,numpyQ_PrimitiveD_floatD_deserialize,NULL,NULL,NULL, DblType,to$objB_float,from$objB_float,B_d_prim_str, B_d_add,B_d_sub,B_d_mul,B_d_truediv,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,dB_pow, B_d_iadd,B_d_isub,B_d_imul,B_d_itruediv,NULL,NULL,NULL,NULL,NULL,NULL,NULL, diff --git a/stdlib/c_src/numpy/protocol_impls.c b/stdlib/c_src/numpy/protocol_impls.c index 44e9a98af..bcc87ae8b 100644 --- a/stdlib/c_src/numpy/protocol_impls.c +++ b/stdlib/c_src/numpy/protocol_impls.c @@ -428,6 +428,7 @@ struct numpyQ_MinusD_ndarray numpyQ_MinusD_ndarray$instance; struct numpyQ_SliceableD_ndarray numpyQ_SliceableD_ndarray$instance; struct numpyQ_IntegralD_ndarrayD_intG_class numpyQ_IntegralD_ndarrayD_intG_methods = { + 0, "numpyQ_IntegralD_ndarrayD_int", UNASSIGNED, ($SuperG_class)&B_IntegralG_methods, @@ -477,6 +478,7 @@ struct numpyQ_IntegralD_ndarrayD_int numpyQ_IntegralD_ndarrayD_int$instance = {& numpyQ_IntegralD_ndarrayD_int numpyQ_IntegralD_ndarrayD_intG_witness = &numpyQ_IntegralD_ndarrayD_int$instance; struct numpyQ_LogicalD_ndarrayD_intG_class numpyQ_LogicalD_ndarrayD_intG_methods = { + 0, "numpyQ_LogicalD_ndarrayD_int", UNASSIGNED, ($SuperG_class)&B_LogicalG_methods, @@ -498,6 +500,7 @@ struct numpyQ_LogicalD_ndarrayD_int numpyQ_LogicalD_ndarrayD_int$instance = {&nu numpyQ_LogicalD_ndarrayD_int numpyQ_LogicalD_ndarrayD_intG_witness = &numpyQ_LogicalD_ndarrayD_int$instance; struct numpyQ_MinusD_ndarrayD_intG_class numpyQ_MinusD_ndarrayD_intG_methods = { + 0, "numpyQ_MinusD_ndarrayD_int", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -514,6 +517,7 @@ struct numpyQ_MinusD_ndarrayD_int numpyQ_MinusD_ndarrayD_int$instance = {&numpyQ numpyQ_MinusD_ndarrayD_int numpyQ_MinusD_ndarrayD_intG_witness = &numpyQ_MinusD_ndarrayD_int$instance; struct numpyQ_RealD_ndarrayG_class numpyQ_RealD_ndarrayG_methods = { + 0, "numpyQ_RealD_ndarray", UNASSIGNED, ($SuperG_class)&B_IntegralG_methods, @@ -545,6 +549,7 @@ struct numpyQ_RealD_ndarrayG_class numpyQ_RealD_ndarrayG_methods = { }; struct numpyQ_MinusD_ndarrayG_class numpyQ_MinusD_ndarrayG_methods = { + 0, "numpyQ_MinusD_ndarray", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -562,6 +567,7 @@ struct numpyQ_MinusD_ndarray numpyQ_MinusD_ndarray$instance = {&numpyQ_MinusD_nd numpyQ_MinusD_ndarray numpyQ_MinusD_ndarrayG_witness = &numpyQ_MinusD_ndarray$instance; struct numpyQ_DivD_ndarrayD_intG_class numpyQ_DivD_ndarrayD_intG_methods = { + 0, "numpyQ_DivD_ndarrayD_int", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -579,6 +585,7 @@ struct numpyQ_DivD_ndarrayD_int numpyQ_DivD_ndarrayD_int$instance = {&numpyQ_Div numpyQ_DivD_ndarrayD_int numpyQ_DivD_ndarrayD_intG_witness = &numpyQ_DivD_ndarrayD_int$instance; struct numpyQ_DivD_ndarrayD_floatG_class numpyQ_DivD_ndarrayD_floatG_methods = { + 0, "numpyQ_DivD_ndarrayD_float", UNASSIGNED, ($SuperG_class)&B_MinusG_methods, @@ -596,6 +603,7 @@ struct numpyQ_DivD_ndarrayD_float numpyQ_DivD_ndarrayD_float$instance = {&numpyQ numpyQ_DivD_ndarrayD_float numpyQ_DivD_ndarrayD_floatG_witness = &numpyQ_DivD_ndarrayD_float$instance; struct numpyQ_SliceableD_ndarrayG_class numpyQ_SliceableD_ndarrayG_methods = { + 0, "numpyQ_SliceableD_ndarray", UNASSIGNED, ($SuperG_class)&B_SliceableG_methods, @@ -617,6 +625,7 @@ numpyQ_SliceableD_ndarray numpyQ_SliceableD_ndarrayG_witness = &numpyQ_Sliceable struct numpyQ_CollectionD_ndarrayG_class numpyQ_CollectionD_ndarrayG_methods = { + 0, "numpyQ_CollectionD_ndarray", UNASSIGNED, ($SuperG_class)&B_CollectionG_methods, @@ -728,6 +737,7 @@ numpyQ_RealFunsD_mathD_ndarray numpyQ_RealFunsD_mathD_ndarrayG_new(numpyQ_Primit return $tmp; } struct numpyQ_RealFunsD_mathD_ndarrayG_class numpyQ_RealFunsD_mathD_ndarrayG_methods = { + 0, "numpyQ_RealFunsD_mathD_ndarray", UNASSIGNED, ($SuperG_class)&mathQ_RealFunsG_methods, diff --git a/stdlib/src/json.ext.c b/stdlib/src/json.ext.c index 08f6da217..c317741cb 100644 --- a/stdlib/src/json.ext.c +++ b/stdlib/src/json.ext.c @@ -17,7 +17,7 @@ void jsonQ_encode_dict(yyjson_mut_doc *doc, yyjson_mut_val *node, B_dict data) { char *key = (char *)fromB_str((B_str)item->components[0]); char *value = (char *)fromB_str((B_str)item->components[1]); B_value v = item->components[1]; - //log_info("key: %s class_id: %d type: %s", key, v->$class->$class_id, v->$class->$GCINFO); + //log_info("key: %s class_id: %d type: %s", key, v->$class->$class_id, v->$class->$name); switch (v->$class->$class_id) { case INT_ID:; yyjson_mut_obj_add_int(doc, node, key, from$int((B_int)v)); diff --git a/stdlib/src/math.c b/stdlib/src/math.c index 0778aacea..4136c9cf0 100644 --- a/stdlib/src/math.c +++ b/stdlib/src/math.c @@ -19,12 +19,13 @@ B_NoneType mathQ_RealFunsD___init__ (mathQ_RealFuns W_self) { return B_None; } mathQ_RealFuns mathQ_RealFunsG_new() { - mathQ_RealFuns $tmp = malloc(sizeof(struct mathQ_RealFuns)); + mathQ_RealFuns $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct mathQ_RealFuns), mathQ_RealFunsG_methods.$GCdescr); $tmp->$class = &mathQ_RealFunsG_methods; mathQ_RealFunsG_methods.__init__($tmp); return $tmp; } struct mathQ_RealFunsG_class mathQ_RealFunsG_methods; +GC_word mathQ_RealFunsD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFuns)]; B_NoneType mathQ_RealFunsD_floatD___init__ (mathQ_RealFunsD_float W_self) { mathQ_RealFunsG_methods.__init__((mathQ_RealFuns)W_self); return B_None; @@ -86,24 +87,29 @@ B_float mathQ_RealFunsD_float$atanh(mathQ_RealFunsD_float wit, B_float x) { mathQ_RealFunsD_float mathQ_RealFunsD_floatG_new() { - mathQ_RealFunsD_float $tmp = malloc(sizeof(struct mathQ_RealFunsD_float)); + mathQ_RealFunsD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct mathQ_RealFunsD_float), mathQ_RealFunsD_floatG_methods.$GCdescr); $tmp->$class = &mathQ_RealFunsD_floatG_methods; mathQ_RealFunsD_floatG_methods.__init__($tmp); return $tmp; } struct mathQ_RealFunsD_floatG_class mathQ_RealFunsD_floatG_methods; +GC_word mathQ_RealFunsD_floatD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFunsD_float)]; int mathQ_done$ = 0; void mathQ___init__ () { if (mathQ_done$) return; mathQ_done$ = 1; { - mathQ_RealFunsG_methods.$GCINFO = "mathQ_RealFuns"; + memset(mathQ_RealFunsD_gcbm, 0xFF, sizeof(mathQ_RealFunsD_gcbm)); + mathQ_RealFunsG_methods.$GCdescr = GC_make_descriptor(mathQ_RealFunsD_gcbm, GC_WORD_LEN(struct mathQ_RealFuns)); + mathQ_RealFunsG_methods.$name = "mathQ_RealFuns"; mathQ_RealFunsG_methods.$superclass = NULL; mathQ_RealFunsG_methods.__init__ = mathQ_RealFunsD___init__; $register(&mathQ_RealFunsG_methods); } { - mathQ_RealFunsD_floatG_methods.$GCINFO = "mathQ_RealFunsD_float"; + memset(mathQ_RealFunsD_floatD_gcbm, 0xFF, sizeof(mathQ_RealFunsD_floatD_gcbm)); + mathQ_RealFunsD_floatG_methods.$GCdescr = GC_make_descriptor(mathQ_RealFunsD_floatD_gcbm, GC_WORD_LEN(struct mathQ_RealFunsD_float)); + mathQ_RealFunsD_floatG_methods.$name = "mathQ_RealFunsD_float"; mathQ_RealFunsD_floatG_methods.$superclass = ($SuperG_class)&mathQ_RealFunsG_methods; mathQ_RealFunsD_floatG_methods.__serialize__ = mathQ_RealFunsD_floatD___serialize__, mathQ_RealFunsD_floatG_methods.__deserialize__ = mathQ_RealFunsD_floatD___deserialize__, diff --git a/stdlib/src/math.h b/stdlib/src/math.h index 3dd41be1a..03671958c 100644 --- a/stdlib/src/math.h +++ b/stdlib/src/math.h @@ -5,7 +5,8 @@ struct mathQ_RealFuns; typedef struct mathQ_RealFuns *mathQ_RealFuns; struct mathQ_RealFunsG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; B_int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (mathQ_RealFuns); @@ -33,12 +34,14 @@ struct mathQ_RealFunsG_class { struct mathQ_RealFuns { struct mathQ_RealFunsG_class *$class; }; +extern GC_word mathQ_RealFunsD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFuns)]; extern struct mathQ_RealFunsG_class mathQ_RealFunsG_methods; mathQ_RealFuns mathQ_RealFunsG_new(); struct mathQ_RealFunsD_float; typedef struct mathQ_RealFunsD_float *mathQ_RealFunsD_float; struct mathQ_RealFunsD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; B_int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (mathQ_RealFunsD_float); @@ -66,6 +69,7 @@ struct mathQ_RealFunsD_floatG_class { struct mathQ_RealFunsD_float { struct mathQ_RealFunsD_floatG_class *$class; }; +extern GC_word mathQ_RealFunsD_floatD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFunsD_float)]; extern struct mathQ_RealFunsD_floatG_class mathQ_RealFunsD_floatG_methods; mathQ_RealFunsD_float mathQ_RealFunsD_floatG_new(); $WORD mathQ_sqrt (mathQ_RealFuns, $WORD); diff --git a/stdlib/src/numpy.h b/stdlib/src/numpy.h index 0fdc7633c..f93a7b8ca 100644 --- a/stdlib/src/numpy.h +++ b/stdlib/src/numpy.h @@ -6,7 +6,8 @@ struct numpyQ_ndselect; typedef struct numpyQ_ndselect *numpyQ_ndselect; struct numpyQ_ndselectG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (numpyQ_ndselect); @@ -19,12 +20,14 @@ struct numpyQ_ndselectG_class { struct numpyQ_ndselect { struct numpyQ_ndselectG_class *$class; }; +extern GC_word numpyQ_ndselectD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndselect)]; extern struct numpyQ_ndselectG_class numpyQ_ndselectG_methods; numpyQ_ndselect numpyQ_ndselectG_new(); struct numpyQ_ndindex; typedef struct numpyQ_ndindex *numpyQ_ndindex; struct numpyQ_ndindexG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (numpyQ_ndindex, B_int); @@ -38,6 +41,7 @@ struct numpyQ_ndindex { struct numpyQ_ndindexG_class *$class; B_int index; }; +extern GC_word numpyQ_ndindexD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndindex)]; extern struct numpyQ_ndindexG_class numpyQ_ndindexG_methods; numpyQ_ndindex numpyQ_ndindexG_new(B_int); @@ -45,7 +49,8 @@ numpyQ_ndindex numpyQ_ndindexG_new(B_int); struct numpyQ_ndslice; typedef struct numpyQ_ndslice *numpyQ_ndslice; struct numpyQ_ndsliceG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (numpyQ_ndslice, B_slice); @@ -59,6 +64,7 @@ struct numpyQ_ndslice { struct numpyQ_ndsliceG_class *$class; B_slice slc; }; +extern GC_word numpyQ_ndsliceD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndslice)]; extern struct numpyQ_ndsliceG_class numpyQ_ndsliceG_methods; numpyQ_ndslice numpyQ_ndsliceG_new(B_slice); @@ -92,6 +98,7 @@ typedef struct numpyQ_PrimitiveD_floatG_class *numpyQ_PrimitiveD_floatG_class; struct numpyQ_Primitive { numpyQ_PrimitiveG_class $class; }; +extern GC_word numpyQ_PrimitiveD_gcbm[GC_BITMAP_SIZE(struct numpyQ_Primitive)]; union $Bytes8 { long l; @@ -103,7 +110,8 @@ enum ElemType {LongType,DblType}; int $elem_size(enum ElemType typ); struct numpyQ_PrimitiveG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_Primitive); @@ -161,9 +169,11 @@ B_str B_l_prim_str(union $Bytes8 n); struct numpyQ_PrimitiveD_int { numpyQ_PrimitiveD_intG_class $class; }; +extern GC_word numpyQ_PrimitiveD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_PrimitiveD_int)]; struct numpyQ_PrimitiveD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_PrimitiveD_int); @@ -218,9 +228,11 @@ struct numpyQ_PrimitiveD_intG_class { struct numpyQ_PrimitiveD_float { numpyQ_PrimitiveD_floatG_class $class; }; +extern GC_word numpyQ_PrimitiveD_floatD_gcbm[GC_BITMAP_SIZE(struct numpyQ_PrimitiveD_float)]; struct numpyQ_PrimitiveD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_PrimitiveD_float); @@ -287,7 +299,8 @@ struct numpyQ_ndarray; typedef struct numpyQ_ndarray *numpyQ_ndarray; struct numpyQ_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_ndarray,numpyQ_Primitive,B_atom); @@ -314,6 +327,7 @@ struct numpyQ_ndarray { B_list strides; union $Bytes8 *data; }; +extern GC_word numpyQ_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndarray)]; extern struct numpyQ_ndarrayG_class numpyQ_ndarrayG_methods; @@ -338,7 +352,8 @@ typedef struct numpyQ_array_iterator_state { typedef struct numpyQ_IteratorD_ndarray *numpyQ_IteratorD_ndarray; ; struct numpyQ_IteratorD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_IteratorD_ndarray, numpyQ_Primitive, numpyQ_ndarray); @@ -357,6 +372,7 @@ struct numpyQ_IteratorD_ndarray { numpyQ_Primitive pwit; numpyQ_array_iterator_state it; }; +extern GC_word numpyQ_IteratorD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_IteratorD_ndarray)]; extern struct numpyQ_IteratorD_ndarrayG_class numpyQ_IteratorD_ndarrayG_methods; @@ -466,9 +482,11 @@ struct numpyQ_IntegralD_ndarrayD_int { B_Logical W_Logical; B_Minus W_Minus; }; +extern GC_word numpyQ_IntegralD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_IntegralD_ndarrayD_int)]; struct numpyQ_IntegralD_ndarrayD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_IntegralD_ndarrayD_int); @@ -549,9 +567,11 @@ struct numpyQ_LogicalD_ndarrayD_int { numpyQ_LogicalD_ndarrayD_intG_class $class; B_Integral W_Integral; }; +extern GC_word numpyQ_LogicalD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_LogicalD_ndarrayD_int)]; struct numpyQ_LogicalD_ndarrayD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_LogicalD_ndarrayD_int, B_Integral); @@ -581,9 +601,11 @@ struct numpyQ_MinusD_ndarrayD_int { numpyQ_MinusD_ndarrayD_intG_class $class; B_Integral W_Integral; }; +extern GC_word numpyQ_MinusD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_MinusD_ndarrayD_int)]; struct numpyQ_MinusD_ndarrayD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_MinusD_ndarrayD_int, B_Integral); @@ -608,9 +630,11 @@ struct numpyQ_RealD_ndarray { B_Minus W_Minus; numpyQ_Primitive W_PrimitiveD_AD_RealD_ndarray; }; +extern GC_word numpyQ_RealD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_RealD_ndarray)]; struct numpyQ_RealD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_RealD_ndarray, numpyQ_Primitive); @@ -667,9 +691,11 @@ struct numpyQ_MinusD_ndarray { numpyQ_MinusD_ndarrayG_class $class; B_Real W_Real; }; +extern GC_word numpyQ_MinusD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_MinusD_ndarray)]; struct numpyQ_MinusD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_MinusD_ndarray, B_Real); @@ -693,9 +719,11 @@ struct numpyQ_DivD_ndarrayD_int { numpyQ_DivD_ndarrayD_intG_class $class; B_Real W_Real; }; +extern GC_word numpyQ_DivD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_DivD_ndarrayD_int)]; struct numpyQ_DivD_ndarrayD_intG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_DivD_ndarrayD_int); @@ -719,9 +747,11 @@ struct numpyQ_DivD_ndarrayD_float { numpyQ_DivD_ndarrayD_floatG_class $class; B_Real W_Real; }; +extern GC_word numpyQ_DivD_ndarrayD_floatD_gcbm[GC_BITMAP_SIZE(struct numpyQ_DivD_ndarrayD_float)]; struct numpyQ_DivD_ndarrayD_floatG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_DivD_ndarrayD_float); @@ -745,7 +775,8 @@ struct numpyQ_SliceableD_ndarray; typedef struct numpyQ_SliceableD_ndarray *numpyQ_SliceableD_ndarray; struct numpyQ_SliceableD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (numpyQ_SliceableD_ndarray, numpyQ_Primitive); @@ -765,6 +796,7 @@ struct numpyQ_SliceableD_ndarray { numpyQ_SliceableD_ndarrayG_class $class; numpyQ_Primitive pwit; }; +extern GC_word numpyQ_SliceableD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_SliceableD_ndarray)]; // numpyQ_CollectionD_ndarray //////////////////////////////////////////////////////////// @@ -773,9 +805,11 @@ struct numpyQ_CollectionD_ndarray { numpyQ_CollectionD_ndarrayG_class $class; numpyQ_Primitive pwit; }; +extern GC_word numpyQ_CollectionD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_CollectionD_ndarray)]; struct numpyQ_CollectionD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__)(numpyQ_CollectionD_ndarray, numpyQ_Primitive); @@ -806,7 +840,8 @@ numpyQ_RealD_ndarray numpyQ_RealFloat$ndarrayG_new(numpyQ_Primitive,B_RealFloat) struct numpyQ_RealFunsD_mathD_ndarray; typedef struct numpyQ_RealFunsD_mathD_ndarray *numpyQ_RealFunsD_mathD_ndarray; struct numpyQ_RealFunsD_mathD_ndarrayG_class { - char *$GCINFO; + GC_descr $GCdescr; + char *$name; int $class_id; $SuperG_class $superclass; B_NoneType (*__init__) (numpyQ_RealFunsD_mathD_ndarray, numpyQ_Primitive, mathQ_RealFuns); @@ -836,6 +871,7 @@ struct numpyQ_RealFunsD_mathD_ndarray { numpyQ_Primitive W_PrimitiveD_AD_RealFuns$math$ndarray; mathQ_RealFuns W_RealFuns$mathD_AD_RealFuns$math$ndarray; }; +extern GC_word numpyQ_RealFunsD_mathD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_RealFunsD_mathD_ndarray)]; extern struct numpyQ_RealFunsD_mathD_ndarrayG_class numpyQ_RealFunsD_mathD_ndarrayG_methods;