build: re-enable namespace-specific tests

.clang-format

@@ -44,15 +44,17 @@ ReflowComments: true
 SpacesBeforeTrailingComments: 3
 TabWidth: 8
 UseTab: AlignWithSpaces
-PenaltyReturnTypeOnItsOwnLine: 1000000
-PenaltyExcessCharacter: 5
-PenaltyBreakOpenParenthesis: 5
-PenaltyBreakBeforeFirstCallParameter: 5
+BreakAfterReturnType: Automatic
+PenaltyBreakAssignment: 1000000
+PenaltyReturnTypeOnItsOwnLine: 100000000
+PenaltyExcessCharacter: 10000000
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakBeforeFirstCallParameter: 0
 PenaltyIndentedWhitespace: 0
 AttributeMacros:
   - FX_API
 ForEachMacros:
   - fx_btree_foreach
   - fx_queue_foreach
-MacroBlockBegin: "FX_(TYPE|ASSEMBLY)_.*_BEGIN"
-MacroBlockEnd: "FX_(TYPE|ASSEMBLY)_.*_END"
+MacroBlockBegin: "FX_(TYPE|ASSEMBLY).*_BEGIN"
+MacroBlockEnd: "FX_(TYPE|ASSEMBLY).*_END"

assemblies/fx.cmdline/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
+FX_ASSEMBLY_BEGIN(fx_cmdline)
 	FX_ASSEMBLY_NAME("fx.cmdline");
 	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_END(fx_cmdline)

assemblies/fx.compression/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
+FX_ASSEMBLY_BEGIN(fx_compression)
 	FX_ASSEMBLY_NAME("fx.compression");
 	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_END(fx_compression)

assemblies/fx.io/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
-FX_ASSEMBLY_NAME("fx.io");
-FX_ASSEMBLY_VERSION(1, 0, 0, 0);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_BEGIN(fx_io)
+	FX_ASSEMBLY_NAME("fx.io");
+	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
+FX_ASSEMBLY_END(fx_io)

assemblies/fx.runtime/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
+FX_ASSEMBLY_BEGIN(fx_runtime)
 	FX_ASSEMBLY_NAME("fx.runtime");
 	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
 	FX_ASSEMBLY_EXPORT_TYPE("fx", "stream", fx_stream);
@@ -9,4 +9,4 @@ FX_ASSEMBLY_BEGIN()
 	FX_ASSEMBLY_EXPORT_TYPE("fx", "stringstream", fx_stringstream);
 	FX_ASSEMBLY_EXPORT_TYPE("fx", "iterator", fx_iterator);
 	FX_ASSEMBLY_EXPORT_TYPE("fx.reflection", "assembly", fx_assembly);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_END(fx_runtime)

assemblies/fx.serial/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
+FX_ASSEMBLY_BEGIN(fx_serial)
 	FX_ASSEMBLY_NAME("fx.serial");
 	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_END(fx_serial)

assemblies/fx.term/assembly.c

@@ -1,7 +1,7 @@
 #include <fx/macros.h>
 #include <fx/reflection/assembly.h>
 
-FX_ASSEMBLY_BEGIN()
+FX_ASSEMBLY_BEGIN(fx_term)
 	FX_ASSEMBLY_NAME("fx.term");
 	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
-FX_ASSEMBLY_END()
+FX_ASSEMBLY_END(fx_term)

cmake/Templates.cmake

@@ -45,6 +45,17 @@ function(add_fx_assembly)
 		target_compile_definitions(${assembly_target_name} PRIVATE ${def})
 	endforeach (def)
 
+	foreach (ns ${arg_NAMESPACES})
+		file(GLOB test_sources ${fx_source_root}/${ns}/test/*.c)
+		foreach (test_file ${test_sources})
+			get_filename_component(test_name ${test_file} NAME_WE)
+			set(test_name ${ns}-${test_name})
+			string(REPLACE "." "-" test_name ${test_name})
+			add_executable(${test_name} ${test_file})
+			target_link_libraries(${test_name} ${assembly_target_name})
+		endforeach (test_file)
+	endforeach (ns)
+
 	set_target_properties(${assembly_target_name} PROPERTIES
 		FOLDER "${assembly_name}")
 

fx.collections/array.c

@@ -486,16 +486,16 @@ static enum fx_status iterator_is_valid(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_array DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_array)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_array)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = array_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = iterable_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = iterable_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_array)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_array)
 
 FX_TYPE_DEFINITION_BEGIN(fx_array)
 	FX_TYPE_ID(0xe3c46da1, 0x5f37, 0x4e44, 0xb53b, 0xff5a6200191b);
@@ -507,18 +507,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_array)
 FX_TYPE_DEFINITION_END(fx_array)
 
 // ---- fx_array_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_array_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_array_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_array_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_array_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_array_iterator)
 	FX_TYPE_ID(0xe5e9e8b8, 0x14cb, 0x4192, 0x8138, 0xf45238a2ae73);

fx.collections/bitbuffer.c

@@ -23,11 +23,11 @@ static void bitbuffer_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bitbuffer)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_bitbuffer)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_bitbuffer)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_bitbuffer)
 
 FX_TYPE_DEFINITION_BEGIN(fx_bitbuffer)
 	FX_TYPE_ID(0x628e33da, 0x3109, 0x4a5d, 0x98d5, 0xb0e4cb3ccb65);

fx.collections/bitmap.c

@@ -343,11 +343,11 @@ static void bitmap_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bitmap)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_bitmap)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = bitmap_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_bitmap)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_bitmap)
 
 FX_TYPE_DEFINITION_BEGIN(fx_bitmap)
 	FX_TYPE_ID(0xea115cef, 0x8a63, 0x445f, 0x9474, 0xba9309d5dde8);

fx.collections/buffer.c

@@ -465,11 +465,11 @@ void buffer_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_buffer)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_buffer)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_buffer)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_buffer)
 
 FX_TYPE_DEFINITION_BEGIN(fx_buffer)
 	FX_TYPE_ID(0x323e6858, 0x7a43, 0x4484, 0xa6fb, 0xe3d1e47ae637);

fx.collections/datetime.c

@@ -611,11 +611,11 @@ static void _datetime_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_datetime)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_datetime)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = _datetime_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_datetime)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_datetime)
 
 FX_TYPE_DEFINITION_BEGIN(fx_datetime)
 	FX_TYPE_ID(0x06a6030b, 0x1e3c, 0x4be2, 0xbd23, 0xf34f4a8e68be);

fx.collections/dict.c

@@ -690,16 +690,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_dict DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_dict)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_dict)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = dict_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = iterable_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = iterable_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_dict)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_dict)
 
 FX_TYPE_DEFINITION_BEGIN(fx_dict)
 	FX_TYPE_ID(0xd2af61d9, 0xd0be, 0x4960, 0xbe3f, 0x509749814c10);
@@ -711,18 +711,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_dict)
 FX_TYPE_DEFINITION_END(fx_dict)
 
 // ---- fx_dict_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_dict_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_dict_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_dict_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_dict_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_dict_iterator)
 	FX_TYPE_ID(0x9ea96701, 0x1713, 0x4a3e, 0xbf63, 0xdc856b456f3b);

fx.collections/hashmap.c

@@ -607,16 +607,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_hashmap DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_hashmap)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_hashmap)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = fx_hashmap_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = fx_hashmap_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_hashmap)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_hashmap)
 
 FX_TYPE_DEFINITION_BEGIN(fx_hashmap)
 	FX_TYPE_ID(0x7bf5bcd1, 0x1ff3, 0x4e43, 0xbed8, 0x7c74f28348bf);
@@ -628,18 +628,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_hashmap)
 FX_TYPE_DEFINITION_END(fx_hashmap)
 
 // ---- fx_hashmap_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_hashmap_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_hashmap_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_hashmap_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_hashmap_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_hashmap_iterator)
 	FX_TYPE_ID(0xd9658456, 0xdd80, 0x419a, 0xb23a, 0xb513013e6431);

fx.collections/include/fx/collections/array.h

@@ -30,8 +30,8 @@ FX_TYPE_CLASS_DECLARATION_END(fx_array)
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_array_iterator)
 FX_TYPE_CLASS_DECLARATION_END(fx_array_iterator)
 
-FX_API fx_type fx_array_get_type(void);
-FX_API fx_type fx_array_iterator_get_type(void);
+FX_API fx_type_id fx_array_get_type(void);
+FX_API fx_type_id fx_array_iterator_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_array, FX_TYPE_ARRAY);
 

fx.collections/include/fx/collections/bitmap.h

@@ -14,7 +14,7 @@ FX_DECLARE_TYPE(fx_bitmap);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bitmap)
 FX_TYPE_CLASS_DECLARATION_END(fx_bitmap)
 
-FX_API fx_type fx_bitmap_get_type(void);
+FX_API fx_type_id fx_bitmap_get_type(void);
 
 FX_API fx_bitmap *fx_bitmap_create(size_t nr_bits);
 

fx.collections/include/fx/collections/buffer.h

@@ -13,7 +13,7 @@ FX_DECLARE_TYPE(fx_buffer);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_buffer)
 FX_TYPE_CLASS_DECLARATION_END(fx_buffer)
 
-FX_API fx_type fx_buffer_get_type(void);
+FX_API fx_type_id fx_buffer_get_type(void);
 
 FX_API fx_buffer *fx_buffer_create(size_t item_sz);
 FX_API fx_buffer *fx_buffer_create_from_bytes(const void *p, size_t len);

fx.collections/include/fx/collections/datetime.h

@@ -18,7 +18,7 @@ typedef enum fx_datetime_format {
 	FX_DATETIME_FORMAT_RFC3339 = 1,
 } fx_datetime_format;
 
-FX_API fx_type fx_datetime_get_type(void);
+FX_API fx_type_id fx_datetime_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_datetime, FX_TYPE_DATETIME);
 

fx.collections/include/fx/collections/dict.h

@@ -37,8 +37,8 @@ typedef struct fx_dict_item {
 	fx_object *value;
 } fx_dict_item;
 
-FX_API fx_type fx_dict_get_type(void);
-FX_API fx_type fx_dict_iterator_get_type(void);
+FX_API fx_type_id fx_dict_get_type(void);
+FX_API fx_type_id fx_dict_iterator_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_dict, FX_TYPE_DICT);
 

fx.collections/include/fx/collections/hashmap.h

@@ -2,6 +2,7 @@
 #define FX_DS_HASHMAP_H_
 
 #include <fx/bst.h>
+#include <fx/iterator.h>
 #include <fx/macros.h>
 #include <fx/misc.h>
 #include <fx/queue.h>
@@ -60,8 +61,8 @@ typedef struct fx_hashmap_item {
 	fx_hashmap_value value;
 } fx_hashmap_item;
 
-FX_API fx_type fx_hashmap_get_type(void);
-FX_API fx_type fx_hashmap_iterator_get_type(void);
+FX_API fx_type_id fx_hashmap_get_type(void);
+FX_API fx_type_id fx_hashmap_iterator_get_type(void);
 
 FX_API fx_hashmap *fx_hashmap_create(
 	fx_hashmap_key_destructor key_dtor,

fx.collections/include/fx/collections/list.h

@@ -23,8 +23,8 @@ FX_TYPE_CLASS_DECLARATION_END(fx_list_iterator)
 
 typedef struct fx_list_entry fx_list_entry;
 
-FX_API fx_type fx_list_get_type(void);
-FX_API fx_type fx_list_iterator_get_type(void);
+FX_API fx_type_id fx_list_get_type(void);
+FX_API fx_type_id fx_list_iterator_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_list, FX_TYPE_LIST);
 

fx.collections/include/fx/collections/tree.h

@@ -30,8 +30,8 @@ typedef struct fx_tree_node {
 	struct fx_queue_entry __q01;
 } fx_tree_node;
 
-FX_API fx_type fx_tree_get_type(void);
-FX_API fx_type fx_tree_iterator_get_type(void);
+FX_API fx_type_id fx_tree_get_type(void);
+FX_API fx_type_id fx_tree_iterator_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_tree, FX_TYPE_TREE);
 

fx.collections/list.c

@@ -507,16 +507,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_list DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_list)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_list)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = fx_list_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = fx_list_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_list)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_list)
 
 FX_TYPE_DEFINITION_BEGIN(fx_list)
 	FX_TYPE_ID(0x8730e66f, 0x0fd9, 0x4773, 0x9bbd, 0x6428f6e495eb);
@@ -528,18 +528,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_list)
 FX_TYPE_DEFINITION_END(fx_list)
 
 // ---- fx_list_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_list_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_list_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_list_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_list_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_list_iterator)
 	FX_TYPE_ID(0xd9658456, 0xdd80, 0x419a, 0xb23a, 0xb513013e6431);

fx.collections/test/arrays.c

@@ -1,13 +1,13 @@
-#include <fx/ds/array.h>
-#include <fx/ds/number.h>
+#include <fx/collections/array.h>
+#include <fx/int.h>
 #include <stdio.h>
 
 int main(void)
 {
 	fx_array *array = fx_array_create();
-	fx_array_append(array, FX_RV_INT(32));
-	fx_array_append(array, FX_RV_INT(64));
-	fx_array_append(array, FX_RV_INT(128));
+	fx_array_append(array, fx_int_create(32));
+	fx_array_append(array, fx_int_create(64));
+	fx_array_append(array, fx_int_create(128));
 
 	fx_iterator *it = fx_iterator_begin(array);
 	fx_foreach_ptr(fx_object, obj, it)

fx.collections/test/numbers.c

@@ -1,11 +1,12 @@
-#include <fx/ds/number.h>
+#include <fx/double.h>
 #include <stdio.h>
 
 int main(void)
 {
-	fx_number *number = fx_number_create_float(6.8);
+	fx_double *d = fx_double_create(6.8);
+
+	printf("double=%lf\n", fx_double_get_value(d));
+	fx_double_unref(d);
 
-	printf("number=%zd\n", FX_NUMBER_IVAL(number));
-	fx_number_unref(number);
 	return 0;
 }

fx.collections/test/simple.c

@@ -1,4 +1,4 @@
-#include <fx/ds/string.h>
+#include <fx/string.h>
 
 int main(void)
 {

fx.collections/test/streams.c

@@ -1,6 +1,6 @@
-#include <fx/core/stream.h>
-#include <fx/core/stringstream.h>
-#include <fx/ds/string.h>
+#include <fx/stream.h>
+#include <fx/string.h>
+#include <fx/stringstream.h>
 #include <stdio.h>
 
 int main(int argc, const char **argv)

fx.collections/test/trees.c

@@ -1,8 +1,9 @@
-#include <fx/core/bst.h>
-#include <fx/core/iterator.h>
-#include <fx/ds/dict.h>
-#include <fx/ds/number.h>
-#include <fx/ds/tree.h>
+#include <fx/bst.h>
+#include <fx/collections/dict.h>
+#include <fx/collections/tree.h>
+#include <fx/int.h>
+#include <fx/iterator.h>
+#include <inttypes.h>
 #include <stdio.h>
 
 #define NITEMS 16
@@ -23,18 +24,20 @@ FX_BST_DEFINE_SIMPLE_INSERT(struct bst_item, node, value, put_node)
 int main(void)
 {
 	fx_dict *dict = fx_dict_create();
-	fx_dict_put(dict, "hello", FX_RV_INT(32));
-	fx_dict_put(dict, "world", FX_RV_INT(64));
-	fx_dict_put(dict, "more", FX_RV_INT(128));
-	fx_dict_put(dict, "other", FX_RV_INT(256));
+	fx_dict_put(dict, "hello", fx_int_create(32));
+	fx_dict_put(dict, "world", fx_int_create(64));
+	fx_dict_put(dict, "more", fx_int_create(128));
+	fx_dict_put(dict, "other", fx_int_create(256));
 
 	fx_iterator *it = fx_iterator_begin(dict);
 
 	size_t i = 0;
 	fx_foreach(fx_dict_item *, item, it)
 	{
-		printf("item %zu: %s=%d\n", i++, fx_string_get_cstr(item->key),
-		       fx_number_get_int(item->value));
+		printf("item %zu: %s=%" PRIdPTR "\n",
+		       i++,
+		       fx_string_get_cstr(item->key),
+		       fx_int_get_value(item->value));
 	}
 
 	fx_iterator_unref(it);

fx.collections/test/unit-tests.c

@@ -1,50 +0,0 @@
-#include <CuTest.h>
-#include <fx/ds/string.h>
-
-static void test_string_create(CuTest *tc)
-{
-	fx_string *str = fx_string_create();
-
-	CuAssertPtrNotNull(tc, str);
-	CuAssertIntEquals(tc, 0, fx_string_get_size(str, FX_STRLEN_NORMAL));
-	CuAssertStrEquals(tc, "", fx_string_get_cstr(str));
-
-	fx_string_unref(str);
-
-	str = fx_string_create_from_c('A', 8);
-
-	CuAssertPtrNotNull(tc, str);
-	CuAssertIntEquals(tc, 8, fx_string_get_size(str, FX_STRLEN_NORMAL));
-	CuAssertStrEquals(tc, "AAAAAAAA", fx_string_get_cstr(str));
-
-	fx_string_unref(str);
-
-	str = fx_string_create_from_cstr("Hello, world!");
-
-	CuAssertPtrNotNull(tc, str);
-	CuAssertIntEquals(tc, 13, fx_string_get_size(str, FX_STRLEN_NORMAL));
-	CuAssertStrEquals(tc, "Hello, world!", fx_string_get_cstr(str));
-
-	fx_string_unref(str);
-}
-
-static void test_string_length(CuTest *tc)
-{
-	const char *cstr = "Hello, \033[91;1mworld!";
-	fx_string *s = fx_string_create_from_cstr(cstr);
-
-	CuAssertIntEquals(tc, 13, fx_string_get_size(s, FX_STRLEN_IGNORE_ESC));
-	CuAssertIntEquals(tc, 20, fx_string_get_size(s, FX_STRLEN_NORMAL));
-
-	fx_string_unref(s);
-}
-
-CuSuite *get_all_tests(void)
-{
-	CuSuite *suite = CuSuiteNew();
-
-	SUITE_ADD_TEST(suite, test_string_create);
-	SUITE_ADD_TEST(suite, test_string_length);
-
-	return suite;
-}

fx.collections/tree.c

@@ -348,16 +348,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_tree DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_tree)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_tree)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = fx_tree_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = fx_tree_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_tree)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_tree)
 
 FX_TYPE_DEFINITION_BEGIN(fx_tree)
 	FX_TYPE_ID(0x8d8fa36b, 0xc515, 0x4803, 0x8124, 0xfd704f01b8ae);
@@ -369,18 +369,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_tree)
 FX_TYPE_DEFINITION_END(fx_tree)
 
 // ---- fx_tree_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_tree_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_tree_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_tree_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_tree_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_tree_iterator)
 	FX_TYPE_ID(0xb896e671, 0x84b2, 0x4892, 0xaf09, 0x407f305f4bf8);

fx.compression/compressor.c

@@ -162,7 +162,7 @@ static bool compressor_eof(const struct compressor_data *p)
 /*** PUBLIC FUNCTIONS *********************************************************/
 
 enum fx_status fx_compressor_get_buffer_size(
-	fx_type type,
+	fx_type_id type,
 	fx_compressor_mode mode,
 	size_t *inbuf_size,
 	size_t *outbuf_size)
@@ -248,11 +248,11 @@ static void compressor_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_compressor)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_compressor)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_compressor)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_compressor)
 
 FX_TYPE_DEFINITION_BEGIN(fx_compressor)
 	FX_TYPE_ID(0x452ee0f9, 0xfe12, 0x48a1, 0xb596, 0xad5b7a3940e7);

fx.compression/cstream.c

@@ -782,7 +782,7 @@ static enum fx_status cstream_restore_cursor_position(
 
 enum fx_status fx_cstream_open(
 	fx_stream *endpoint,
-	fx_type compressor_type,
+	fx_type_id compressor_type,
 	fx_compressor_mode mode,
 	fx_cstream **out)
 {
@@ -989,12 +989,12 @@ static void cstream_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_cstream)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_cstream)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
 		FX_INTERFACE_ENTRY(s_close) = NULL;
 		FX_INTERFACE_ENTRY(s_seek) = NULL;
 		FX_INTERFACE_ENTRY(s_tell) = NULL;
@@ -1002,8 +1002,8 @@ FX_TYPE_CLASS_DEFINITION_BEGIN(fx_cstream)
 		FX_INTERFACE_ENTRY(s_read) = fx_cstream_read;
 		FX_INTERFACE_ENTRY(s_write) = fx_cstream_write;
 		FX_INTERFACE_ENTRY(s_reserve) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
-FX_TYPE_CLASS_DEFINITION_END(fx_cstream)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
+FX_TYPE_CLASS_END(fx_cstream)
 
 FX_TYPE_DEFINITION_BEGIN(fx_cstream)
 	FX_TYPE_ID(0xe1e899b5, 0x6a3c, 0x4f9c, 0xafd0, 0xaab3f156615c);

fx.compression/function/zstd.c

@@ -361,12 +361,12 @@ static enum fx_status set_mode(
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_zstd_compressor)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_zstd_compressor)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_compressor, FX_TYPE_COMPRESSOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_compressor, FX_TYPE_COMPRESSOR)
 		FX_INTERFACE_ENTRY(c_buffer_size)
 			= fx_zstd_compressor_get_buffer_size;
 		FX_INTERFACE_ENTRY(c_compress) = compress;
@@ -374,8 +374,8 @@ FX_TYPE_CLASS_DEFINITION_BEGIN(fx_zstd_compressor)
 		FX_INTERFACE_ENTRY(c_decompress) = decompress;
 		FX_INTERFACE_ENTRY(c_reset) = reset;
 		FX_INTERFACE_ENTRY(c_set_mode) = set_mode;
-	FX_TYPE_CLASS_INTERFACE_END(fx_compressor, FX_TYPE_COMPRESSOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_zstd_compressor)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_compressor, FX_TYPE_COMPRESSOR)
+FX_TYPE_CLASS_END(fx_zstd_compressor)
 
 FX_TYPE_DEFINITION_BEGIN(fx_zstd_compressor)
 	FX_TYPE_ID(0x51d437fc, 0xe789, 0x4105, 0xbac7, 0xe6b3f45df198);

fx.compression/include/fx/compression/compressor.h

@@ -38,7 +38,7 @@ typedef struct fx_compressor_data {
 	fx_ringbuffer *c_in, *c_out;
 } fx_compressor_data;
 
-FX_API fx_type fx_compressor_get_type(void);
+FX_API fx_type_id fx_compressor_get_type(void);
 
 #if 0
 FX_API fx_status fx_compressor_create(
@@ -48,7 +48,7 @@ FX_API fx_status fx_compressor_create(
 #endif
 
 FX_API fx_status fx_compressor_get_buffer_size(
-	fx_type type,
+	fx_type_id type,
 	fx_compressor_mode mode,
 	size_t *inbuf_size,
 	size_t *outbuf_size);

fx.compression/include/fx/compression/cstream.h

@@ -16,11 +16,11 @@ FX_DECLARE_TYPE(fx_cstream);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_cstream)
 FX_TYPE_CLASS_DECLARATION_END(fx_cstream)
 
-FX_API fx_type fx_cstream_get_type(void);
+FX_API fx_type_id fx_cstream_get_type(void);
 
 FX_API fx_status fx_cstream_open(
 	fx_stream *endpoint,
-	fx_type compressor_type,
+	fx_type_id compressor_type,
 	enum fx_compressor_mode mode,
 	fx_cstream **out);
 

fx.compression/include/fx/compression/zstd.h

@@ -16,7 +16,7 @@ FX_DECLARE_TYPE(fx_zstd_compressor);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_zstd_compressor)
 FX_TYPE_CLASS_DECLARATION_END(fx_compressor)
 
-FX_API fx_type fx_zstd_compressor_get_type(void);
+FX_API fx_type_id fx_zstd_compressor_get_type(void);
 
 FX_API fx_status fx_zstd_compressor_get_buffer_size(
 	fx_compressor_mode mode,

fx.compression/test/mix-compress.c

@@ -1,9 +1,9 @@
 #include <assert.h>
-#include <fx/compress/compressor.h>
-#include <fx/compress/cstream.h>
-#include <fx/compress/zstd.h>
-#include <fx/core/ringbuffer.h>
-#include <fx/core/stream.h>
+#include <fx/compression/compressor.h>
+#include <fx/compression/cstream.h>
+#include <fx/compression/zstd.h>
+#include <fx/ringbuffer.h>
+#include <fx/stream.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -48,9 +48,13 @@ int main(int argc, const char **argv)
 
 		size_t nr_written = 0;
 		fx_status status = fx_cstream_write(
-			cstream, source, source_len, &nr_written);
+			cstream,
+			source,
+			source_len,
+			&nr_written);
 		if (!FX_OK(status)) {
-			fprintf(stderr, "write error: %s\n",
+			fprintf(stderr,
+			        "write error: %s\n",
 			        fx_status_description(status));
 			break;
 		}
@@ -59,14 +63,19 @@ int main(int argc, const char **argv)
 
 		if (compressed) {
 			fx_cstream_end_compressed_section(
-				cstream, &nr_written_compressed, &nr_written);
+				cstream,
+				&nr_written_compressed,
+				&nr_written);
 		}
 
 		size_t tx_total = 0;
 		fx_cstream_tx_bytes(cstream, &tx_total);
 		printf("iteration %d: wrote %zu (compressed) / %zu "
 		       "(uncompressed) / %zu (total) bytes (%s)\n",
-		       i, nr_written_compressed, nr_written, tx_total,
+		       i,
+		       nr_written_compressed,
+		       nr_written,
+		       tx_total,
 		       compressed ? "compressed" : "uncompressed");
 
 		compressed = !compressed;

fx.compression/test/mix-decompress.c

@@ -1,9 +1,9 @@
 #include <assert.h>
-#include <fx/compress/compressor.h>
-#include <fx/compress/cstream.h>
-#include <fx/compress/zstd.h>
-#include <fx/core/ringbuffer.h>
-#include <fx/core/stream.h>
+#include <fx/compression/compressor.h>
+#include <fx/compression/cstream.h>
+#include <fx/compression/zstd.h>
+#include <fx/ringbuffer.h>
+#include <fx/stream.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -37,10 +37,14 @@ int main(int argc, const char **argv)
 		memset(buf, 0x0, sizeof buf);
 
 		size_t nr_read = 0;
-		fx_status status
-			= fx_cstream_read(cstream, buf, sizeof buf - 1, &nr_read);
+		fx_status status = fx_cstream_read(
+			cstream,
+			buf,
+			sizeof buf - 1,
+			&nr_read);
 		if (!FX_OK(status)) {
-			fprintf(stderr, "write error: %s\n",
+			fprintf(stderr,
+			        "write error: %s\n",
 			        fx_status_description(status));
 			break;
 		}
@@ -52,14 +56,19 @@ int main(int argc, const char **argv)
 		size_t nr_read_compressed = 0;
 		if (compressed) {
 			fx_cstream_end_compressed_section(
-				cstream, &nr_read_compressed, &nr_read);
+				cstream,
+				&nr_read_compressed,
+				&nr_read);
 		}
 
 		size_t tx_total = 0;
 		fx_cstream_tx_bytes(cstream, &tx_total);
 		printf(" * iteration %d: read %zu (compressed) / %zu "
 		       "(uncompressed) / %zu (total) bytes (%s)\n",
-		       i, nr_read_compressed, nr_read, tx_total,
+		       i,
+		       nr_read_compressed,
+		       nr_read,
+		       tx_total,
 		       compressed ? "compressed" : "uncompressed");
 		printf("%s\n", buf);
 

fx.compression/test/simple1.c

@@ -1,7 +1,7 @@
 #include <assert.h>
-#include <fx/compress/compressor.h>
-#include <fx/compress/zstd.h>
-#include <fx/core/ringbuffer.h>
+#include <fx/compression/compressor.h>
+#include <fx/compression/zstd.h>
+#include <fx/ringbuffer.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -12,8 +12,10 @@ int refill_input_buffer(FILE *fp, fx_ringbuffer *dest)
 	while (1) {
 		void *buf;
 		size_t capacity;
-		fx_status status
-			= fx_ringbuffer_open_write_buffer(dest, &buf, &capacity);
+		fx_status status = fx_ringbuffer_open_write_buffer(
+			dest,
+			&buf,
+			&capacity);
 		if (status == FX_ERR_NO_SPACE) {
 			break;
 		}
@@ -43,8 +45,10 @@ int flush_output_buffer(FILE *fp, fx_ringbuffer *src)
 	while (1) {
 		const void *buf;
 		size_t capacity;
-		fx_status status
-			= fx_ringbuffer_open_read_buffer(src, &buf, &capacity);
+		fx_status status = fx_ringbuffer_open_read_buffer(
+			src,
+			&buf,
+			&capacity);
 		if (status == FX_ERR_NO_DATA) {
 			break;
 		}
@@ -68,7 +72,9 @@ int flush_output_buffer(FILE *fp, fx_ringbuffer *src)
 int main(int argc, const char **argv)
 {
 	if (argc < 4) {
-		fprintf(stderr, "usage: %s <C/D> <inpath> <outpath>\n", argv[0]);
+		fprintf(stderr,
+		        "usage: %s <C/D> <inpath> <outpath>\n",
+		        argv[0]);
 		return -1;
 	}
 
@@ -96,12 +102,15 @@ int main(int argc, const char **argv)
 	}
 
 	fx_status status = FX_SUCCESS;
-	fx_type compressor_type = FX_TYPE_ZSTD_COMPRESSOR;
+	fx_type_id compressor_type = FX_TYPE_ZSTD_COMPRESSOR;
 	fx_compressor *compressor = fx_object_create(compressor_type);
 
 	size_t inbuf_size, outbuf_size;
 	fx_compressor_get_buffer_size(
-		compressor_type, mode, &inbuf_size, &outbuf_size);
+		compressor_type,
+		mode,
+		&inbuf_size,
+		&outbuf_size);
 
 	fx_ringbuffer *in = fx_ringbuffer_create(inbuf_size);
 	fx_ringbuffer *out = fx_ringbuffer_create(outbuf_size);

fx.compression/test/stream.c

@@ -1,21 +1,24 @@
 #include <assert.h>
-#include <fx/compress/compressor.h>
-#include <fx/compress/cstream.h>
-#include <fx/compress/zstd.h>
-#include <fx/core/ringbuffer.h>
-#include <fx/core/stream.h>
+#include <fx/compression/compressor.h>
+#include <fx/compression/cstream.h>
+#include <fx/compression/zstd.h>
+#include <fx/ringbuffer.h>
+#include <fx/stream.h>
 #include <stdio.h>
 #include <string.h>
 
 #define BUF_SIZE 32
 
-static int compress(fx_type compressor_type, FILE *in, FILE *out)
+static int compress(fx_type_id compressor_type, FILE *in, FILE *out)
 {
 	fx_stream *out_stream = fx_stream_open_fp(out);
 
 	fx_cstream *cstream;
 	fx_status status = fx_cstream_open(
-		out_stream, compressor_type, FX_COMPRESSOR_MODE_COMPRESS, &cstream);
+		out_stream,
+		compressor_type,
+		FX_COMPRESSOR_MODE_COMPRESS,
+		&cstream);
 
 	if (!FX_OK(status)) {
 		fprintf(stderr, "cannot initialise compressor\n");
@@ -48,13 +51,16 @@ static int compress(fx_type compressor_type, FILE *in, FILE *out)
 	return 0;
 }
 
-static int decompress(fx_type compressor_type, FILE *in, FILE *out)
+static int decompress(fx_type_id compressor_type, FILE *in, FILE *out)
 {
 	fx_stream *in_stream = fx_stream_open_fp(in);
 
 	fx_cstream *cstream;
 	fx_status status = fx_cstream_open(
-		in_stream, compressor_type, FX_COMPRESSOR_MODE_DECOMPRESS, &cstream);
+		in_stream,
+		compressor_type,
+		FX_COMPRESSOR_MODE_DECOMPRESS,
+		&cstream);
 
 	if (!FX_OK(status)) {
 		fprintf(stderr, "cannot initialise compressor\n");
@@ -66,9 +72,14 @@ static int decompress(fx_type compressor_type, FILE *in, FILE *out)
 	char buf[4096];
 	while (1) {
 		size_t r = 0;
-		fx_status status = fx_cstream_read(cstream, buf, sizeof buf, &r);
+		fx_status status = fx_cstream_read(
+			cstream,
+			buf,
+			sizeof buf,
+			&r);
 		if (!FX_OK(status)) {
-			fprintf(stderr, "read error: %s\n",
+			fprintf(stderr,
+			        "read error: %s\n",
 			        fx_status_description(status));
 			return -1;
 		}
@@ -94,7 +105,9 @@ static int decompress(fx_type compressor_type, FILE *in, FILE *out)
 int main(int argc, const char **argv)
 {
 	if (argc < 4) {
-		fprintf(stderr, "usage: %s <C/D> <inpath> <outpath>\n", argv[0]);
+		fprintf(stderr,
+		        "usage: %s <C/D> <inpath> <outpath>\n",
+		        argv[0]);
 		return -1;
 	}
 

fx.io/include/fx/io/directory.h

@@ -45,8 +45,8 @@ typedef struct fx_directory_entry {
 	fx_file_info info;
 } fx_directory_entry;
 
-FX_API fx_type fx_directory_get_type(void);
-FX_API fx_type fx_directory_iterator_get_type(void);
+FX_API fx_type_id fx_directory_get_type(void);
+FX_API fx_type_id fx_directory_iterator_get_type(void);
 
 FX_API fx_result fx_directory_open(
 	fx_directory *root,

fx.io/include/fx/io/file.h

@@ -51,7 +51,7 @@ typedef struct fx_file_info {
 	size_t length;
 } fx_file_info;
 
-FX_API fx_type fx_file_get_type(void);
+FX_API fx_type_id fx_file_get_type(void);
 
 FX_API fx_result fx_file_open(
 	FX_TYPE_FWDREF(fx_directory) * root,

fx.io/include/fx/io/path.h

@@ -20,7 +20,7 @@ FX_TYPE_CLASS_DECLARATION_END(fx_path)
 
 struct fx_file_info;
 
-FX_API fx_type fx_path_get_type(void);
+FX_API fx_type_id fx_path_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_path, FX_TYPE_PATH);
 

fx.io/sys/darwin/directory.c

@@ -709,16 +709,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_directory DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_directory)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_directory)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = iterator_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = iterator_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_directory)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_directory)
 
 FX_TYPE_DEFINITION_BEGIN(fx_directory)
 	FX_TYPE_ID(0x10d36546, 0x7f96, 0x464b, 0xbc4d, 0xe504b283fa45);
@@ -730,18 +730,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_directory)
 FX_TYPE_DEFINITION_END(fx_directory)
 
 // ---- fx_directory_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_directory_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_directory_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_directory_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_directory_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_directory_iterator)
 	FX_TYPE_ID(0xc707fce6, 0xc895, 0x4925, 0x8700, 0xa60641dee0cc);

fx.io/sys/darwin/file.c

@@ -618,20 +618,20 @@ static void file_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_file)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_file)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
 		FX_INTERFACE_ENTRY(s_close) = stream_close;
 		FX_INTERFACE_ENTRY(s_getc) = stream_getc;
 		FX_INTERFACE_ENTRY(s_read) = stream_read;
 		FX_INTERFACE_ENTRY(s_write) = stream_write;
 		FX_INTERFACE_ENTRY(s_seek) = stream_seek;
 		FX_INTERFACE_ENTRY(s_tell) = stream_tell;
-	FX_TYPE_CLASS_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
-FX_TYPE_CLASS_DEFINITION_END(fx_file)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
+FX_TYPE_CLASS_END(fx_file)
 
 FX_TYPE_DEFINITION_BEGIN(fx_file)
 	FX_TYPE_ID(0x495a73f6, 0xb8c3, 0x4e17, 0xb5f4, 0x6fc321f67c7b);

fx.io/sys/darwin/path.c

@@ -401,11 +401,11 @@ void path_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_path)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_path)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = path_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_path)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_path)
 
 FX_TYPE_DEFINITION_BEGIN(fx_path)
 	FX_TYPE_ID(0x56dc32eb, 0xea96, 0x46ed, 0x85d3, 0x760fa4ad61f4);

fx.io/sys/linux/directory.c

@@ -711,16 +711,16 @@ static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_directory DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_directory)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_directory)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterable, FX_TYPE_ITERABLE)
 		FX_INTERFACE_ENTRY(it_begin) = iterator_begin;
 		FX_INTERFACE_ENTRY(it_cbegin) = iterator_cbegin;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
-FX_TYPE_CLASS_DEFINITION_END(fx_directory)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterable, FX_TYPE_ITERABLE)
+FX_TYPE_CLASS_END(fx_directory)
 
 FX_TYPE_DEFINITION_BEGIN(fx_directory)
 	FX_TYPE_ID(0x10d36546, 0x7f96, 0x464b, 0xbc4d, 0xe504b283fa45);
@@ -732,18 +732,18 @@ FX_TYPE_DEFINITION_BEGIN(fx_directory)
 FX_TYPE_DEFINITION_END(fx_directory)
 
 // ---- fx_directory_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_directory_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_directory_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
 		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
 		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
 		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
 		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_directory_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
+FX_TYPE_CLASS_END(fx_directory_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_directory_iterator)
 	FX_TYPE_ID(0xc707fce6, 0xc895, 0x4925, 0x8700, 0xa60641dee0cc);

fx.io/sys/linux/file.c

@@ -620,20 +620,20 @@ static void file_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_file)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_file)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
 		FX_INTERFACE_ENTRY(s_close) = stream_close;
 		FX_INTERFACE_ENTRY(s_getc) = stream_getc;
 		FX_INTERFACE_ENTRY(s_read) = stream_read;
 		FX_INTERFACE_ENTRY(s_write) = stream_write;
 		FX_INTERFACE_ENTRY(s_seek) = stream_seek;
 		FX_INTERFACE_ENTRY(s_tell) = stream_tell;
-	FX_TYPE_CLASS_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
-FX_TYPE_CLASS_DEFINITION_END(fx_file)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
+FX_TYPE_CLASS_END(fx_file)
 
 FX_TYPE_DEFINITION_BEGIN(fx_file)
 	FX_TYPE_ID(0x495a73f6, 0xb8c3, 0x4e17, 0xb5f4, 0x6fc321f67c7b);

fx.io/sys/linux/path.c

@@ -401,11 +401,11 @@ void path_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_path)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_path)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = path_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_path)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_path)
 
 FX_TYPE_DEFINITION_BEGIN(fx_path)
 	FX_TYPE_ID(0x56dc32eb, 0xea96, 0x46ed, 0x85d3, 0x760fa4ad61f4);

fx.io/test/streams.c

@@ -1,6 +1,6 @@
-#include <fx/core/stream.h>
 #include <fx/io/file.h>
 #include <fx/io/path.h>
+#include <fx/stream.h>
 #include <stdio.h>
 
 int main(int argc, const char **argv)
@@ -8,7 +8,10 @@ int main(int argc, const char **argv)
 	fx_file *dest;
 	fx_path *path = fx_path_create_from_cstr("data.txt");
 	fx_result result = fx_file_open(
-		NULL, path, FX_FILE_WRITE_ONLY | FX_FILE_CREATE, &dest);
+		NULL,
+		path,
+		FX_FILE_WRITE_ONLY | FX_FILE_CREATE,
+		&dest);
 	if (fx_result_is_error(result)) {
 		fx_throw(result);
 		return -1;

fx.io/test/unit-tests.c

@@ -1,35 +0,0 @@
-#include <CuTest.h>
-#include <fx/core/stringstream.h>
-#include <fx/io/path.h>
-#include <stdio.h>
-
-void test_path_1(CuTest *tc)
-{
-	fx_path *path = fx_path_create_from_cstr("C:\\hello\\world\\");
-	char buf[512];
-	fx_stringstream *str = fx_stringstream_create_with_buffer(buf, sizeof buf);
-
-	fx_object_to_string(path, str);
-
-	printf("%s\n", buf);
-
-	fx_path *path2 = fx_path_create_from_cstr("path1\\path2\\");
-	fx_path *path3 = fx_path_create_from_cstr("path3\\path4\\");
-
-	const fx_path *paths[] = {path, path2, path3};
-
-	fx_path *path4 = fx_path_join(paths, sizeof paths / sizeof paths[0]);
-
-	fx_stringstream_reset_with_buffer(str, buf, sizeof buf);
-	fx_object_to_string(path4, str);
-	printf("%s\n", buf);
-}
-
-CuSuite *get_all_tests(void)
-{
-	CuSuite *suite = CuSuiteNew();
-
-	SUITE_ADD_TEST(suite, test_path_1);
-
-	return suite;
-}

fx.reflection/assembly.c

@@ -35,7 +35,7 @@ struct map {
 
 struct type {
 	struct map_item e_map_item;
-	fx_type e_type;
+	fx_type_id e_type;
 };
 
 struct fx_assembly_p {
@@ -131,7 +131,7 @@ static void assembly_set_version(
 static void assembly_add_type(
 	struct fx_assembly_p *asm,
 	const char *full_name,
-	fx_type type_id)
+	fx_type_id type_id)
 {
 	struct type *type = malloc(sizeof *type);
 	memset(type, 0x0, sizeof *type);
@@ -218,7 +218,7 @@ void fx_assembly_set_version(
 void fx_assembly_add_type(
 	fx_assembly *asm,
 	const char *full_name,
-	fx_type type_id)
+	fx_type_id type_id)
 {
 	FX_CLASS_DISPATCH_STATIC_V(
 		FX_REFLECTION_TYPE_ASSEMBLY,
@@ -249,11 +249,11 @@ static void assembly_fini(fx_object *obj, void *priv)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_string DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_assembly)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_assembly)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_assembly)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_assembly)
 
 FX_TYPE_DEFINITION_BEGIN(fx_assembly)
 	FX_TYPE_ID(0xf6690c30, 0x6642, 0x42f0, 0xb79f, 0xe2baf3684b1b);

fx.reflection/function-context.c

@@ -1,86 +0,0 @@
-#include <fx/macros.h>
-#include <fx/reflection/function.h>
-#include <fx/string.h>
-#include <fx/value.h>
-#include <platform/callvm.h>
-
-struct fx_function_context_p {
-	struct callvm ctx_vm;
-};
-
-/*** PRIVATE FUNCTIONS ********************************************************/
-
-static fx_status function_context_reset(
-	const struct fx_function_context_p *func)
-{
-	return FX_SUCCESS;
-}
-
-static fx_status function_context_push_arg(
-	const struct fx_function_context_p *func,
-	const fx_value *arg)
-{
-	return FX_SUCCESS;
-}
-
-/*** PUBLIC FUNCTIONS *********************************************************/
-
-FX_API fx_function *fx_function_context_create(void)
-{
-	fx_function_context *ctx
-		= fx_object_create(FX_REFLECTION_TYPE_FUNCTION_CONTEXT);
-	if (!ctx) {
-		return NULL;
-	}
-
-	struct fx_function_context_p *p = fx_object_get_private(
-		ctx,
-		FX_REFLECTION_TYPE_FUNCTION_CONTEXT);
-
-	return ctx;
-}
-
-FX_API void fx_function_context_reset(fx_function_context *ctx)
-{
-	FX_CLASS_DISPATCH_STATIC_V0(
-		FX_REFLECTION_TYPE_FUNCTION_CONTEXT,
-		function_context_reset,
-		ctx);
-}
-
-FX_API void fx_function_context_push_arg(
-	fx_function_context *ctx,
-	const fx_value *value)
-{
-	FX_CLASS_DISPATCH_STATIC_V(
-		FX_REFLECTION_TYPE_FUNCTION_CONTEXT,
-		function_context_push_arg,
-		ctx,
-		value);
-}
-
-/*** VIRTUAL FUNCTIONS ********************************************************/
-
-static void function_context_init(fx_object *obj, void *priv)
-{
-}
-
-static void function_context_fini(fx_object *obj, void *priv)
-{
-}
-
-/*** CLASS DEFINITION *********************************************************/
-
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_function_context)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
-		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_function_context)
-
-FX_TYPE_DEFINITION_BEGIN(fx_function_context)
-	FX_TYPE_ID(0x97d98a1a, 0x6312, 0x409e, 0xb47d, 0xc5d80daf9e50);
-	FX_TYPE_CLASS(fx_function_context_class);
-	FX_TYPE_INSTANCE_PRIVATE(struct fx_function_context_p);
-	FX_TYPE_INSTANCE_INIT(function_context_init);
-	FX_TYPE_INSTANCE_FINI(function_context_fini);
-FX_TYPE_DEFINITION_END(fx_function_context)

fx.reflection/function.c

@@ -15,14 +15,51 @@ struct fx_function_p {
 	 * variable number of arguments, which may be handled differently by the
 	 * ABI */
 	size_t func_nr_args;
+
+	fx_value *func_bound_args;
+	size_t func_nr_bound_args, func_max_bound_args;
 };
 
 /*** PRIVATE FUNCTIONS ********************************************************/
 
-extern intptr_t fx_function_invoke_i(
-	fx_function_impl impl,
-	const fx_value *args,
-	size_t nr_args);
+static const char *function_get_name(const struct fx_function_p *func)
+{
+	return func->func_name;
+}
+
+static fx_status function_bind(
+	struct fx_function_p *func,
+	fx_value *args,
+	size_t nr_args)
+{
+	if (func->func_nr_bound_args) {
+		fx_value_unset_array(
+			func->func_bound_args,
+			func->func_nr_bound_args);
+	}
+
+	if (!args || !nr_args) {
+		func->func_nr_bound_args = 0;
+		return FX_SUCCESS;
+	}
+
+	if (nr_args > func->func_max_bound_args) {
+		fx_value *buf = realloc(
+			func->func_bound_args,
+			nr_args * sizeof *buf);
+		if (!buf) {
+			return FX_ERR_NO_MEMORY;
+		}
+
+		func->func_bound_args = buf;
+		func->func_max_bound_args = nr_args;
+	}
+
+	fx_value_copy_array(func->func_bound_args, args, nr_args);
+	func->func_nr_bound_args = nr_args;
+
+	return FX_SUCCESS;
+}
 
 static fx_status function_invoke(
 	const struct fx_function_p *func,
@@ -30,28 +67,37 @@ static fx_status function_invoke(
 	size_t nr_args,
 	fx_value *return_value)
 {
-	if (nr_args < func->func_nr_args) {
+	size_t total_args = nr_args + func->func_nr_bound_args;
+
+	if (total_args < func->func_nr_args) {
 		return FX_ERR_INVALID_ARGUMENT;
 	}
 
-	if (nr_args > func->func_nr_args
+	if (total_args > func->func_nr_args
 	    && !(func->func_flags & FX_FUNCTION_F_VARARG)) {
 		return FX_ERR_INVALID_ARGUMENT;
 	}
 
 	size_t nr_fixed_args = func->func_nr_args;
-	size_t nr_var_args = nr_args - nr_fixed_args;
+	size_t nr_var_args = total_args - nr_fixed_args;
 
 	struct callvm vm = {0};
 	callvm_reset(&vm, nr_fixed_args);
 
+	for (size_t i = 0; i < func->func_nr_bound_args; i++) {
+		const fx_value *arg = &func->func_bound_args[i];
+		callvm_push(&vm, arg);
+	}
+
 	for (size_t i = 0; i < nr_args; i++) {
 		const fx_value *arg = &args[i];
 		callvm_push(&vm, arg);
 	}
 
-	*return_value
-		= callvm_invoke(&vm, func->func_impl, func->func_return_type);
+	*return_value = callvm_invoke(
+		&vm,
+		func->func_impl,
+		func->func_return_type);
 
 	callvm_reset(&vm, 0);
 	return FX_SUCCESS;
@@ -59,7 +105,7 @@ static fx_status function_invoke(
 
 /*** PUBLIC FUNCTIONS *********************************************************/
 
-FX_API fx_function *fx_function_create(
+fx_function *fx_function_create(
 	const char *name,
 	fx_function_flags flags,
 	fx_function_impl impl,
@@ -72,8 +118,13 @@ FX_API fx_function *fx_function_create(
 		return NULL;
 	}
 
-	struct fx_function_p *p
-		= fx_object_get_private(func, FX_REFLECTION_TYPE_FUNCTION);
+	struct fx_function_p *p = fx_object_get_private(
+		func,
+		FX_REFLECTION_TYPE_FUNCTION);
+
+	if (nr_args == 1 && args[0] == FX_VALUE_TYPE_NONE) {
+		nr_args = 0;
+	}
 
 	p->func_name = fx_strdup(name);
 	p->func_flags = flags;
@@ -88,7 +139,25 @@ FX_API fx_function *fx_function_create(
 	return func;
 }
 
-FX_API fx_status fx_function_invoke(
+const char *fx_function_get_name(const fx_function *func)
+{
+	FX_CLASS_DISPATCH_STATIC_0(
+		FX_REFLECTION_TYPE_FUNCTION,
+		function_get_name,
+		func);
+}
+
+fx_status fx_function_bind(fx_function *func, fx_value *args, size_t nr_args)
+{
+	FX_CLASS_DISPATCH_STATIC(
+		FX_REFLECTION_TYPE_FUNCTION,
+		function_bind,
+		func,
+		args,
+		nr_args);
+}
+
+fx_status fx_function_invoke(
 	const fx_function *func,
 	const fx_value *args,
 	size_t nr_args,
@@ -125,14 +194,15 @@ static void function_fini(fx_object *obj, void *priv)
 /*** CLASS DEFINITION
  * *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_function)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_function)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_function)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_function)
 
 FX_TYPE_DEFINITION_BEGIN(fx_function)
 	FX_TYPE_ID(0x09e40174, 0x7443, 0x486e, 0xad21, 0xcc9374762e7e);
+	FX_TYPE_NAME("fx.reflection.function");
 	FX_TYPE_CLASS(fx_function_class);
 	FX_TYPE_INSTANCE_PRIVATE(struct fx_function_p);
 	FX_TYPE_INSTANCE_INIT(function_init);

fx.reflection/include/fx/reflection/assembly.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_assembly);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_assembly)
 FX_TYPE_CLASS_DECLARATION_END(fx_assembly)
 
-FX_API fx_type fx_assembly_get_type();
+FX_API fx_type_id fx_assembly_get_type();
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_assembly, FX_REFLECTION_TYPE_ASSEMBLY);
 
@@ -27,11 +27,10 @@ FX_API void fx_assembly_set_version(
 FX_API void fx_assembly_add_type(
 	fx_assembly *asm,
 	const char *full_name,
-	fx_type type_id);
+	fx_type_id type_id);
 
 FX_API void fx_assembly_dump(const fx_assembly *asm);
 
-FX_DECLS_END
-;
+FX_DECLS_END;
 
 #endif

fx.reflection/include/fx/reflection/function.h

@@ -7,57 +7,26 @@
 
 FX_DECLS_BEGIN;
 
-#define FX_REFLECTION_TYPE_FUNCTION         (fx_function_get_type())
-#define FX_REFLECTION_TYPE_FUNCTION_CONTEXT (fx_function_context_get_type())
+#define FX_REFLECTION_TYPE_FUNCTION (fx_function_get_type())
 
 typedef enum fx_function_flags {
 	FX_FUNCTION_F_NONE = 0x00u,
 	FX_FUNCTION_F_STATIC = 0x01u,
 	FX_FUNCTION_F_VIRTUAL = 0x02u,
 	FX_FUNCTION_F_VARARG = 0x04u,
+	FX_FUNCTION_F_CONSTRUCTOR = 0x08u,
 } fx_function_flags;
 
-#if 0
-#define FX_FUNCTION_VALUE(type)                                                \
-	((fx_function_value) {                                                 \
-		.v_type = FX_FUNCTION_V_PRIMITIVE,                             \
-		.v_primitive = (type),                                         \
-	})
-
-typedef enum fx_function_value_type {
-	FX_FUNCTION_V_NONE = 0,
-	FX_FUNCTION_V_PRIMITIVE,
-	FX_FUNCTION_V_OBJECT,
-} fx_function_value_type;
-
-typedef struct fx_function_value {
-	fx_function_value_type v_type;
-	union {
-		fx_value_type v_primitive;
-		fx_type v_object;
-	};
-} fx_function_value;
-#endif
-
 typedef void (*fx_function_impl)();
 
 FX_DECLARE_TYPE(fx_function);
-FX_DECLARE_TYPE(fx_function_context);
 
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_function)
 FX_TYPE_CLASS_DECLARATION_END(fx_function)
 
-FX_TYPE_CLASS_DECLARATION_BEGIN(fx_function_context)
-FX_TYPE_CLASS_DECLARATION_END(fx_function_context)
+FX_API fx_type_id fx_function_get_type();
 
-FX_API fx_type fx_function_get_type();
-FX_API fx_type fx_function_context_get_type();
-
-FX_API fx_function_context *fx_function_context_create(void);
-FX_API void fx_function_context_reset(fx_function_context *ctx);
-FX_API void fx_function_context_push_arg(
-	fx_function_context *ctx,
-	const fx_value *value);
+FX_API const char *fx_function_get_name(const fx_function *func);
 
 FX_API fx_function *fx_function_create(
 	const char *name,
@@ -67,16 +36,12 @@ FX_API fx_function *fx_function_create(
 	size_t nr_args,
 	fx_value_type return_type);
 FX_API fx_status
-fx_function_bind(const fx_function *func, const fx_value *args, size_t nr_args);
+fx_function_bind(fx_function *func, fx_value *args, size_t nr_args);
 FX_API fx_status fx_function_invoke(
 	const fx_function *func,
 	const fx_value *args,
 	size_t nr_args,
 	fx_value *return_value);
-FX_API fx_status fx_function_invoke_with_context(
-	const fx_function *func,
-	const fx_function_context *ctx,
-	fx_value *return_value);
 
 FX_DECLS_END;
 

fx.reflection/include/fx/reflection/type.h

@@ -0,0 +1,30 @@
+#ifndef FX_REFLECTION_TYPE_H_
+#define FX_REFLECTION_TYPE_H_
+
+#include <fx/macros.h>
+#include <fx/reflection/function.h>
+
+FX_DECLS_BEGIN;
+
+struct fx_type_info;
+
+#define FX_REFLECTION_TYPE_TYPE (fx_type_get_type())
+
+FX_DECLARE_TYPE(fx_type);
+
+FX_TYPE_CLASS_DECLARATION_BEGIN(fx_type)
+FX_TYPE_CLASS_DECLARATION_END(fx_type)
+
+FX_API fx_type_id fx_type_get_type();
+
+FX_API const char *fx_type_get_name(const fx_type *ty);
+FX_API const fx_function *fx_type_get_function(
+	const fx_type *ty,
+	const char *name);
+
+FX_API const fx_type *fx_type_get_by_id(fx_type_id id);
+FX_API const fx_type *fx_type_get_by_name(const char *name);
+
+FX_API fx_type *__fx_type_create(struct fx_type_info *opaque);
+
+#endif

fx.reflection/type.c

@@ -0,0 +1,99 @@
+#include <fx/macros.h>
+#include <fx/reflection/type.h>
+#include <fx/type.h>
+
+struct fx_type_registration;
+
+struct fx_type_p {
+	struct fx_type_info *ty_info;
+};
+
+/*** PRIVATE FUNCTIONS ********************************************************/
+
+extern struct fx_type_info *fx_type_info_get_by_id(const union fx_type_id *key);
+extern struct fx_type_info *fx_type_info_get_by_name(const char *name);
+extern fx_function *fx_type_info_get_function_by_name(
+	const struct fx_type_info *ty,
+	const char *name);
+
+static const char *type_get_name(const struct fx_type_p *ty)
+{
+	return ty->ty_info->ty_name;
+}
+
+const fx_function *type_get_function(
+	const struct fx_type_p *ty,
+	const char *name)
+{
+	return fx_type_info_get_function_by_name(ty->ty_info, name);
+}
+
+/*** PUBLIC FUNCTIONS *********************************************************/
+
+fx_type *__fx_type_create(struct fx_type_info *type_info)
+{
+	fx_type *out = fx_object_create(FX_REFLECTION_TYPE_TYPE);
+	if (!out) {
+		return NULL;
+	}
+
+	struct fx_type_p *p = fx_object_get_private(
+		out,
+		FX_REFLECTION_TYPE_TYPE);
+	p->ty_info = type_info;
+
+	return out;
+}
+
+const char *fx_type_get_name(const fx_type *ty)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_REFLECTION_TYPE_TYPE, type_get_name, ty);
+}
+
+const fx_function *fx_type_get_function(const fx_type *ty, const char *name)
+{
+	FX_CLASS_DISPATCH_STATIC(
+		FX_REFLECTION_TYPE_TYPE,
+		type_get_function,
+		ty,
+		name);
+}
+
+const fx_type *fx_type_get_by_id(fx_type_id id)
+{
+	struct fx_type_info *ty = fx_type_info_get_by_id(id);
+	return ty ? ty->ty_metatype : NULL;
+}
+
+const fx_type *fx_type_get_by_name(const char *name)
+{
+	struct fx_type_info *ty = fx_type_info_get_by_name(name);
+	return ty ? ty->ty_metatype : NULL;
+}
+
+/*** VIRTUAL FUNCTIONS ********************************************************/
+
+static void type_init(fx_object *obj, void *priv)
+{
+}
+
+static void type_fini(fx_object *obj, void *priv)
+{
+}
+
+/*** CLASS DEFINITION *********************************************************/
+
+FX_TYPE_CLASS_BEGIN(fx_type)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+		FX_INTERFACE_ENTRY(to_string) = NULL;
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_type)
+
+FX_TYPE_DEFINITION_BEGIN(fx_type)
+	FX_TYPE_ID(0xec8b2679, 0x5c73, 0x4ec9, 0xa04e, 0x3f72881b5b5a);
+	FX_TYPE_NAME("fx.reflection.type");
+	FX_TYPE_CLASS(fx_type_class);
+	FX_TYPE_INSTANCE_PRIVATE(struct fx_type_p);
+	FX_TYPE_INSTANCE_INIT(type_init);
+	FX_TYPE_INSTANCE_FINI(type_fini);
+FX_TYPE_DEFINITION_END(fx_type)

fx.serial/bitcode.c

@@ -31,16 +31,16 @@ static void bitcode_serial_ctx_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bitcode_serial_ctx)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_bitcode_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
 		FX_INTERFACE_ENTRY(s_serialise) = bitcode_serialise;
 		FX_INTERFACE_ENTRY(s_deserialise) = bitcode_deserialise;
-	FX_TYPE_CLASS_INTERFACE_END(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
-FX_TYPE_CLASS_DEFINITION_END(fx_bitcode_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
+FX_TYPE_CLASS_END(fx_bitcode_serial_ctx)
 
 FX_TYPE_DEFINITION_BEGIN(fx_bitcode_serial_ctx)
 	FX_TYPE_ID(0xcdc8c462, 0xf2b3, 0x4193, 0x8cae, 0xc1e5ad9afcb8);

fx.serial/ctx.c

@@ -26,11 +26,11 @@ static void serial_ctx_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_serial_ctx)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_serial_ctx)
 
 FX_TYPE_DEFINITION_BEGIN(fx_serial_ctx)
 	FX_TYPE_ID(0xc7c1039a, 0xf397, 0x4fda, 0xb473, 0x4d86fec85384);

fx.serial/include/fx/serial/bitcode.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_bitcode_serial_ctx);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bitcode_serial_ctx)
 FX_TYPE_CLASS_DECLARATION_END(fx_bitcode_serial_ctx)
 
-FX_API fx_type fx_bitcode_serial_ctx_get_type(void);
+FX_API fx_type_id fx_bitcode_serial_ctx_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_bitcode_serial_ctx, FX_TYPE_BITCODE_SERIAL_CTX);
 

fx.serial/include/fx/serial/ctx.h

@@ -35,7 +35,7 @@ typedef struct fx_serial_ctx_data {
 	fx_stream_buffer *ctx_streambuf;
 } fx_serial_ctx_data;
 
-FX_API fx_type fx_serial_ctx_get_type(void);
+FX_API fx_type_id fx_serial_ctx_get_type(void);
 
 FX_API fx_result fx_serial_ctx_serialise(
 	fx_serial_ctx *ctx,

fx.serial/include/fx/serial/toml.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_toml_serial_ctx);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_toml_serial_ctx)
 FX_TYPE_CLASS_DECLARATION_END(fx_toml_serial_ctx)
 
-FX_API fx_type fx_toml_serial_ctx_get_type(void);
+FX_API fx_type_id fx_toml_serial_ctx_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_toml_serial_ctx, FX_TYPE_TOML_SERIAL_CTX);
 

fx.serial/test/streams.c

@@ -1,9 +1,10 @@
-#include <fx/core/stream.h>
-#include <fx/ds/array.h>
-#include <fx/ds/dict.h>
-#include <fx/ds/number.h>
-#include <fx/ds/string.h>
-#include <fx/serial.h>
+#include <fx/collections/array.h>
+#include <fx/collections/dict.h>
+#include <fx/int.h>
+#include <fx/serial/ctx.h>
+#include <fx/serial/toml.h>
+#include <fx/stream.h>
+#include <fx/string.h>
 #include <stdio.h>
 
 int main(void)
@@ -13,9 +14,9 @@ int main(void)
 	fx_dict *dict = fx_dict_create();
 
 	fx_array *array = fx_array_create();
-	fx_array_append(array, FX_RV_INT(32));
-	fx_array_append(array, FX_RV_INT(64));
-	fx_array_append(array, FX_RV_INT(128));
+	fx_array_append(array, fx_int_create(32));
+	fx_array_append(array, fx_int_create(64));
+	fx_array_append(array, fx_int_create(128));
 
 	fx_dict_put(dict, "numbers", FX_RV(array));
 

fx.serial/test/toml-decode.c

@@ -1,9 +1,12 @@
-#include <fx/ds/array.h>
-#include <fx/ds/datetime.h>
-#include <fx/ds/dict.h>
-#include <fx/ds/number.h>
-#include <fx/ds/string.h>
-#include <fx/serial.h>
+#include <fx/bool.h>
+#include <fx/collections/array.h>
+#include <fx/collections/datetime.h>
+#include <fx/collections/dict.h>
+#include <fx/double.h>
+#include <fx/int.h>
+#include <fx/serial/ctx.h>
+#include <fx/serial/toml.h>
+#include <fx/string.h>
 #include <inttypes.h>
 
 void write_tagged_value(fx_object *data);
@@ -50,50 +53,50 @@ void write_tagged_string(fx_string *data)
 	fx_stream_write_cstr(fx_stdout, " }", NULL);
 }
 
-void write_tagged_integer(fx_number *data)
+void write_tagged_integer(fx_int *data)
 {
 	fx_stream_write_cstr(
 		fx_stdout,
 		"{ \"type\": \"integer\", \"value\": \"",
 		NULL);
 
-	if (fx_number_is_inf_positive(data)) {
+	if (fx_int_is_inf_positive(data)) {
 		fx_stream_write_cstr(fx_stdout, "inf", NULL);
-	} else if (fx_number_is_inf_negative(data)) {
+	} else if (fx_int_is_inf_negative(data)) {
 		fx_stream_write_cstr(fx_stdout, "-inf", NULL);
-	} else if (fx_number_is_nan_positive(data)) {
+	} else if (fx_int_is_nan_positive(data)) {
 		fx_stream_write_cstr(fx_stdout, "nan", NULL);
-	} else if (fx_number_is_nan_negative(data)) {
+	} else if (fx_int_is_nan_negative(data)) {
 		fx_stream_write_cstr(fx_stdout, "-nan", NULL);
 	} else {
 		fx_stream_write_fmt(
 			fx_stdout,
 			NULL,
 			"%lld",
-			fx_number_get_longlong(data),
+			fx_int_get_value(data),
 			NULL);
 	}
 
 	fx_stream_write_cstr(fx_stdout, "\" }", NULL);
 }
 
-void write_tagged_float(fx_number *data)
+void write_tagged_float(fx_double *data)
 {
 	fx_stream_write_cstr(
 		fx_stdout,
 		"{ \"type\": \"float\", \"value\": \"",
 		NULL);
 
-	if (fx_number_is_inf_positive(data)) {
+	if (fx_double_is_inf_positive(data)) {
 		fx_stream_write_cstr(fx_stdout, "inf", NULL);
-	} else if (fx_number_is_inf_negative(data)) {
+	} else if (fx_double_is_inf_negative(data)) {
 		fx_stream_write_cstr(fx_stdout, "-inf", NULL);
-	} else if (fx_number_is_nan_positive(data)) {
+	} else if (fx_double_is_nan_positive(data)) {
 		fx_stream_write_cstr(fx_stdout, "nan", NULL);
-	} else if (fx_number_is_nan_negative(data)) {
+	} else if (fx_double_is_nan_negative(data)) {
 		fx_stream_write_cstr(fx_stdout, "-nan", NULL);
 	} else {
-		double v = fx_number_get_double(data);
+		double v = fx_double_get_value(data);
 		if ((v <= 0.00000001 && v > 0) || (v >= -0.00000001 && v < 0)
 		    || (v >= 1000000000) || (v <= -1000000000)) {
 			fx_stream_write_fmt(fx_stdout, NULL, "%.15e", v, NULL);
@@ -105,14 +108,13 @@ void write_tagged_float(fx_number *data)
 	fx_stream_write_cstr(fx_stdout, "\" }", NULL);
 }
 
-void write_tagged_bool(fx_number *data)
+void write_tagged_bool(fx_bool *data)
 {
-	int v = fx_number_get_int8(data);
 	fx_stream_write_fmt(
 		fx_stdout,
 		NULL,
 		"{ \"type\": \"bool\", \"value\": \"%s\" }",
-		(v > 0) ? "true" : "false",
+		fx_bool_get_value(data) ? "true" : "false",
 		NULL);
 }
 
@@ -197,30 +199,18 @@ void write_tagged_value(fx_object *data)
 {
 	if (fx_object_is_type(data, FX_TYPE_DICT)) {
 		write_tagged_dict(data);
-
 	} else if (fx_object_is_type(data, FX_TYPE_ARRAY)) {
 		write_tagged_array(data);
-
 	} else if (fx_object_is_type(data, FX_TYPE_STRING)) {
 		write_tagged_string(data);
-
 	} else if (fx_object_is_type(data, FX_TYPE_DATETIME)) {
 		write_tagged_datetime(data);
-
-	} else if (fx_object_is_type(data, FX_TYPE_NUMBER)) {
-		switch (fx_number_get_number_type(data)) {
-		case FX_NUMBER_LONGLONG:
-			write_tagged_integer(data);
-			break;
-		case FX_NUMBER_INT8:
-			write_tagged_bool(data);
-			break;
-		case FX_NUMBER_DOUBLE:
-			write_tagged_float(data);
-			break;
-		default:
-			break;
-		}
+	} else if (fx_object_is_type(data, FX_TYPE_INT)) {
+		write_tagged_integer(data);
+	} else if (fx_object_is_type(data, FX_TYPE_BOOL)) {
+		write_tagged_bool(data);
+	} else if (fx_object_is_type(data, FX_TYPE_DOUBLE)) {
+		write_tagged_float(data);
 	}
 }
 

fx.serial/toml.c

@@ -2322,16 +2322,16 @@ static void toml_serial_ctx_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_toml_serial_ctx)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_toml_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
 
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
 		FX_INTERFACE_ENTRY(s_serialise) = toml_serialise;
 		FX_INTERFACE_ENTRY(s_deserialise) = toml_deserialise;
-	FX_TYPE_CLASS_INTERFACE_END(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
-FX_TYPE_CLASS_DEFINITION_END(fx_toml_serial_ctx)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_serial_ctx, FX_TYPE_SERIAL_CTX)
+FX_TYPE_CLASS_END(fx_toml_serial_ctx)
 
 FX_TYPE_DEFINITION_BEGIN(fx_toml_serial_ctx)
 	FX_TYPE_ID(0xaec8dca0, 0x131a, 0x4217, 0x916b, 0xaed15756601c);

fx.term/test/errors.c

@@ -1,4 +1,4 @@
-#include <fx/core/error.h>
+#include <fx/error.h>
 #include <fx/term/print.h>
 #include <stdio.h>
 
@@ -17,21 +17,28 @@ static const fx_error_definition sample_errors[] = {
 	FX_ERROR_DEFINITION(SAMPLE_OK, "OK", "Success"),
 	FX_ERROR_DEFINITION(SAMPLE_ERR_IO_FAILURE, "IO_FAILURE", "I/O failure"),
 	FX_ERROR_DEFINITION_TEMPLATE(
-		SAMPLE_ERR_FILE_READ_FAILED, "FILE_READ_FAILED",
+		SAMPLE_ERR_FILE_READ_FAILED,
+		"FILE_READ_FAILED",
 		"Failed to read file @i[filepath]",
 		FX_ERROR_TEMPLATE_PARAM(
-			"filepath", FX_ERROR_TEMPLATE_PARAM_STRING, "%s")),
+			"filepath",
+			FX_ERROR_TEMPLATE_PARAM_STRING,
+			"%s")),
 };
 
 static const fx_error_msg sample_error_msg[] = {
 	FX_ERROR_MSG_TEMPLATE(
-		SAMPLE_MSG_A_TEMPLATED_MSG, "A templated message: @e[param1]",
+		SAMPLE_MSG_A_TEMPLATED_MSG,
+		"A templated message: @e[param1]",
 		FX_ERROR_TEMPLATE_PARAM(
-			"param1", FX_ERROR_TEMPLATE_PARAM_STRING, "%s")),
+			"param1",
+			FX_ERROR_TEMPLATE_PARAM_STRING,
+			"%s")),
 };
 
 static const char *sample_code_to_string(
-	const struct fx_error_vendor *vendor, fx_error_status_code code)
+	const struct fx_error_vendor *vendor,
+	fx_error_status_code code)
 {
 	switch (code) {
 	case SAMPLE_OK:
@@ -56,15 +63,22 @@ static fx_error_vendor sample_vendor = {
 static fx_result error_return_3(void)
 {
 	fx_result err = fx_error_with_string(
-		&sample_vendor, SAMPLE_ERR_IO_FAILURE,
+		&sample_vendor,
+		SAMPLE_ERR_IO_FAILURE,
 		"I/O failure while reading file");
 
 	fx_error_add_submsg_string(
-		err, FX_ERROR_SUBMSG_ERROR, "An @e{error} message");
+		err,
+		FX_ERROR_SUBMSG_ERROR,
+		"An @e{error} message");
 	fx_error_add_submsg_string(
-		err, FX_ERROR_SUBMSG_WARNING, "A @w{warning} message");
+		err,
+		FX_ERROR_SUBMSG_WARNING,
+		"A @w{warning} message");
 	fx_error_add_submsg_template(
-		err, FX_ERROR_SUBMSG_WARNING, SAMPLE_MSG_A_TEMPLATED_MSG,
+		err,
+		FX_ERROR_SUBMSG_WARNING,
+		SAMPLE_MSG_A_TEMPLATED_MSG,
 		FX_ERROR_PARAM("param1", "Hello!"));
 
 	return err;
@@ -105,10 +119,12 @@ static fx_result some_operation(void)
 	fx_result result = error_return_2();
 	if (fx_result_is_error(result)) {
 		fx_result err = fx_error_with_template(
-			&sample_vendor, SAMPLE_ERR_FILE_READ_FAILED,
+			&sample_vendor,
+			SAMPLE_ERR_FILE_READ_FAILED,
 			FX_ERROR_PARAM("filepath", "src/Manifest.json"));
 		fx_error_add_submsg_string(
-			err, FX_ERROR_SUBMSG_INFO,
+			err,
+			FX_ERROR_SUBMSG_INFO,
 			"An @i{informational} message");
 
 		fx_error_caused_by_fx_status(result, FX_ERR_IO_FAILURE);
@@ -122,7 +138,9 @@ static fx_result some_operation(void)
 
 int main(void)
 {
-	fx_set_error_report_function(fx_enhanced_error_reporter, FX_ERROR_REPORT_ALL);
+	fx_set_error_report_function(
+		fx_enhanced_error_reporter,
+		FX_ERROR_REPORT_ALL);
 
 	test(PARAM("Hello", 1), PARAM("Goodbye", 2));
 

fx.term/test/printing.c

@@ -1,6 +1,6 @@
-#include <fx/term/tty.h>
+#include <fx/string.h>
 #include <fx/term/print.h>
-#include <fx/ds/string.h>
+#include <fx/term/tty.h>
 #include <stdio.h>
 
 #define F_GREEN  "[green]"
@@ -62,7 +62,7 @@ int main(void)
 	size_t len = fx_string_get_size(str, FX_STRLEN_IGNORE_MOD);
 	printf("length = %zu\n", len);
 
-	fx_paragraph_format format = { 0 };
+	fx_paragraph_format format = {0};
 	format.p_left_margin = 5;
 	format.p_right_margin = 5;
 	format.p_flags = FX_PARAGRAPH_DOUBLE_LINE_BREAK;
@@ -72,8 +72,11 @@ int main(void)
 	fx_i("An informational message\n\nWith multiple lines");
 	fx_warn("A warning message\nWith multiple lines");
 	fx_err("An error message\nWith multiple lines");
-	
-	fx_printf("[red]formatting ignored: '%s'[reset]\n[dark_grey]dark text[reset]\n", "[blue]wow![reset]");
+
+	fx_printf(
+		"[red]formatting ignored: '%s'[reset]\n[dark_grey]dark "
+	        "text[reset]\n",
+		"[blue]wow![reset]");
 
 	return 0;
 }

fx/bool.c

@@ -69,11 +69,11 @@ static void bool_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bool)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_bool)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = bool_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_bool)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_bool)
 
 FX_TYPE_DEFINITION_BEGIN(fx_bool)
 	FX_TYPE_ID(0x9c8453bf, 0xfc92, 0x4b0a, 0xbcaf, 0xd0c6cdba9310);

fx/bst.c

@@ -59,6 +59,7 @@
 
 #include <fx/bst.h>
 #include <stddef.h>
+#include <string.h>
 
 #define MAX(a, b)            ((a) > (b) ? (a) : (b))
 #define MIN(a, b)            ((a) < (b) ? (a) : (b))
@@ -766,131 +767,3 @@ void fx_bst_move(
 
 	memmove(dest, src, sizeof *src);
 }
-
-fx_iterator *fx_bst_begin(struct fx_bst *tree)
-{
-	fx_iterator *it_obj = fx_object_create(FX_TYPE_BST_ITERATOR);
-	if (!it_obj) {
-		return NULL;
-	}
-
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(it_obj, FX_TYPE_BST_ITERATOR);
-	int depth = 0;
-
-	it->_b = (struct fx_bst *)tree;
-	it->i = 0;
-	it->node = first_node(tree, &depth);
-	it->depth = depth;
-
-	return it_obj;
-}
-
-const fx_iterator *fx_bst_cbegin(const struct fx_bst *tree)
-{
-	fx_iterator *it_obj = fx_object_create(FX_TYPE_BST_ITERATOR);
-	if (!it_obj) {
-		return NULL;
-	}
-
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(it_obj, FX_TYPE_BST_ITERATOR);
-	int depth = 0;
-
-	it->_b = (struct fx_bst *)tree;
-	it->i = 0;
-	it->node = first_node(tree, &depth);
-	it->depth = depth;
-
-	return it_obj;
-}
-
-static enum fx_status iterator_move_next(const fx_iterator *obj)
-{
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_BST_ITERATOR);
-
-	int depth_diff = 0;
-	struct fx_bst_node *next = next_node(it->node, &depth_diff);
-
-	if (!next) {
-		it->node = NULL;
-		it->depth = 0;
-		it->i++;
-		return false;
-	}
-
-	it->node = next;
-	it->i++;
-	it->depth += depth_diff;
-	return true;
-}
-
-static enum fx_status iterator_erase(fx_iterator *obj)
-{
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_BST_ITERATOR);
-
-	if (!it->node) {
-		return FX_ERR_OUT_OF_BOUNDS;
-	}
-
-	int depth_diff = 0;
-	struct fx_bst_node *next = next_node(it->node, &depth_diff);
-
-	fx_bst_delete(it->_b, it->node);
-	if (!next) {
-		it->node = NULL;
-		it->depth = 0;
-	} else {
-		it->node = next;
-		it->depth = 0;
-
-		struct fx_bst_node *cur = next->n_parent;
-		while (cur) {
-			it->depth++;
-			cur = cur->n_parent;
-		}
-	}
-
-	return FX_SUCCESS;
-}
-
-static fx_iterator_value iterator_get_value(fx_iterator *obj)
-{
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_BST_ITERATOR);
-
-	return FX_ITERATOR_VALUE_PTR(it->node);
-}
-
-static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
-{
-	struct fx_bst_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_BST_ITERATOR);
-
-	return FX_ITERATOR_VALUE_CPTR(it->node);
-}
-
-/*** CLASS DEFINITION *********************************************************/
-
-// ---- fx_bst_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bst_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
-		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
-		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
-		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
-		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
-		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_bst_iterator)
-
-FX_TYPE_DEFINITION_BEGIN(fx_bst_iterator)
-	FX_TYPE_ID(0x432779d7, 0xc03a, 0x48ea, 0xae8f, 0x12c666c767ae);
-	FX_TYPE_EXTENDS(FX_TYPE_ITERATOR);
-	FX_TYPE_CLASS(fx_bst_iterator_class);
-	FX_TYPE_INSTANCE_PRIVATE(struct fx_bst_iterator_p);
-FX_TYPE_DEFINITION_END(fx_bst_iterator)

fx/class.c

@@ -7,14 +7,14 @@
 #include <stdlib.h>
 #include <string.h>
 
-void *fx_class_get(fx_type id)
+void *fx_class_get(fx_type_id id)
 {
-	struct fx_type_registration *r = fx_type_get_registration(id);
-	if (!r) {
+	struct fx_type_info *ty = fx_type_info_get_by_id(id);
+	if (!ty) {
 		return NULL;
 	}
 
-	return r->r_class;
+	return ty->ty_class;
 }
 
 const char *fx_class_get_name(const struct _fx_class *c)
@@ -25,10 +25,12 @@ const char *fx_class_get_name(const struct _fx_class *c)
 
 	assert(c->c_magic == FX_CLASS_MAGIC);
 
-	return c->c_type->r_info->t_name;
+	return c->c_type->ty_name;
 }
 
-void *fx_class_get_interface(const struct _fx_class *c, const union fx_type *id)
+void *fx_class_get_interface(
+	const struct _fx_class *c,
+	const union fx_type_id *id)
 {
 	if (!c) {
 		return NULL;
@@ -36,9 +38,10 @@ void *fx_class_get_interface(const struct _fx_class *c, const union fx_type *id)
 
 	assert(c->c_magic == FX_CLASS_MAGIC);
 
-	const struct fx_type_registration *type_reg = c->c_type;
-	struct fx_type_component *comp
-		= fx_type_get_component(&type_reg->r_components, id);
+	const struct fx_type_info *type_reg = c->c_type;
+	struct fx_type_component *comp = fx_type_get_component(
+		&type_reg->ty_components,
+		id);
 
 	if (!comp) {
 		return NULL;
@@ -48,28 +51,38 @@ void *fx_class_get_interface(const struct _fx_class *c, const union fx_type *id)
 }
 
 fx_result fx_class_instantiate(
-	struct fx_type_registration *type,
+	struct fx_type_info *type,
 	struct _fx_class **out_class)
 {
-	struct _fx_class *out = malloc(type->r_class_size);
+	struct _fx_class *out = malloc(type->ty_class_size);
 	if (!out) {
 		return FX_RESULT_ERR(NO_MEMORY);
 	}
 
-	memset(out, 0x0, type->r_class_size);
+	memset(out, 0x0, type->ty_class_size);
 
 	out->c_magic = FX_CLASS_MAGIC;
 	out->c_type = type;
 
-	struct fx_queue_entry *entry = fx_queue_first(&type->r_class_hierarchy);
+	struct fx_queue_entry *entry = fx_queue_first(
+		&type->ty_class_hierarchy);
 	while (entry) {
-		struct fx_type_component *comp
-			= fx_unbox(struct fx_type_component, entry, c_entry);
-		const struct fx_type_info *class_info = comp->c_type->r_info;
+		struct fx_type_component *comp = fx_unbox(
+			struct fx_type_component,
+			entry,
+			c_entry);
+		const struct fx_type_info *class_info = comp->c_type;
 		void *class_data = (char *)out + comp->c_class_data_offset;
+		struct fx_type_info *main_class_param = NULL;
+		if (class_info == type) {
+			main_class_param = type;
+		}
 
-		if (class_info->t_class_init) {
-			class_info->t_class_init(out, class_data);
+		if (class_info->ty_class_init) {
+			class_info->ty_class_init(
+				out,
+				main_class_param,
+				class_data);
 		}
 
 		entry = fx_queue_next(entry);

fx/class.h

@@ -5,14 +5,15 @@
 #include <fx/misc.h>
 #include <stdint.h>
 
-struct fx_type_registration;
+struct fx_type_info;
 
 struct _fx_class {
 	uint64_t c_magic;
-	const struct fx_type_registration *c_type;
+	const struct fx_type_info *c_type;
 };
 
 extern fx_result fx_class_instantiate(
-	struct fx_type_registration *type, struct _fx_class **out);
+	struct fx_type_info *type,
+	struct _fx_class **out);
 
 #endif

fx/double.c

@@ -265,11 +265,11 @@ static void double_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_double)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_double)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = double_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_double)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_double)
 
 FX_TYPE_DEFINITION_BEGIN(fx_double)
 	FX_TYPE_ID(0x3b20f57a, 0x2ddf, 0x4682, 0x81c4, 0x4fe404a6524e);

fx/include/fx/bool.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_bool);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bool)
 FX_TYPE_CLASS_DECLARATION_END(fx_bool)
 
-FX_API fx_type fx_bool_get_type(void);
+FX_API fx_type_id fx_bool_get_type(void);
 
 FX_API fx_bool *fx_bool_create(bool value);
 

fx/include/fx/bst.h

@@ -1,22 +1,16 @@
 #ifndef FX_CORE_BST_H_
 #define FX_CORE_BST_H_
 
-#include <fx/iterator.h>
-#include <fx/macros.h>
 #include <fx/misc.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-FX_DECLS_BEGIN;
+#ifdef __cplusplus
+#define FX_DECLS_BEGIN extern "C" {
+#endif
 
-#define FX_BST_INIT          {0}
-#define FX_TYPE_BST_ITERATOR (fx_bst_iterator_get_type())
-
-FX_DECLARE_TYPE(fx_bst_iterator);
-
-FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bst_iterator)
-FX_TYPE_CLASS_DECLARATION_END(fx_bst_iterator)
+#define FX_BST_INIT {0}
 
 /* defines a simple node insertion function.
    this function assumes that your nodes have simple integer keys that can be
@@ -26,18 +20,18 @@ FX_TYPE_CLASS_DECLARATION_END(fx_bst_iterator)
    if you have a tree node type like this:
 
      struct my_tree_node {
-	     int key;
-	     fx_bst_node base;
+             int key;
+             fx_bst_node base;
      }
 
    You would use the following call to generate an insert function for a tree
    with this node type:
 
      BST_DEFINE_SIMPLE_INSERT(
-	struct my_tree_node,
-	base,
-	key,
-	my_tree_node_insert);
+        struct my_tree_node,
+        base,
+        key,
+        my_tree_node_insert);
 
    Which would emit a function defined like:
 
@@ -111,8 +105,8 @@ FX_TYPE_CLASS_DECLARATION_END(fx_bst_iterator)
    if you have a tree node type like this:
 
      struct my_tree_node {
-	     complex_key_t key;
-	     fx_bst_node base;
+             complex_key_t key;
+             fx_bst_node base;
      }
 
    You would need to define a comparator function or macro with the following
@@ -207,8 +201,8 @@ FX_TYPE_CLASS_DECLARATION_END(fx_bst_iterator)
    if you have a tree node type like this:
 
      struct my_tree_node {
-	     int key;
-	     fx_bst_node base;
+             int key;
+             fx_bst_node base;
      }
 
    You would use the following call to generate a search function for a tree
@@ -279,8 +273,6 @@ typedef struct fx_bst {
 	fx_bst_node *bst_root;
 } fx_bst;
 
-FX_API fx_type fx_bst_iterator_get_type(void);
-
 /* re-balance a binary tree after an insertion operation.
 
    NOTE that, if you define an insertion function using BST_DEFINE_INSERT or
@@ -369,9 +361,6 @@ static inline unsigned short fx_bst_height(fx_bst_node *node)
 	return node->n_height;
 }
 
-FX_API fx_iterator *fx_bst_begin(fx_bst *tree);
-FX_API const fx_iterator *fx_bst_cbegin(const fx_bst *tree);
-
 #ifdef __cplusplus
 }
 #endif

fx/include/fx/class.h

@@ -8,8 +8,8 @@
 
 typedef struct _fx_class fx_class;
 
-FX_API void *fx_class_get(fx_type id);
+FX_API void *fx_class_get(fx_type_id id);
 FX_API const char *fx_class_get_name(const fx_class *c);
-FX_API void *fx_class_get_interface(const fx_class *c, fx_type id);
+FX_API void *fx_class_get_interface(const fx_class *c, fx_type_id id);
 
 #endif

fx/include/fx/double.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_double);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_double)
 FX_TYPE_CLASS_DECLARATION_END(fx_double)
 
-FX_API fx_type fx_double_get_type(void);
+FX_API fx_type_id fx_double_get_type(void);
 
 FX_API fx_double *fx_double_create(double value);
 FX_API fx_double *fx_double_create_nan(void);

fx/include/fx/int.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_int);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_int)
 FX_TYPE_CLASS_DECLARATION_END(fx_int)
 
-FX_API fx_type fx_int_get_type(void);
+FX_API fx_type_id fx_int_get_type(void);
 
 FX_API fx_int *fx_int_create(intptr_t value);
 FX_API fx_int *fx_int_create_nan(void);

fx/include/fx/iterator.h

@@ -61,8 +61,8 @@ FX_TYPE_CLASS_DECLARATION_BEGIN(fx_iterable)
 	const fx_iterator *(*it_cbegin)(const fx_iterable *);
 FX_TYPE_CLASS_DECLARATION_END(fx_iterable)
 
-FX_API fx_type fx_iterator_get_type(void);
-FX_API fx_type fx_iterable_get_type(void);
+FX_API fx_type_id fx_iterator_get_type(void);
+FX_API fx_type_id fx_iterable_get_type(void);
 
 static inline const fx_iterator *fx_iterator_ref(const fx_iterator *p)
 {

fx/include/fx/macros.h

@@ -5,6 +5,7 @@
 #include <fx/object.h>
 #include <fx/thread.h>
 #include <fx/type.h>
+#include <fx/value.h>
 #include <stdlib.h>
 
 #define __FX_IFACE_I0(p, x) p##x
@@ -12,12 +13,63 @@
 
 /* Type definitions macros (for use in .c source file) */
 
-#define FX_TYPE_CLASS_DEFINITION_BEGIN(type_name)                              \
-	static void type_name##_class_init(fx_class *p, void *d)               \
+#define FX_TYPE_CLASS_BEGIN(type_name)                                         \
+	static void type_name##_class_init(                                    \
+		fx_class *p,                                                   \
+		fx_type_info *ty,                                              \
+		void *d)                                                       \
 	{
-#define FX_TYPE_CLASS_DEFINITION_END(type_name) }
+#define FX_TYPE_CLASS_END(type_name) }
 
-#define FX_TYPE_CLASS_INTERFACE_BEGIN(interface_name, interface_id)            \
+#define FX_TYPE_FUNCTIONALITY_BEGIN(type_name)                                 \
+	static void type_name##_type_functionality_init(void *opaque)          \
+	{
+#define FX_TYPE_FUNCTIONALITY_END(type_name) }
+#define FX_TYPE_CONSTRUCTOR(name, impl, flags, ...)                            \
+	do {                                                                   \
+		if (ty) {                                                      \
+			fx_value_type args[] = {__VA_ARGS__};                  \
+			fx_function *func = fx_function_create(                \
+				name,                                          \
+				FX_FUNCTION_F_CONSTRUCTOR                      \
+					| FX_FUNCTION_F_STATIC | (flags),      \
+				(fx_function_impl)impl,                        \
+				args,                                          \
+				sizeof args / sizeof args[0],                  \
+				FX_VALUE_TYPE_POINTER);                        \
+			fx_type_add_function(ty, func);                        \
+		}                                                              \
+	} while (0)
+#define FX_TYPE_METHOD(return_type, name, impl, flags, ...)                    \
+	do {                                                                   \
+		if (ty) {                                                      \
+			fx_value_type args[] = {__VA_ARGS__};                  \
+			fx_function *func = fx_function_create(                \
+				name,                                          \
+				(flags),                                       \
+				(fx_function_impl)impl,                        \
+				args,                                          \
+				sizeof args / sizeof args[0],                  \
+				return_type);                                  \
+			fx_type_add_function(ty, func);                        \
+		}                                                              \
+	} while (0)
+#define FX_TYPE_FUNCTION(return_type, name, impl, ...)                         \
+	do {                                                                   \
+		if (ty) {                                                      \
+			fx_value_type args[] = {__VA_ARGS__};                  \
+			fx_function *func = fx_function_create(                \
+				name,                                          \
+				FX_FUNCTION_F_STATIC | (flags),                \
+				(fx_function_impl)impl,                        \
+				args,                                          \
+				sizeof args / sizeof args[0],                  \
+				return_type);                                  \
+			fx_type_add_function(ty, func);                        \
+		}                                                              \
+	} while (0)
+
+#define FX_TYPE_VTABLE_INTERFACE_BEGIN(interface_name, interface_id)           \
 	interface_name##_class *__FX_IFACE_I1(iface, __LINE__)                 \
 		= fx_class_get_interface(p, interface_id);                     \
 	if (!__FX_IFACE_I1(iface, __LINE__)) {                                 \
@@ -30,18 +82,18 @@
 		exit(-1);                                                      \
 	} else {                                                               \
 		interface_name##_class *iface = __FX_IFACE_I1(iface, __LINE__);
-#define FX_TYPE_CLASS_INTERFACE_END(interface_name, interface_id) }
-#define FX_INTERFACE_ENTRY(slot)                                  iface->slot
+#define FX_TYPE_VTABLE_INTERFACE_END(interface_name, interface_id) }
+#define FX_INTERFACE_ENTRY(slot)                                   iface->slot
 
 #define FX_TYPE_DEFINITION_BEGIN(name)                                         \
 	static fx_type_info name##_type_info = {0};                            \
-	static void name##_class_init(fx_class *, void *);                     \
+	static void name##_class_init(fx_class *, fx_type_info *, void *);     \
 	static void name##_type_init(void)                                     \
 	{                                                                      \
 		fx_type_info *type_info = &name##_type_info;                   \
 		unsigned int nr_vtables = 0;                                   \
-		type_info->t_name = #name;                                     \
-		type_info->t_class_init = name##_class_init;
+		type_info->ty_name = #name;                                    \
+		type_info->ty_class_init = name##_class_init;
 #define FX_TYPE_DEFINITION_END(name)                                           \
 	fx_result result = fx_type_register(type_info);                        \
 	if (fx_result_is_error(result)) {                                      \
@@ -52,7 +104,7 @@
 		abort();                                                       \
 	}                                                                      \
 	}                                                                      \
-	fx_type name##_get_type(void)                                          \
+	fx_type_id name##_get_type(void)                                       \
 	{                                                                      \
 		static fx_once static_type_init = FX_ONCE_INIT;                \
                                                                                \
@@ -60,39 +112,28 @@
 			name##_type_init();                                    \
 		}                                                              \
                                                                                \
-		return &name##_type_info.t_id;                                 \
+		return &name##_type_info.ty_id;                                \
 	}
 
 #define FX_TYPE_ID(a, b, c, d, e)                                              \
-	fx_type_id_init(&type_info->t_id, a, b, c, d, e)
+	fx_type_id_init(&type_info->ty_id, a, b, c, d, e)
+#define FX_TYPE_NAME(n) type_info->ty_name = (n)
 #define FX_TYPE_EXTENDS(parent_id)                                             \
-	fx_type_id_copy(parent_id, &type_info->t_parent_id)
+	fx_type_id_copy(parent_id, &type_info->ty_parent_id)
 #define FX_TYPE_IMPLEMENTS(interface_id)                                       \
 	fx_type_id_copy(                                                       \
 		interface_id,                                                  \
-		&type_info->t_interfaces[type_info->t_nr_interfaces++])
+		&type_info->ty_interfaces[type_info->ty_nr_interfaces++])
 #define FX_TYPE_CLASS(class_struct)                                            \
-	type_info->t_class_size = sizeof(class_struct)
-#define FX_TYPE_FLAGS(flags)        type_info->t_flags = (flags)
-#define FX_TYPE_INSTANCE_INIT(func) type_info->t_instance_init = (func)
-#define FX_TYPE_INSTANCE_FINI(func) type_info->t_instance_fini = (func)
-
-#if 0
-#define FX_TYPE_VTABLE_BEGIN(vtable_struct, interface_id)                      \
-	vtable_struct __FX_IFACE_I1(iface, __LINE__) = {0};                    \
-	{                                                                      \
-		vtable_struct *iface = &__FX_IFACE_I1(iface, __LINE__);        \
-		type_info->t_vtables[nr_vtables].v_vtable = iface;             \
-		type_info->t_vtables[nr_vtables].v_interface_id                \
-			= interface_id;                                        \
-		nr_vtables++;
-#define FX_TYPE_VTABLE_END(vtable_struct, interface_id) }
-#endif
+	type_info->ty_class_private_size = sizeof(class_struct)
+#define FX_TYPE_FLAGS(flags)        type_info->ty_flags = (flags)
+#define FX_TYPE_INSTANCE_INIT(func) type_info->ty_instance_init = (func)
+#define FX_TYPE_INSTANCE_FINI(func) type_info->ty_instance_fini = (func)
 
 #define FX_TYPE_INSTANCE_PRIVATE(instance_struct)                              \
-	type_info->t_instance_private_size = sizeof(instance_struct)
+	type_info->ty_instance_private_size = sizeof(instance_struct)
 #define FX_TYPE_INSTANCE_PROTECTED(instance_struct)                            \
-	type_info->t_instance_protected_size = sizeof(instance_struct)
+	type_info->ty_instance_protected_size = sizeof(instance_struct)
 
 /* Type declaration macros (for use in .h header file) */
 
@@ -135,8 +176,9 @@
 	object,                                                                \
 	...)                                                                   \
 	do {                                                                   \
-		type_name##_class *iface                                       \
-			= fx_object_get_interface(object, type_id);            \
+		type_name##_class *iface = fx_object_get_interface(            \
+			object,                                                \
+			type_id);                                              \
 		if (iface && iface->func) {                                    \
 			return iface->func(object, __VA_ARGS__);               \
 		} else {                                                       \
@@ -150,8 +192,9 @@
 	func,                                                                  \
 	object)                                                                \
 	do {                                                                   \
-		type_name##_class *iface                                       \
-			= fx_object_get_interface(object, type_id);            \
+		type_name##_class *iface = fx_object_get_interface(            \
+			object,                                                \
+			type_id);                                              \
 		if (iface && iface->func) {                                    \
 			return iface->func(object);                            \
 		} else {                                                       \
@@ -160,8 +203,9 @@
 	} while (0)
 #define FX_CLASS_DISPATCH_VIRTUAL_V(type_name, type_id, func, object, ...)     \
 	do {                                                                   \
-		type_name##_class *iface                                       \
-			= fx_object_get_interface(object, type_id);            \
+		type_name##_class *iface = fx_object_get_interface(            \
+			object,                                                \
+			type_id);                                              \
 		if (iface && iface->func) {                                    \
 			iface->func(object, __VA_ARGS__);                      \
 			return;                                                \
@@ -169,8 +213,9 @@
 	} while (0)
 #define FX_CLASS_DISPATCH_VIRTUAL_V0(type_name, type_id, func, object)         \
 	do {                                                                   \
-		type_name##_class *iface                                       \
-			= fx_object_get_interface(object, type_id);            \
+		type_name##_class *iface = fx_object_get_interface(            \
+			object,                                                \
+			type_id);                                              \
 		if (iface && iface->func) {                                    \
 			iface->func(object);                                   \
 			return;                                                \
@@ -200,23 +245,27 @@
 		func_name(priv);                                               \
 	} while (0)
 
-#define FX_ASSEMBLY_BEGIN()                                                    \
-	const fx_assembly *__fx_assembly_get(void)                             \
+#define FX_ASSEMBLY_BEGIN(id)                                                  \
+	const fx_assembly *id##_assembly_get(void)                             \
 	{                                                                      \
 		static fx_assembly *self = NULL;                               \
 		if (self) {                                                    \
 			return self;                                           \
 		}                                                              \
 		self = fx_assembly_create();
-#define FX_ASSEMBLY_END()                                                      \
-	fx_assembly_dump(self);                                                \
+#define FX_ASSEMBLY_END(id)                                                    \
 	return self;                                                           \
+	}                                                                      \
+	const fx_assembly *__fx_assembly_get(void)                             \
+	{                                                                      \
+		return id##_assembly_get();                                    \
 	}
+
 #define FX_ASSEMBLY_NAME(name) fx_assembly_set_name(self, name)
 #define FX_ASSEMBLY_VERSION(major, minor, build, revision)                     \
 	fx_assembly_set_version(self, major, minor, build, revision)
 #define FX_ASSEMBLY_EXPORT_TYPE(namespace_name, type_name, type_id)            \
-	extern fx_type type_id##_get_type(void);                               \
+	extern fx_type_id type_id##_get_type(void);                            \
 	fx_assembly_add_type(                                                  \
 		self,                                                          \
 		namespace_name "." type_name,                                  \

fx/include/fx/namemap.h

@@ -0,0 +1,48 @@
+#ifndef FX_NAMEMAP_H_
+#define FX_NAMEMAP_H_
+
+#include <fx/bst.h>
+#include <fx/misc.h>
+#include <fx/queue.h>
+
+#define FX_NAMEMAP_INIT ((fx_namemap) {0})
+
+typedef struct fx_namemap {
+	fx_bst m_entries;
+} fx_namemap;
+
+struct __fx_namemap_entry {
+	int e_flags;
+	uint64_t e_hash;
+	void *e_bucket;
+	union {
+		fx_queue_entry e_entry;
+		fx_bst_node e_node;
+	};
+};
+
+typedef struct fx_namemap_entry {
+	struct __fx_namemap_entry e_opaque;
+	const char *e_name;
+} fx_namemap_entry;
+
+FX_API fx_status fx_namemap_cleanup(fx_namemap *map);
+
+FX_API fx_status
+fx_namemap_put(fx_namemap *map, const char *name, fx_namemap_entry *entry);
+
+FX_API fx_namemap_entry *fx_namemap_get(
+	const fx_namemap *map,
+	const char *name);
+
+FX_API fx_namemap_entry *fx_namemap_first(const fx_namemap *map);
+FX_API fx_namemap_entry *fx_namemap_last(const fx_namemap *map);
+
+FX_API fx_namemap_entry *fx_namemap_next(
+	const fx_namemap *map,
+	fx_namemap_entry *entry);
+FX_API fx_namemap_entry *fx_namemap_prev(
+	const fx_namemap *map,
+	fx_namemap_entry *entry);
+
+#endif

fx/include/fx/object.h

@@ -19,14 +19,14 @@ typedef struct _fx_object_class {
 	void (*to_string)(const fx_object *, FX_TYPE_FWDREF(fx_stream) *);
 } fx_object_class;
 
-FX_API fx_type fx_object_get_type(void);
+FX_API fx_type_id fx_object_get_type(void);
 
-FX_API void *fx_object_get_private(const fx_object *object, fx_type type);
-FX_API void *fx_object_get_protected(const fx_object *object, fx_type type);
-FX_API void *fx_object_get_interface(const fx_object *object, fx_type type);
+FX_API void *fx_object_get_private(const fx_object *object, fx_type_id type);
+FX_API void *fx_object_get_protected(const fx_object *object, fx_type_id type);
+FX_API void *fx_object_get_interface(const fx_object *object, fx_type_id type);
 FX_API fx_status fx_object_get_data(
 	const fx_object *object,
-	fx_type type,
+	fx_type_id type,
 	void **priv,
 	void **prot,
 	void **iface);
@@ -35,10 +35,10 @@ FX_API fx_object *fx_object_ref(fx_object *p);
 FX_API void fx_object_unref(fx_object *p);
 FX_API fx_object *fx_object_make_rvalue(fx_object *p);
 
-FX_API fx_object *fx_object_create(fx_type type);
+FX_API fx_object *fx_object_create(fx_type_id type);
 FX_API void fx_object_to_string(
 	const fx_object *p,
 	FX_TYPE_FWDREF(fx_stream) * out);
-FX_API bool fx_object_is_type(const fx_object *p, fx_type type);
+FX_API bool fx_object_is_type(const fx_object *p, fx_type_id type);
 
 #endif

fx/include/fx/queue.h

@@ -1,20 +1,13 @@
 #ifndef FX_CORE_QUEUE_H_
 #define FX_CORE_QUEUE_H_
 
-#include <fx/iterator.h>
-#include <fx/macros.h>
 #include <fx/status.h>
 #include <stdbool.h>
 #include <string.h>
 
-FX_DECLS_BEGIN;
-
-#define FX_TYPE_QUEUE_ITERATOR (fx_queue_iterator_get_type())
-
-FX_DECLARE_TYPE(fx_queue_iterator);
-
-FX_TYPE_CLASS_DECLARATION_BEGIN(fx_queue_iterator)
-FX_TYPE_CLASS_DECLARATION_END(fx_queue_iterator)
+#ifdef __cplusplus
+#define FX_DECLS_BEGIN extern "C" {
+#endif
 
 #define FX_QUEUE_INIT ((fx_queue) {.q_first = NULL, .q_last = NULL})
 #define FX_QUEUE_ENTRY_INIT                                                    \
@@ -56,8 +49,6 @@ static inline fx_queue_entry *fx_queue_prev(const fx_queue_entry *entry)
 	return entry ? entry->qe_prev : NULL;
 }
 
-FX_API fx_type fx_queue_iterator_get_type(void);
-
 FX_API size_t fx_queue_length(const fx_queue *q);
 
 FX_API void fx_queue_insert_before(
@@ -82,9 +73,8 @@ FX_API void fx_queue_move(
 FX_API void fx_queue_delete(fx_queue *q, fx_queue_entry *entry);
 FX_API void fx_queue_delete_all(fx_queue *q);
 
-FX_API fx_iterator *fx_queue_begin(fx_queue *q);
-FX_API fx_iterator *fx_queue_cbegin(const fx_queue *q);
-
-FX_DECLS_END;
+#ifdef __cplusplus
+}
+#endif
 
 #endif

fx/include/fx/ringbuffer.h

@@ -14,7 +14,7 @@ FX_DECLARE_TYPE(fx_ringbuffer);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_ringbuffer)
 FX_TYPE_CLASS_DECLARATION_END(fx_ringbuffer)
 
-FX_API fx_type fx_ringbuffer_get_type(void);
+FX_API fx_type_id fx_ringbuffer_get_type(void);
 
 FX_API fx_ringbuffer *fx_ringbuffer_create(size_t capacity);
 FX_API fx_ringbuffer *fx_ringbuffer_create_with_buffer(

fx/include/fx/stream.h

@@ -50,8 +50,8 @@ FX_TYPE_CLASS_DECLARATION_END(fx_stream)
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_stream_buffer)
 FX_TYPE_CLASS_DECLARATION_END(fx_stream_buffer)
 
-FX_API fx_type fx_stream_get_type();
-FX_API fx_type fx_stream_buffer_get_type();
+FX_API fx_type_id fx_stream_get_type();
+FX_API fx_type_id fx_stream_buffer_get_type();
 
 FX_API fx_stream *z__fx_stream_get_stdin(void);
 FX_API fx_stream *z__fx_stream_get_stdout(void);

fx/include/fx/string.h

@@ -40,8 +40,8 @@ typedef enum fx_string_tokenise_flags {
 	FX_STRING_TOK_F_INCLUDE_EMPTY_TOKENS = 0x01u,
 } fx_string_tokenise_flags;
 
-FX_API fx_type fx_string_get_type(void);
-FX_API fx_type fx_string_iterator_get_type(void);
+FX_API fx_type_id fx_string_get_type(void);
+FX_API fx_type_id fx_string_iterator_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_string, FX_TYPE_STRING);
 FX_API fx_string *fx_string_create_from_cstr(const char *s);

fx/include/fx/stringstream.h

@@ -16,7 +16,7 @@ FX_DECLARE_TYPE(fx_stringstream);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_stringstream)
 FX_TYPE_CLASS_DECLARATION_END(fx_stringstream)
 
-FX_API fx_type fx_stringstream_get_type(void);
+FX_API fx_type_id fx_stringstream_get_type(void);
 
 FX_API fx_stringstream *fx_stringstream_create(void);
 FX_API fx_stringstream *fx_stringstream_create_with_buffer(

fx/include/fx/type.h

@@ -1,8 +1,11 @@
 #ifndef FX_CORE_TYPE_H_
 #define FX_CORE_TYPE_H_
 
+#include <fx/bst.h>
 #include <fx/error.h>
 #include <fx/misc.h>
+#include <fx/namemap.h>
+#include <fx/queue.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ -11,60 +14,83 @@
 
 struct _fx_class;
 struct _fx_object;
+struct fx_type_info;
 
-typedef void (*fx_class_init_function)(struct _fx_class *, void *);
+typedef void (*fx_class_init_function)(
+	struct _fx_class *,
+	struct fx_type_info *,
+	void *);
 typedef void (*fx_instance_init_function)(struct _fx_object *, void *);
 typedef void (*fx_instance_fini_function)(struct _fx_object *, void *);
 
-typedef const union fx_type {
+typedef const union fx_type_id {
 	struct {
 		uint64_t p00, p01;
 	} a;
 
 	unsigned char b[16];
-} *fx_type;
+} *fx_type_id;
+
+typedef enum fx_type_category {
+	FX_TYPE_NONE = 0,
+	FX_TYPE_CLASS,
+	FX_TYPE_INTERFACE,
+} fx_type_category;
 
 typedef enum fx_type_flags {
 	FX_TYPE_F_ABSTRACT = 0x01u,
 } fx_type_flags;
 
 typedef struct fx_type_info {
-	union fx_type t_id;
-	union fx_type t_parent_id;
-	const char *t_name;
-	fx_type_flags t_flags;
-	union fx_type t_interfaces[FX_TYPE_MAX_INTERFACES];
-	size_t t_nr_interfaces;
-	size_t t_class_size;
-	fx_class_init_function t_class_init;
-	size_t t_instance_private_size;
-	size_t t_instance_protected_size;
-	fx_instance_init_function t_instance_init;
-	fx_instance_fini_function t_instance_fini;
+	union fx_type_id ty_id;
+	union fx_type_id ty_parent_id;
+	fx_type_category ty_category;
+	const char *ty_name;
+	fx_type_flags ty_flags;
+	union fx_type_id ty_interfaces[FX_TYPE_MAX_INTERFACES];
+	size_t ty_nr_interfaces;
+	fx_class_init_function ty_class_init;
+	size_t ty_instance_private_size;
+	size_t ty_instance_protected_size;
+	size_t ty_class_private_size;
+	fx_instance_init_function ty_instance_init;
+	fx_instance_fini_function ty_instance_fini;
+
+	struct fx_bst_node ty_idmap_node;
+	struct fx_namemap_entry ty_namemap_entry;
+	struct _fx_object *ty_metatype;
+	struct _fx_class *ty_class;
+	struct fx_bst ty_components;
+	struct fx_queue ty_class_hierarchy;
+	struct fx_namemap ty_functions;
+
+	size_t ty_instance_size, ty_class_size;
 } fx_type_info;
 
 FX_API void fx_type_id_init(
-	union fx_type *out,
+	union fx_type_id *out,
 	uint32_t a,
 	uint16_t b,
 	uint16_t c,
 	uint16_t d,
 	uint64_t e);
-static inline void fx_type_id_copy(fx_type src, union fx_type *dest)
+static inline void fx_type_id_copy(fx_type_id src, union fx_type_id *dest)
 {
 	dest->a.p00 = src->a.p00;
 	dest->a.p01 = src->a.p01;
 }
 
-static inline int fx_type_id_compare(fx_type a, fx_type b)
+static inline int fx_type_id_compare(fx_type_id a, fx_type_id b)
 {
 	if (a == b) {
 		return 0;
 	}
 
-	return memcmp(a, b, sizeof(union fx_type));
+	return memcmp(a, b, sizeof(union fx_type_id));
 }
 
 FX_API fx_result fx_type_register(fx_type_info *info);
+FX_API fx_result
+fx_type_add_function(fx_type_info *info, struct _fx_object *func);
 
 #endif

fx/include/fx/uint.h

@@ -12,7 +12,7 @@ FX_DECLARE_TYPE(fx_uint);
 FX_TYPE_CLASS_DECLARATION_BEGIN(fx_uint)
 FX_TYPE_CLASS_DECLARATION_END(fx_uint)
 
-FX_API fx_type fx_uint_get_type(void);
+FX_API fx_type_id fx_uint_get_type(void);
 
 FX_API fx_uint *fx_uint_create(uintptr_t value);
 FX_API fx_uint *fx_uint_create_nan(void);

fx/include/fx/uuid.h

@@ -24,7 +24,7 @@ typedef union fx_uuid_bytes {
 	uint64_t uuid_qwords[FX_UUID_NBYTES / 8];
 } fx_uuid_bytes;
 
-FX_API fx_type fx_uuid_get_type(void);
+FX_API fx_type_id fx_uuid_get_type(void);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_uuid, FX_TYPE_UUID);
 

fx/include/fx/value.h

@@ -46,14 +46,14 @@ typedef enum fx_value_type {
 	FX_VALUE_TYPE_CSTR,
 	FX_VALUE_TYPE_POINTER,
 
-	/* any value greater than this represents an object fx_type */
+	/* any value greater than this represents an object fx_type_id */
 	__FX_VALUE_TYPE_OBJECT_BOUNDARY = 1024,
 } fx_value_type;
 
 typedef struct fx_value {
 	union {
 		fx_value_type t_primitive;
-		fx_type t_object;
+		fx_type_id t_object;
 	} v_type;
 
 	union {
@@ -67,10 +67,14 @@ typedef struct fx_value {
 	};
 } fx_value;
 
-FX_API void fx_value_init(fx_value *v, fx_type type);
+FX_API void fx_value_init(fx_value *v, fx_type_id type);
 FX_API void fx_value_init_primitive(fx_value *v, fx_value_type type);
 
+FX_API void fx_value_copy(fx_value *dst, fx_value *src);
+FX_API void fx_value_copy_array(fx_value *dst, fx_value *src, size_t count);
+
 FX_API void fx_value_unset(fx_value *v);
+FX_API void fx_value_unset_array(fx_value *v, size_t length);
 
 FX_API void fx_value_set_bool(fx_value *v, bool b);
 FX_API void fx_value_set_int(fx_value *v, intptr_t i);
@@ -86,7 +90,7 @@ FX_API bool fx_value_is_uint(const fx_value *v);
 FX_API bool fx_value_is_double(const fx_value *v);
 FX_API bool fx_value_is_string(const fx_value *v);
 FX_API bool fx_value_is_pointer(const fx_value *v);
-FX_API bool fx_value_is_object(const fx_value *v, fx_type type);
+FX_API bool fx_value_is_object(const fx_value *v, fx_type_id type);
 
 FX_API bool fx_value_get_bool(const fx_value *v);
 FX_API intptr_t fx_value_get_int(const fx_value *v);

fx/include/fx/vector.h

@@ -0,0 +1,159 @@
+#ifndef FX_VECTOR_H_
+#define FX_VECTOR_H_
+
+#include <fx/misc.h>
+#include <fx/status.h>
+#include <stddef.h>
+
+typedef struct fx_vector_ops {
+	fx_status (*v_copy)(void *, const void *, size_t);
+	fx_status (*v_move)(void *, void *, size_t);
+	fx_status (*v_destroy)(void *);
+} fx_vector_ops;
+
+#define FX_VECTOR_DEFINE(type, name)                                           \
+	struct {                                                               \
+		size_t count;                                                  \
+		size_t max;                                                    \
+		type *items;                                                   \
+	} name = {0}
+
+#define FX_VECTOR_DECLARE(type, name)                                          \
+	struct {                                                               \
+		size_t count;                                                  \
+		size_t max;                                                    \
+		type *items;                                                   \
+	} name
+
+#define FX_VECTOR_ITEM(name, index)     name.items[index]
+#define FX_VECTOR_ITEM_PTR(name, index) &name.items[index]
+#define FX_VECTOR_COUNT(name)           name.count
+#define FX_VECTOR_MAX(name)             name.max
+
+/* use this macros in your function prototype, to allow the function to accept
+ * a reference to a vector as a parameter */
+#define FX_VECTOR_REF_PARAM(type, name)                                        \
+	type **name, size_t *name##_count, size_t *name##_max
+/* use this macro to pass a reference to a vector as a parameter to a function
+ * whose prototype uses FX_VECTOR_REF_PARAM */
+#define FX_VECTOR_REF(name)  &(name.items), &(name.count), &(name.max)
+/* use this macro to forward your reference to a vector (which you got via
+ * FX_VECTOR_REF_PARAM in your function prototype), to another function whose
+ * prototype also uses FX_VECTOR_REF_PARAM */
+#define FX_VECTOR_REF2(name) name, name##_count, name##_max
+
+/* use these functions if you're accessing a vector directly. */
+#define fx_vector_push_back(vector, ptr, ops)                                  \
+	__fx_vector_push_back(                                                 \
+		(void **)&(vector.items),                                      \
+		ptr,                                                           \
+		sizeof *ptr,                                                   \
+		&(vector.count),                                               \
+		&(vector.max),                                                 \
+		ops)
+#define fx_vector_pop_back(vector, ops)                                        \
+	__fx_vector_pop_back(                                                  \
+		(void **)&(vector.items),                                      \
+		sizeof *vector.items,                                          \
+		&(vector.count),                                               \
+		&(vector.max),                                                 \
+		ops)
+#define fx_vector_emplace_back(vector, ops)                                    \
+	__fx_vector_emplace_back(                                              \
+		(void **)&(vector.items),                                      \
+		sizeof *vector.items,                                          \
+		&(vector.count),                                               \
+		&(vector.max),                                                 \
+		ops)
+#define fx_vector_trim(vector, ops)                                            \
+	__fx_vector_trim(                                                      \
+		(void **)&(vector.items),                                      \
+		sizeof *vector.items,                                          \
+		&(vector.count),                                               \
+		&(vector.max),                                                 \
+		ops)
+#define fx_vector_destroy(vector, ops)                                         \
+	__fx_vector_destroy(                                                   \
+		(void **)&(vector.items),                                      \
+		sizeof *vector.items,                                          \
+		&(vector.count),                                               \
+		&(vector.max),                                                 \
+		ops)
+
+/* use these functions if you're accessing a vector as a reference
+ * via FX_VECTOR_REF_PARAM. */
+#define fx_vector_ref_push_back(vector, ptr, ops)                              \
+	__fx_vector_push_back(                                                 \
+		(void **)(vector),                                             \
+		ptr,                                                           \
+		sizeof *ptr,                                                   \
+		(vector##_count),                                              \
+		(vector##_max),                                                \
+		ops)
+#define fx_vector_ref_pop_back(vector, ops)                                    \
+	__fx_vector_pop_back(                                                  \
+		(void **)(vector),                                             \
+		sizeof **vector,                                               \
+		(vector##_count),                                              \
+		(vector##_max),                                                \
+		ops)
+#define fx_vector_ref_emplace_back(vector, ops)                                \
+	__fx_vector_emplace_back(                                              \
+		(void **)(vector),                                             \
+		sizeof **vector,                                               \
+		(vector##_count),                                              \
+		(vector##_max),                                                \
+		ops)
+#define fx_vector_ref_trim(vector, ops)                                        \
+	__fx_vector_trim(                                                      \
+		(void **)(vector),                                             \
+		sizeof **vector,                                               \
+		(vector##_count),                                              \
+		(vector##_max),                                                \
+		ops)
+#define fx_vector_ref_destroy(vector, ops)                                     \
+	__fx_vector_destroy(                                                   \
+		(void **)(vector),                                             \
+		sizeof **vector,                                               \
+		(vector##_count),                                              \
+		(vector##_max),                                                \
+		ops)
+#define fx_vector_ref_get_item(vector, index)     (*vector)[index]
+#define fx_vector_ref_get_item_ptr(vector, index) (&(*vector)[index])
+#define fx_vector_ref_get_count(vector)           *(vector##_count)
+#define fx_vector_ref_get_max(vector)             *(vector##_count)
+
+/* don't use these functions */
+FX_API int __fx_vector_push_back(
+	void **vector,
+	const void *item,
+	size_t item_size,
+	size_t *count,
+	size_t *max,
+	const struct fx_vector_ops *ops);
+FX_API void __fx_vector_pop_back(
+	void **vector,
+	size_t item_size,
+	size_t *count,
+	size_t *max,
+	const struct fx_vector_ops *ops);
+FX_API void *__fx_vector_emplace_back(
+	void **vector,
+	size_t item_size,
+	size_t *count,
+	size_t *max,
+	const struct fx_vector_ops *ops);
+FX_API void __fx_vector_trim(
+	void **vector,
+	size_t item_size,
+	size_t *count,
+	size_t *max,
+	const struct fx_vector_ops *ops);
+FX_API void __fx_vector_destroy(
+	void **vector,
+	size_t item_size,
+	size_t *count,
+	size_t *max,
+	const struct fx_vector_ops *ops);
+
+#endif

fx/int.c

@@ -257,11 +257,11 @@ static void int_to_string(const fx_object *obj, fx_stream *out)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_int)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_int)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = int_to_string;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_int)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_int)
 
 FX_TYPE_DEFINITION_BEGIN(fx_int)
 	FX_TYPE_ID(0x3b20f57a, 0x2ddf, 0x4682, 0x81c4, 0x4fe404a6524e);

fx/iterator.c

@@ -61,8 +61,9 @@ enum fx_status fx_iterator_move_next(const fx_iterator *it)
 {
 	enum fx_status status = FX_ERR_NOT_SUPPORTED;
 
-	fx_iterator_class *iface
-		= fx_object_get_interface(it, FX_TYPE_ITERATOR);
+	fx_iterator_class *iface = fx_object_get_interface(
+		it,
+		FX_TYPE_ITERATOR);
 	if (iface && iface->it_move_next) {
 		status = iface->it_move_next(it);
 	}
@@ -97,8 +98,9 @@ fx_status fx_iterator_erase(fx_iterator *it)
 {
 	enum fx_status status = FX_ERR_NOT_SUPPORTED;
 
-	fx_iterator_class *iface
-		= fx_object_get_interface(it, FX_TYPE_ITERATOR);
+	fx_iterator_class *iface = fx_object_get_interface(
+		it,
+		FX_TYPE_ITERATOR);
 	if (iface && iface->it_erase) {
 		status = iface->it_erase(it);
 	}
@@ -112,28 +114,30 @@ fx_status fx_iterator_erase(fx_iterator *it)
 /*** CLASS DEFINITION *********************************************************/
 
 // ---- fx_iterator DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_iterator)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_iterator)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_iterator)
 
 FX_TYPE_DEFINITION_BEGIN(fx_iterator)
 	FX_TYPE_FLAGS(FX_TYPE_F_ABSTRACT);
 	FX_TYPE_ID(0xfd40b67f, 0x7087, 0x40a9, 0x8fd8, 0x8ae27bd58c9e);
+	FX_TYPE_NAME("fx.iterator");
 	FX_TYPE_CLASS(fx_iterator_class);
 	FX_TYPE_INSTANCE_PRIVATE(struct fx_iterator_p);
 FX_TYPE_DEFINITION_END(fx_iterator)
 
 // ---- fx_iterable DEFINITION
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_iterable)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_iterable)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_iterable)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_iterable)
 
 FX_TYPE_DEFINITION_BEGIN(fx_iterable)
 	FX_TYPE_FLAGS(FX_TYPE_F_ABSTRACT);
 	FX_TYPE_ID(0x4bbabf2d, 0xfc5d, 0x40cc, 0x89fc, 0x164085e47f73);
+	FX_TYPE_NAME("fx.iterable");
 	FX_TYPE_CLASS(fx_iterable_class);
 FX_TYPE_DEFINITION_END(fx_iterable)

fx/namemap.c

@@ -0,0 +1,257 @@
+#include <fx/hash.h>
+#include <fx/namemap.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum map_entry_type {
+	MAP_ENTRY_NONE = 0,
+	MAP_ENTRY_ITEM,
+	MAP_ENTRY_BUCKET,
+};
+
+static FX_BST_DEFINE_SIMPLE_GET(
+	struct __fx_namemap_entry,
+	uint64_t,
+	e_node,
+	e_hash,
+	map_get_entry);
+static FX_BST_DEFINE_SIMPLE_INSERT(
+	struct __fx_namemap_entry,
+	e_node,
+	e_hash,
+	map_put_entry);
+
+struct map_bucket {
+	struct __fx_namemap_entry b_entry;
+	fx_queue b_items;
+};
+
+static struct map_bucket *map_item_convert_to_bucket(
+	struct fx_namemap *map,
+	struct fx_namemap_entry *item)
+{
+	struct map_bucket *bucket = malloc(sizeof *bucket);
+
+	memset(bucket, 0x0, sizeof *bucket);
+
+	bucket->b_entry.e_hash = item->e_opaque.e_hash;
+	bucket->b_entry.e_flags = MAP_ENTRY_BUCKET;
+
+	fx_bst_delete(&map->m_entries, &item->e_opaque.e_node);
+	fx_queue_push_back(&bucket->b_items, &item->e_opaque.e_entry);
+	item->e_opaque.e_bucket = bucket;
+	map_put_entry(&map->m_entries, &bucket->b_entry);
+
+	return bucket;
+}
+
+enum fx_status fx_namemap_cleanup(struct fx_namemap *map)
+{
+	return FX_SUCCESS;
+}
+
+enum fx_status fx_namemap_put(
+	struct fx_namemap *map,
+	const char *name,
+	struct fx_namemap_entry *new_item)
+{
+	uint64_t hash = fx_hash_cstr(name);
+
+	new_item->e_opaque.e_flags = MAP_ENTRY_ITEM;
+	new_item->e_opaque.e_hash = hash;
+	new_item->e_name = name;
+
+	struct __fx_namemap_entry *entry = map_get_entry(&map->m_entries, hash);
+	if (!entry) {
+		map_put_entry(&map->m_entries, &new_item->e_opaque);
+		return FX_SUCCESS;
+	}
+
+	struct fx_namemap_entry *existing_item = NULL;
+	struct map_bucket *bucket = NULL;
+	switch (entry->e_flags) {
+	case MAP_ENTRY_ITEM:
+		existing_item = (struct fx_namemap_entry *)entry;
+		bucket = map_item_convert_to_bucket(map, existing_item);
+		new_item->e_opaque.e_bucket = bucket;
+		fx_queue_push_back(
+			&bucket->b_items,
+			&new_item->e_opaque.e_entry);
+		break;
+	case MAP_ENTRY_BUCKET:
+		bucket = (struct map_bucket *)entry;
+		new_item->e_opaque.e_bucket = bucket;
+		fx_queue_push_back(
+			&bucket->b_items,
+			&new_item->e_opaque.e_entry);
+		break;
+	default:
+		break;
+	}
+
+	return FX_SUCCESS;
+}
+
+fx_namemap_entry *fx_namemap_get(const fx_namemap *map, const char *name)
+{
+	uint64_t hash = fx_hash_cstr(name);
+	struct __fx_namemap_entry *entry = map_get_entry(&map->m_entries, hash);
+	if (!entry) {
+		return NULL;
+	}
+
+	struct fx_namemap_entry *item = NULL;
+	struct map_bucket *bucket = NULL;
+	struct fx_queue_entry *cur = NULL;
+
+	switch (entry->e_flags) {
+	case MAP_ENTRY_ITEM:
+		item = (struct fx_namemap_entry *)entry;
+		if (!strcmp(item->e_name, name)) {
+			return item;
+		}
+
+		break;
+	case MAP_ENTRY_BUCKET:
+		bucket = (struct map_bucket *)entry;
+		cur = fx_queue_first(&bucket->b_items);
+		while (cur) {
+			entry = fx_unbox(
+				struct __fx_namemap_entry,
+				cur,
+				e_entry);
+			item = (struct fx_namemap_entry *)entry;
+			if (!strcmp(item->e_name, name)) {
+				return item;
+			}
+			cur = fx_queue_next(cur);
+		}
+		break;
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+struct fx_namemap_entry *fx_namemap_first(const struct fx_namemap *map)
+{
+	struct fx_bst_node *first = fx_bst_first(&map->m_entries);
+	struct __fx_namemap_entry *entry = fx_unbox(
+		struct __fx_namemap_entry,
+		first,
+		e_node);
+	if (entry->e_flags == MAP_ENTRY_ITEM) {
+		return (struct fx_namemap_entry *)entry;
+	}
+
+	struct map_bucket *bucket = (struct map_bucket *)entry;
+	struct fx_queue_entry *first_entry = fx_queue_first(&bucket->b_items);
+	return (struct fx_namemap_entry *)
+		fx_unbox(struct __fx_namemap_entry, first_entry, e_entry);
+}
+
+struct fx_namemap_entry *fx_namemap_last(const struct fx_namemap *map)
+{
+	struct fx_bst_node *last = fx_bst_last(&map->m_entries);
+	struct __fx_namemap_entry *entry = fx_unbox(
+		struct __fx_namemap_entry,
+		last,
+		e_node);
+	if (entry->e_flags == MAP_ENTRY_ITEM) {
+		return (struct fx_namemap_entry *)entry;
+	}
+
+	struct map_bucket *bucket = (struct map_bucket *)entry;
+	struct fx_queue_entry *last_entry = fx_queue_last(&bucket->b_items);
+	return (struct fx_namemap_entry *)
+		fx_unbox(struct __fx_namemap_entry, last_entry, e_entry);
+}
+
+struct fx_namemap_entry *fx_namemap_next(
+	const struct fx_namemap *map,
+	struct fx_namemap_entry *entry)
+{
+	struct map_bucket *bucket = entry->e_opaque.e_bucket;
+	struct __fx_namemap_entry *next_entry = NULL;
+	if (bucket) {
+		struct fx_queue_entry *q_entry = fx_queue_next(
+			&entry->e_opaque.e_entry);
+		if (!q_entry) {
+			struct fx_bst_node *node = fx_bst_next(
+				&bucket->b_entry.e_node);
+			next_entry = fx_unbox(
+				struct __fx_namemap_entry,
+				node,
+				e_node);
+		} else {
+			next_entry = fx_unbox(
+				struct __fx_namemap_entry,
+				q_entry,
+				e_entry);
+		}
+	} else {
+		struct fx_bst_node *node = fx_bst_next(&entry->e_opaque.e_node);
+		next_entry = fx_unbox(struct __fx_namemap_entry, node, e_node);
+	}
+
+	if (!next_entry) {
+		return NULL;
+	}
+
+	if (next_entry->e_flags == MAP_ENTRY_BUCKET) {
+		bucket = (struct map_bucket *)next_entry;
+		struct fx_queue_entry *q_entry = fx_queue_first(
+			&bucket->b_items);
+		next_entry = fx_unbox(
+			struct __fx_namemap_entry,
+			q_entry,
+			e_entry);
+	}
+
+	return (struct fx_namemap_entry *)next_entry;
+}
+
+struct fx_namemap_entry *fx_namemap_prev(
+	const struct fx_namemap *map,
+	struct fx_namemap_entry *entry)
+{
+	struct map_bucket *bucket = entry->e_opaque.e_bucket;
+	struct __fx_namemap_entry *prev_entry = NULL;
+	if (bucket) {
+		struct fx_queue_entry *q_entry = fx_queue_prev(
+			&entry->e_opaque.e_entry);
+		if (!q_entry) {
+			struct fx_bst_node *node = fx_bst_prev(
+				&bucket->b_entry.e_node);
+			prev_entry = fx_unbox(
+				struct __fx_namemap_entry,
+				node,
+				e_node);
+		} else {
+			prev_entry = fx_unbox(
+				struct __fx_namemap_entry,
+				q_entry,
+				e_entry);
+		}
+	} else {
+		struct fx_bst_node *node = fx_bst_prev(&entry->e_opaque.e_node);
+		prev_entry = fx_unbox(struct __fx_namemap_entry, node, e_node);
+	}
+
+	if (!prev_entry) {
+		return NULL;
+	}
+
+	if (prev_entry->e_flags == MAP_ENTRY_BUCKET) {
+		bucket = (struct map_bucket *)prev_entry;
+		struct fx_queue_entry *q_entry = fx_queue_last(
+			&bucket->b_items);
+		prev_entry = fx_unbox(
+			struct __fx_namemap_entry,
+			q_entry,
+			e_entry);
+	}
+
+	return (struct fx_namemap_entry *)prev_entry;
+}

fx/object.c

@@ -9,42 +9,46 @@
 #include <fx/stream.h>
 #include <fx/thread.h>
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_object)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_object)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_object)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_object)
 
 FX_TYPE_DEFINITION_BEGIN(fx_object)
 	FX_TYPE_ID(0x45f15a2c, 0x6831, 0x4bef, 0xb350, 0x15c650679211);
+	FX_TYPE_NAME("fx.object");
 	FX_TYPE_CLASS(fx_object_class);
 FX_TYPE_DEFINITION_END(fx_object)
 
 fx_result fx_object_instantiate(
-	struct fx_type_registration *type,
+	struct fx_type_info *type,
 	struct _fx_object **out_object)
 {
-	struct _fx_object *out = malloc(type->r_instance_size);
+	struct _fx_object *out = malloc(type->ty_instance_size);
 	if (!out) {
 		return FX_RESULT_ERR(NO_MEMORY);
 	}
 
-	memset(out, 0x0, type->r_instance_size);
+	memset(out, 0x0, type->ty_instance_size);
 
 	out->obj_magic = FX_OBJECT_MAGIC;
 	out->obj_type = type;
 	out->obj_ref = 1;
 
-	struct fx_queue_entry *entry = fx_queue_first(&type->r_class_hierarchy);
+	struct fx_queue_entry *entry = fx_queue_first(
+		&type->ty_class_hierarchy);
 	while (entry) {
-		struct fx_type_component *comp
-			= fx_unbox(struct fx_type_component, entry, c_entry);
-		const struct fx_type_info *class_info = comp->c_type->r_info;
-		void *private_data
-			= (char *)out + comp->c_instance_private_data_offset;
+		struct fx_type_component *comp = fx_unbox(
+			struct fx_type_component,
+			entry,
+			c_entry);
+		const struct fx_type_info *class_info = comp->c_type;
+		void *private_data = (char *)out
+		                   + comp->c_instance_private_data_offset;
 
-		if (class_info->t_instance_init) {
-			class_info->t_instance_init(out, private_data);
+		if (class_info->ty_instance_init) {
+			class_info->ty_instance_init(out, private_data);
 		}
 
 		if (comp->c_type == type) {
@@ -59,9 +63,9 @@ fx_result fx_object_instantiate(
 	return FX_RESULT_SUCCESS;
 }
 
-struct _fx_object *fx_object_create(fx_type type)
+struct _fx_object *fx_object_create(fx_type_id type)
 {
-	struct fx_type_registration *type_reg = fx_type_get_registration(type);
+	struct fx_type_info *type_reg = fx_type_info_get_by_id(type);
 	if (!type_reg) {
 		return NULL;
 	}
@@ -84,27 +88,23 @@ void fx_object_to_string(const struct _fx_object *p, fx_stream *out)
 		to_string,
 		p,
 		out);
-	fx_stream_write_fmt(
-		out,
-		NULL,
-		"<%s@%p>",
-		p->obj_type->r_info->t_name,
-		p);
+	fx_stream_write_fmt(out, NULL, "<%s@%p>", p->obj_type->ty_name, p);
 }
 
-bool fx_object_is_type(const struct _fx_object *p, fx_type type)
+bool fx_object_is_type(const struct _fx_object *p, fx_type_id type)
 {
-	if (fx_type_id_compare(&p->obj_type->r_info->t_id, type) == 0) {
+	if (fx_type_id_compare(&p->obj_type->ty_id, type) == 0) {
 		return true;
 	}
 
-	struct fx_type_component *comp
-		= fx_type_get_component(&p->obj_type->r_components, type);
+	struct fx_type_component *comp = fx_type_get_component(
+		&p->obj_type->ty_components,
+		type);
 
 	return comp != NULL;
 }
 
-void *fx_object_get_private(const struct _fx_object *object, fx_type type)
+void *fx_object_get_private(const struct _fx_object *object, fx_type_id type)
 {
 	if (!object) {
 		return NULL;
@@ -112,12 +112,13 @@ void *fx_object_get_private(const struct _fx_object *object, fx_type type)
 
 	assert(object->obj_magic == FX_OBJECT_MAGIC);
 
-	if (fx_type_id_compare(&object->obj_type->r_info->t_id, type) == 0) {
+	if (fx_type_id_compare(&object->obj_type->ty_id, type) == 0) {
 		return (char *)object + object->obj_main_priv_offset;
 	}
 
-	struct fx_type_component *comp
-		= fx_type_get_component(&object->obj_type->r_components, type);
+	struct fx_type_component *comp = fx_type_get_component(
+		&object->obj_type->ty_components,
+		type);
 	if (!comp) {
 		return NULL;
 	}
@@ -125,7 +126,7 @@ void *fx_object_get_private(const struct _fx_object *object, fx_type type)
 	return (char *)object + comp->c_instance_private_data_offset;
 }
 
-void *fx_object_get_protected(const struct _fx_object *object, fx_type type)
+void *fx_object_get_protected(const struct _fx_object *object, fx_type_id type)
 {
 	if (!object) {
 		return NULL;
@@ -133,8 +134,9 @@ void *fx_object_get_protected(const struct _fx_object *object, fx_type type)
 
 	assert(object->obj_magic == FX_OBJECT_MAGIC);
 
-	struct fx_type_component *comp
-		= fx_type_get_component(&object->obj_type->r_components, type);
+	struct fx_type_component *comp = fx_type_get_component(
+		&object->obj_type->ty_components,
+		type);
 	if (!comp) {
 		return NULL;
 	}
@@ -142,7 +144,7 @@ void *fx_object_get_protected(const struct _fx_object *object, fx_type type)
 	return (char *)object + comp->c_instance_protected_data_offset;
 }
 
-void *fx_object_get_interface(const struct _fx_object *object, fx_type type)
+void *fx_object_get_interface(const struct _fx_object *object, fx_type_id type)
 {
 	if (!object) {
 		return NULL;
@@ -150,12 +152,12 @@ void *fx_object_get_interface(const struct _fx_object *object, fx_type type)
 
 	assert(object->obj_magic == FX_OBJECT_MAGIC);
 
-	return fx_class_get_interface(object->obj_type->r_class, type);
+	return fx_class_get_interface(object->obj_type->ty_class, type);
 }
 
 enum fx_status fx_object_get_data(
 	const struct _fx_object *object,
-	fx_type type,
+	fx_type_id type,
 	void **priv,
 	void **prot,
 	void **iface)
@@ -166,8 +168,9 @@ enum fx_status fx_object_get_data(
 
 	assert(object->obj_magic == FX_OBJECT_MAGIC);
 
-	struct fx_type_component *comp
-		= fx_type_get_component(&object->obj_type->r_components, type);
+	struct fx_type_component *comp = fx_type_get_component(
+		&object->obj_type->ty_components,
+		type);
 	if (!comp) {
 		return FX_ERR_INVALID_ARGUMENT;
 	}
@@ -181,7 +184,7 @@ enum fx_status fx_object_get_data(
 	}
 
 	if (iface) {
-		*iface = (char *)object->obj_type->r_class
+		*iface = (char *)object->obj_type->ty_class
 		       + comp->c_class_data_offset;
 	}
 
@@ -202,19 +205,21 @@ void fx_object_unref(struct _fx_object *p)
 	}
 
 	p->obj_ref = 0;
-	const struct fx_type_registration *type = p->obj_type;
+	const struct fx_type_info *type = p->obj_type;
 
-	struct fx_queue_entry *cur = fx_queue_last(&type->r_class_hierarchy);
+	struct fx_queue_entry *cur = fx_queue_last(&type->ty_class_hierarchy);
 	while (cur) {
-		struct fx_type_component *comp
-			= fx_unbox(struct fx_type_component, cur, c_entry);
+		struct fx_type_component *comp = fx_unbox(
+			struct fx_type_component,
+			cur,
+			c_entry);
 
-		const struct fx_type_info *class_info = comp->c_type->r_info;
-		void *private_data
-			= (char *)p + comp->c_instance_private_data_offset;
+		const struct fx_type_info *class_info = comp->c_type;
+		void *private_data = (char *)p
+		                   + comp->c_instance_private_data_offset;
 
-		if (class_info->t_instance_fini) {
-			class_info->t_instance_fini(p, private_data);
+		if (class_info->ty_instance_fini) {
+			class_info->ty_instance_fini(p, private_data);
 		}
 
 		cur = fx_queue_prev(cur);

fx/object.h

@@ -5,15 +5,16 @@
 #include <fx/misc.h>
 #include <stdint.h>
 
-struct fx_type_registration;
+struct fx_type_info;
 
 struct _fx_object {
 	uint64_t obj_magic;
-	const struct fx_type_registration *obj_type;
+	const struct fx_type_info *obj_type;
 	unsigned int obj_ref, obj_main_priv_offset;
 };
 
 extern fx_result fx_object_instantiate(
-	struct fx_type_registration *type, struct _fx_object **out);
+	struct fx_type_info *type,
+	struct _fx_object **out);
 
 #endif

fx/queue.c

@@ -1,11 +1,5 @@
 #include <fx/queue.h>
 
-struct fx_queue_iterator_p {
-	size_t i;
-	fx_queue_entry *entry;
-	fx_queue *_q;
-};
-
 size_t fx_queue_length(const struct fx_queue *q)
 {
 	size_t i = 0;
@@ -163,87 +157,3 @@ void fx_queue_delete_all(struct fx_queue *q)
 
 	q->q_first = q->q_last = NULL;
 }
-
-fx_iterator *fx_queue_begin(struct fx_queue *q)
-{
-	fx_queue_iterator *it_obj = fx_object_create(FX_TYPE_QUEUE_ITERATOR);
-	struct fx_queue_iterator_p *it
-		= fx_object_get_private(it_obj, FX_TYPE_QUEUE_ITERATOR);
-
-	it->_q = (struct fx_queue *)q;
-	it->entry = q->q_first;
-	it->i = 0;
-
-	if (!it->entry) {
-		fx_iterator_set_status(it_obj, FX_ERR_NO_DATA);
-	}
-
-	return it_obj;
-}
-
-static enum fx_status iterator_move_next(const fx_iterator *obj)
-{
-	struct fx_queue_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
-
-	if (!it->entry) {
-		return FX_ERR_NO_DATA;
-	}
-
-	it->entry = it->entry->qe_next;
-	it->i++;
-
-	return (it->entry != NULL) ? FX_SUCCESS : FX_ERR_NO_DATA;
-}
-
-static enum fx_status iterator_erase(fx_iterator *obj)
-{
-	struct fx_queue_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
-
-	if (!it->entry) {
-		return FX_ERR_OUT_OF_BOUNDS;
-	}
-
-	struct fx_queue_entry *next = it->entry->qe_next;
-	fx_queue_delete(it->_q, it->entry);
-	it->entry = next;
-
-	return FX_SUCCESS;
-}
-
-static fx_iterator_value iterator_get_value(fx_iterator *obj)
-{
-	struct fx_queue_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
-
-	return FX_ITERATOR_VALUE_PTR(it->entry);
-}
-
-static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
-{
-	struct fx_queue_iterator_p *it
-		= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
-
-	return FX_ITERATOR_VALUE_CPTR(it->entry);
-}
-
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_queue_iterator)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
-		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
-		FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
-		FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
-		FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
-		FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
-	FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
-FX_TYPE_CLASS_DEFINITION_END(fx_queue_iterator)
-
-FX_TYPE_DEFINITION_BEGIN(fx_queue_iterator)
-	FX_TYPE_ID(0x560dc263, 0xff98, 0x4812, 0x9b29, 0xa1218bd70881);
-	FX_TYPE_EXTENDS(FX_TYPE_ITERATOR);
-	FX_TYPE_CLASS(fx_queue_iterator_class);
-	FX_TYPE_INSTANCE_PRIVATE(struct fx_queue_iterator_p);
-FX_TYPE_DEFINITION_END(fx_queue_iterator)

fx/ringbuffer.c

@@ -485,11 +485,11 @@ static void ringbuffer_fini(fx_object *obj, void *priv)
 
 /*** CLASS DEFINITION *********************************************************/
 
-FX_TYPE_CLASS_DEFINITION_BEGIN(fx_ringbuffer)
-	FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_BEGIN(fx_ringbuffer)
+	FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
 		FX_INTERFACE_ENTRY(to_string) = NULL;
-	FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
-FX_TYPE_CLASS_DEFINITION_END(fx_ringbuffer)
+	FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
+FX_TYPE_CLASS_END(fx_ringbuffer)
 
 FX_TYPE_DEFINITION_BEGIN(fx_ringbuffer)
 	FX_TYPE_ID(0xb0493774, 0xef13, 0x4905, 0xa865, 0x1595607ccad9);