build: add module to handle querying platform details

.clang-format

@@ -1,7 +1,5 @@
 BasedOnStyle: WebKit
 IndentWidth: 8
----
-Language: ObjC
 DerivePointerAlignment: false
 PointerAlignment: Right
 ColumnLimit: 80
@@ -46,68 +44,12 @@ ReflowComments: true
 SpacesBeforeTrailingComments: 3
 TabWidth: 8
 UseTab: AlignWithSpaces
-PenaltyReturnTypeOnItsOwnLine: 1000000
-PenaltyExcessCharacter: 5
-PenaltyBreakOpenParenthesis: 5
-PenaltyBreakBeforeFirstCallParameter: 5
-PenaltyIndentedWhitespace: 0
-AttributeMacros:
-  - FX_API
-ForEachMacros:
-  - fx_btree_foreach
-  - fx_queue_foreach
-MacroBlockBegin: "FX_(TYPE|ASSEMBLY)_.*_BEGIN"
-MacroBlockEnd: "FX_(TYPE|ASSEMBLY)_.*_END"
----
-Language: Cpp
-DerivePointerAlignment: false
-PointerAlignment: Right
-ColumnLimit: 80
-AlignAfterOpenBracket: AlwaysBreak
-AlignConsecutiveAssignments: None
-AlignConsecutiveBitFields: None
-AlignConsecutiveDeclarations: None
-AlignConsecutiveMacros: AcrossEmptyLinesAndComments
-AlignEscapedNewlines: Right
-AlignOperands: AlignAfterOperator
-AlignTrailingComments: true
-AllowAllArgumentsOnNextLine: false
-AllowAllConstructorInitializersOnNextLine: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: Empty
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: false
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLambdasOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: true
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-ExperimentalAutoDetectBinPacking: false
-BitFieldColonSpacing: Both
-BreakBeforeBraces: Linux
-BreakBeforeBinaryOperators: All
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: BeforeComma
-BreakInheritanceList: BeforeComma
-BreakStringLiterals: true
-ContinuationIndentWidth: 8
-Cpp11BracedListStyle: true
-IncludeBlocks: Regroup
-SortIncludes: true
-IndentRequires: true
-NamespaceIndentation: Inner
-ReflowComments: true
-SpacesBeforeTrailingComments: 3
-TabWidth: 8
-UseTab: AlignWithSpaces
-PenaltyReturnTypeOnItsOwnLine: 1000000
-PenaltyExcessCharacter: 9999999
-PenaltyBreakOpenParenthesis: 5
-PenaltyBreakBeforeFirstCallParameter: 5
+BreakAfterReturnType: Automatic
+PenaltyBreakAssignment: 1000000
+PenaltyReturnTypeOnItsOwnLine: 100000000
+PenaltyExcessCharacter: 10000000
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakBeforeFirstCallParameter: 0
 PenaltyIndentedWhitespace: 0
 AttributeMacros:
   - FX_API

CMakeLists.txt

@@ -1,14 +1,18 @@
 cmake_minimum_required(VERSION 3.25)
-project(fx C)
+project(fx C ASM)
 
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
 include (TestBigEndian)
+include(Templates)
+include(Platform)
 
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_EXTENSIONS OFF)
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
+set(fx_source_root ${CMAKE_CURRENT_SOURCE_DIR})
+set(fx_build_root ${CMAKE_CURRENT_BINARY_DIR})
 file(GLOB _all_assemblies assemblies/*
 	LIST_DIRECTORIES TRUE)
 
@@ -31,19 +35,18 @@ endif ()
 
 message(STATUS "Floating point support: ${fx_enable_floating_point}")
 
-set(fx_system_name ${CMAKE_SYSTEM_NAME})
-string(TOLOWER ${fx_system_name} fx_system_name)
+get_platform_details(
+	SYSTEM fx_system_name
+	PROCESSOR fx_system_arch)
 
-message(STATUS "System name: ${fx_system_name}")
+message(STATUS "Target system: ${fx_system_name}-${fx_system_arch}")
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
 
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Templates.cmake)
-
 foreach (assembly ${fx_assemblies})
 	add_subdirectory(assemblies/${assembly})
 endforeach (assembly)
 
-add_executable(dynamic-test test/dynamic-test.c)
+add_subdirectory(test)

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/Platform.cmake

@@ -0,0 +1,36 @@
+function(get_platform_details)
+	set(options)
+	set(one_value_args SYSTEM PROCESSOR)
+	set(multi_value_args
+		NAMESPACES
+		DEPENDENCIES
+		LIBS)
+	cmake_parse_arguments(PARSE_ARGV 0 arg
+		"${options}"
+		"${one_value_args}"
+		"${multi_value_args}")
+
+	set(system_name "")
+
+	if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+		set(system_name "linux")
+	elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
+		set(system_name "apple")
+	elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
+		set(system_name "win32")
+	else ()
+		message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
+	endif ()
+
+	if ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
+		set(system_arch "amd64")
+	elseif ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "arm64")
+		set(system_arch "aarch64")
+	else ()
+		message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
+	endif ()
+
+	set(${arg_SYSTEM} ${system_name} PARENT_SCOPE)
+	set(${arg_PROCESSOR} ${system_arch} PARENT_SCOPE)
+endfunction (get_platform_details)
+

cmake/Templates.cmake

@@ -20,7 +20,7 @@ function(add_fx_assembly)
 	set(assembly_sources ${CMAKE_CURRENT_SOURCE_DIR}/assembly.c)
 
 	foreach (dir ${arg_NAMESPACES})
-		add_subdirectory(../../${dir} ../../namespaces/${dir})
+		add_subdirectory(${fx_source_root}/${dir} ${fx_build_root}/namespaces/${dir})
 		set(assembly_sources ${assembly_sources} ${namespace_sources})
 		set(assembly_include_paths ${assembly_include_paths} ${namespace_include_paths})
 	endforeach (dir)
@@ -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}")
 
@@ -80,7 +91,10 @@ macro(export_fx_namespace_details ns_name)
 
 	file(GLOB sys_sources
 		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/*.c
-		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/*.h)
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/*.h
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/${fx_system_arch}/*.c
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/${fx_system_arch}/*.h
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/${fx_system_arch}/*.S)
 	file(GLOB headers include/${namespace_path}/*.h)
 	set(namespace_sources
 		${namespace_sources}
@@ -89,8 +103,12 @@ macro(export_fx_namespace_details ns_name)
 		${sys_sources}
 		${headers}
 		PARENT_SCOPE)
+	set(internal_include_dirs
+		${internal_include_dirs}
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/include
+		${CMAKE_CURRENT_SOURCE_DIR}/sys/${fx_system_name}/${fx_system_arch}/include
+		PARENT_SCOPE)
 	set(internal_libs ${internal_libs} PARENT_SCOPE)
-	set(internal_include_dirs ${internal_include_dirs} PARENT_SCOPE)
 	set(internal_defines ${internal_defines} PARENT_SCOPE)
 endmacro(export_fx_namespace_details)
 

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

@@ -1,4 +1,5 @@
 #include <fx/collections/dict.h>
+#include <fx/hash.h>
 #include <fx/status.h>
 #include <fx/stream.h>
 #include <fx/string.h>
@@ -47,21 +48,6 @@ static FX_BST_DEFINE_SIMPLE_INSERT(
 	bk_hash,
 	put_bucket);
 
-uint64_t fx_cstr_hash(const char *s)
-{
-#define FNV1_OFFSET_BASIS 0xcbf29ce484222325
-#define FNV1_PRIME        0x100000001b3
-	uint64_t hash = FNV1_OFFSET_BASIS;
-	size_t i = 0;
-
-	for (i = 0; s[i]; i++) {
-		hash ^= s[i];
-		hash *= FNV1_PRIME;
-	}
-
-	return hash;
-}
-
 /*** PRIVATE FUNCTIONS ********************************************************/
 
 static struct fx_dict_bucket *create_bucket(void)
@@ -91,7 +77,7 @@ static fx_status dict_put(
 	const char *key,
 	fx_object *value)
 {
-	uint64_t hash = fx_cstr_hash(key);
+	uint64_t hash = fx_hash_cstr(key);
 	struct fx_dict_bucket *bucket = get_bucket(&dict->d_buckets, hash);
 	if (!bucket) {
 		bucket = create_bucket();
@@ -148,7 +134,7 @@ static fx_status dict_put_sk(
 
 static fx_object *dict_at(const struct fx_dict_p *dict, const char *key)
 {
-	uint64_t hash = fx_cstr_hash(key);
+	uint64_t hash = fx_hash_cstr(key);
 	struct fx_dict_bucket *bucket = get_bucket(&dict->d_buckets, hash);
 	if (!bucket) {
 		return NULL;
@@ -704,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);
@@ -725,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/number.h

@@ -1,256 +0,0 @@
-#ifndef FX_DS_NUMBER_H
-#define FX_DS_NUMBER_H
-
-#include <fx/macros.h>
-#include <stdbool.h>
-
-FX_DECLS_BEGIN;
-
-#define FX_INT8(v)        (fx_number_create_int8(v))
-#define FX_INT16(v)       (fx_number_create_int16(v))
-#define FX_INT32(v)       (fx_number_create_int32(v))
-#define FX_INT64(v)       (fx_number_create_int64(v))
-#define FX_FLOAT32(v)     (fx_number_create_float32(v))
-#define FX_FLOAT64(v)     (fx_number_create_float64(v))
-#define FX_CHAR(v)        (fx_number_create_char(v))
-#define FX_SHORT(v)       (fx_number_create_short(v))
-#define FX_INT(v)         (fx_number_create_int(v))
-#define FX_LONG(v)        (fx_number_create_long(v))
-#define FX_LONGLONG(v)    (fx_number_create_longlong(v))
-#define FX_FLOAT(v)       (fx_number_create_float(v))
-#define FX_DOUBLE(v)      (fx_number_create_double(v))
-#define FX_SIZE_T(v)      (fx_number_create_size_t(v))
-
-#define FX_RV_INT8(v)     FX_RV(fx_number_create_int8(v))
-#define FX_RV_INT16(v)    FX_RV(fx_number_create_int16(v))
-#define FX_RV_INT32(v)    FX_RV(fx_number_create_int32(v))
-#define FX_RV_INT64(v)    FX_RV(fx_number_create_int64(v))
-#define FX_RV_FLOAT32(v)  FX_RV(fx_number_create_float32(v))
-#define FX_RV_FLOAT64(v)  FX_RV(fx_number_create_float64(v))
-#define FX_RV_CHAR(v)     FX_RV(fx_number_create_char(v))
-#define FX_RV_SHORT(v)    FX_RV(fx_number_create_short(v))
-#define FX_RV_INT(v)      FX_RV(fx_number_create_int(v))
-#define FX_RV_LONG(v)     FX_RV(fx_number_create_long(v))
-#define FX_RV_LONGLONG(v) FX_RV(fx_number_create_longlong(v))
-#define FX_RV_FLOAT(v)    FX_RV(fx_number_create_float(v))
-#define FX_RV_DOUBLE(v)   FX_RV(fx_number_create_double(v))
-#define FX_RV_SIZE_T(v)   FX_RV(fx_number_create_size_t(v))
-
-#define FX_NUMBER_IVAL(p) (fx_number_get_size_t(p))
-#define FX_NUMBER_FVAL(p) (fx_number_get_double(p))
-
-#define FX_TYPE_NUMBER    (fx_number_get_type())
-
-FX_DECLARE_TYPE(fx_number);
-
-FX_TYPE_CLASS_DECLARATION_BEGIN(fx_number)
-FX_TYPE_CLASS_DECLARATION_END(fx_number)
-
-typedef enum fx_number_type {
-	FX_NUMBER_INT8,
-	FX_NUMBER_INT16,
-	FX_NUMBER_INT32,
-	FX_NUMBER_INT64,
-	FX_NUMBER_FLOAT32,
-	FX_NUMBER_FLOAT64,
-	FX_NUMBER_CHAR,
-	FX_NUMBER_SHORT,
-	FX_NUMBER_INT,
-	FX_NUMBER_LONG,
-	FX_NUMBER_LONGLONG,
-	FX_NUMBER_FLOAT,
-	FX_NUMBER_DOUBLE,
-	FX_NUMBER_SIZE_T,
-	FX_NUMBER_HANDLE,
-	FX_NUMBER_TYPE_COUNT,
-
-	FX_NUMBER_BYTE = FX_NUMBER_INT8,
-	FX_NUMBER_WORD = FX_NUMBER_INT16,
-	FX_NUMBER_DWORD = FX_NUMBER_INT32,
-	FX_NUMBER_QWORD = FX_NUMBER_INT64,
-} fx_number_type;
-
-FX_API fx_type fx_number_get_type(void);
-
-FX_API fx_number *fx_number_create(fx_number_type type, void *value_ptr);
-
-static inline fx_number *fx_number_create_int8(int8_t value)
-{
-	return fx_number_create(FX_NUMBER_INT8, &value);
-}
-static inline fx_number *fx_number_create_int16(int16_t value)
-{
-	return fx_number_create(FX_NUMBER_INT16, &value);
-}
-static inline fx_number *fx_number_create_int32(int32_t value)
-{
-	return fx_number_create(FX_NUMBER_INT32, &value);
-}
-static inline fx_number *fx_number_create_int64(int64_t value)
-{
-	return fx_number_create(FX_NUMBER_INT64, &value);
-}
-static inline fx_number *fx_number_create_float32(float value)
-{
-	return fx_number_create(FX_NUMBER_FLOAT32, &value);
-}
-static inline fx_number *fx_number_create_float64(double value)
-{
-	return fx_number_create(FX_NUMBER_FLOAT64, &value);
-}
-static inline fx_number *fx_number_create_char(char value)
-{
-	return fx_number_create(FX_NUMBER_CHAR, &value);
-}
-static inline fx_number *fx_number_create_short(short value)
-{
-	return fx_number_create(FX_NUMBER_SHORT, &value);
-}
-static inline fx_number *fx_number_create_int(int value)
-{
-	return fx_number_create(FX_NUMBER_INT, &value);
-}
-static inline fx_number *fx_number_create_long(long value)
-{
-	return fx_number_create(FX_NUMBER_LONG, &value);
-}
-static inline fx_number *fx_number_create_longlong(long long value)
-{
-	return fx_number_create(FX_NUMBER_LONGLONG, &value);
-}
-static inline fx_number *fx_number_create_float(float value)
-{
-	return fx_number_create(FX_NUMBER_FLOAT, &value);
-}
-static inline fx_number *fx_number_create_double(double value)
-{
-	return fx_number_create(FX_NUMBER_DOUBLE, &value);
-}
-static inline fx_number *fx_number_create_size_t(size_t value)
-{
-	return fx_number_create(FX_NUMBER_SIZE_T, &value);
-}
-
-FX_API fx_number_type fx_number_get_number_type(const fx_number *number);
-FX_API int fx_number_get_value(
-	const fx_number *number,
-	fx_number_type type,
-	void *value_ptr);
-
-static inline int8_t fx_number_get_int8(const fx_number *number)
-{
-	int8_t v;
-	fx_number_get_value(number, FX_NUMBER_INT8, &v);
-	return v;
-}
-
-static inline int16_t fx_number_get_int16(const fx_number *number)
-{
-	int16_t v;
-	fx_number_get_value(number, FX_NUMBER_INT16, &v);
-	return v;
-}
-
-static inline int32_t fx_number_get_int32(const fx_number *number)
-{
-	int32_t v;
-	fx_number_get_value(number, FX_NUMBER_INT32, &v);
-	return v;
-}
-
-static inline int64_t fx_number_get_int64(const fx_number *number)
-{
-	int64_t v;
-	fx_number_get_value(number, FX_NUMBER_INT64, &v);
-	return v;
-}
-
-static inline float fx_number_get_float32(const fx_number *number)
-{
-	float v;
-	fx_number_get_value(number, FX_NUMBER_FLOAT32, &v);
-	return v;
-}
-
-static inline double fx_number_get_float64(const fx_number *number)
-{
-	double v;
-	fx_number_get_value(number, FX_NUMBER_FLOAT64, &v);
-	return v;
-}
-
-static inline char fx_number_get_char(const fx_number *number)
-{
-	char v;
-	fx_number_get_value(number, FX_NUMBER_CHAR, &v);
-	return v;
-}
-
-static inline short fx_number_get_short(const fx_number *number)
-{
-	short v;
-	fx_number_get_value(number, FX_NUMBER_SHORT, &v);
-	return v;
-}
-
-static inline int fx_number_get_int(const fx_number *number)
-{
-	int v;
-	fx_number_get_value(number, FX_NUMBER_INT, &v);
-	return v;
-}
-
-static inline long fx_number_get_long(const fx_number *number)
-{
-	long v;
-	fx_number_get_value(number, FX_NUMBER_LONG, &v);
-	return v;
-}
-
-static inline long long fx_number_get_longlong(const fx_number *number)
-{
-	long long v;
-	fx_number_get_value(number, FX_NUMBER_LONGLONG, &v);
-	return v;
-}
-
-static inline float fx_number_get_float(const fx_number *number)
-{
-	float v;
-	fx_number_get_value(number, FX_NUMBER_FLOAT, &v);
-	return v;
-}
-
-static inline double fx_number_get_double(const fx_number *number)
-{
-	double v;
-	fx_number_get_value(number, FX_NUMBER_DOUBLE, &v);
-	return v;
-}
-
-static inline size_t fx_number_get_size_t(const fx_number *number)
-{
-	size_t v;
-	fx_number_get_value(number, FX_NUMBER_SIZE_T, &v);
-	return v;
-}
-
-FX_API bool fx_number_is_integer(const fx_number *number);
-FX_API bool fx_number_is_float(const fx_number *number);
-FX_API bool fx_number_is_inf(const fx_number *number);
-FX_API bool fx_number_is_inf_positive(const fx_number *number);
-FX_API bool fx_number_is_inf_negative(const fx_number *number);
-FX_API bool fx_number_is_nan(const fx_number *number);
-FX_API bool fx_number_is_nan_positive(const fx_number *number);
-FX_API bool fx_number_is_nan_negative(const fx_number *number);
-
-FX_API void fx_number_set_inf_positive(fx_number *number, bool v);
-FX_API void fx_number_set_inf_negative(fx_number *number, bool v);
-FX_API void fx_number_set_nan_positive(fx_number *number, bool v);
-FX_API void fx_number_set_nan_negative(fx_number *number, bool v);
-
-FX_API size_t fx_number_data_size(const fx_number *number);
-
-FX_DECLS_END;
-
-#endif

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

@@ -0,0 +1,12 @@
+#include <fx/double.h>
+#include <stdio.h>
+
+int main(void)
+{
+	fx_double *d = fx_double_create(6.8);
+
+	printf("double=%lf\n", fx_double_get_value(d));
+	fx_double_unref(d);
+
+	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/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/apple/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/apple/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/apple/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.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.c

@@ -0,0 +1,210 @@
+#include <fx/macros.h>
+#include <fx/reflection/function.h>
+#include <fx/string.h>
+#include <fx/value.h>
+#include <platform/callvm.h>
+
+struct fx_function_p {
+	char *func_name;
+	fx_function_flags func_flags;
+	fx_function_impl func_impl;
+	fx_value_type func_return_type;
+	fx_value_type *func_arg_types;
+	/* number of explicit arguments that the function takes.
+	 * if the FX_FUNCTION_F_VARARG flag is set, the function supports a
+	 * 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 ********************************************************/
+
+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,
+	const fx_value *args,
+	size_t nr_args,
+	fx_value *return_value)
+{
+	size_t total_args = nr_args + func->func_nr_bound_args;
+
+	if (total_args < func->func_nr_args) {
+		return FX_ERR_INVALID_ARGUMENT;
+	}
+
+	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 = 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);
+
+	callvm_reset(&vm, 0);
+	return FX_SUCCESS;
+}
+
+/*** PUBLIC FUNCTIONS *********************************************************/
+
+fx_function *fx_function_create(
+	const char *name,
+	fx_function_flags flags,
+	fx_function_impl impl,
+	const fx_value_type *args,
+	size_t nr_args,
+	fx_value_type return_type)
+{
+	fx_function *func = fx_object_create(FX_REFLECTION_TYPE_FUNCTION);
+	if (!func) {
+		return NULL;
+	}
+
+	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;
+	p->func_impl = impl;
+	p->func_nr_args = nr_args;
+	p->func_return_type = return_type;
+	p->func_arg_types = calloc(nr_args, sizeof *args);
+	for (size_t i = 0; i < nr_args; i++) {
+		p->func_arg_types[i] = args[i];
+	}
+
+	return func;
+}
+
+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,
+	fx_value *return_value)
+{
+	FX_CLASS_DISPATCH_STATIC(
+		FX_REFLECTION_TYPE_FUNCTION,
+		function_invoke,
+		func,
+		args,
+		nr_args,
+		return_value);
+}
+
+/*** VIRTUAL FUNCTIONS
+ * ********************************************************/
+
+static void function_init(fx_object *obj, void *priv)
+{
+}
+
+static void function_fini(fx_object *obj, void *priv)
+{
+	struct fx_function_p *p = priv;
+	if (p->func_name) {
+		free(p->func_name);
+	}
+
+	if (p->func_arg_types) {
+		free(p->func_arg_types);
+	}
+}
+
+/*** CLASS DEFINITION
+ * *********************************************************/
+
+FX_TYPE_CLASS_BEGIN(fx_function)
+	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_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_TYPE_INSTANCE_FINI(function_fini);
+FX_TYPE_DEFINITION_END(fx_function)

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

@@ -0,0 +1,48 @@
+#ifndef FX_REFLECTION_FUNCTION_H_
+#define FX_REFLECTION_FUNCTION_H_
+
+#include <fx/macros.h>
+#include <fx/status.h>
+#include <fx/value.h>
+
+FX_DECLS_BEGIN;
+
+#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;
+
+typedef void (*fx_function_impl)();
+
+FX_DECLARE_TYPE(fx_function);
+
+FX_TYPE_CLASS_DECLARATION_BEGIN(fx_function)
+FX_TYPE_CLASS_DECLARATION_END(fx_function)
+
+FX_API fx_type_id fx_function_get_type();
+
+FX_API const char *fx_function_get_name(const fx_function *func);
+
+FX_API fx_function *fx_function_create(
+	const char *name,
+	fx_function_flags flags,
+	fx_function_impl impl,
+	const fx_value_type *args,
+	size_t nr_args,
+	fx_value_type return_type);
+FX_API fx_status
+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_DECLS_END;
+
+#endif

fx.reflection/include/fx/reflection/property.h

@@ -0,0 +1,4 @@
+#ifndef FX_REFLECTION_PROPERTY_H_
+#define FX_REFLECTION_PROPERTY_H_
+
+#endif

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/sys/apple/aarch64/callvm.S

@@ -0,0 +1,92 @@
+.global _callvm_invoke_i
+.align 4
+
+# x0 = (function ptr) impl
+# x1 = (struct callvm) context
+_callvm_invoke_i:
+	# save the stack frame and link pointer
+	stp x29, x30, [sp, #-16]!
+	mov x29, sp
+
+	# preserve callee-saved registers
+	stp x19, x20, [sp, #-16]!
+
+	# store function pointer and callvm context for later
+	mov x19, x0
+	mov x20, x1
+
+	# First, set up the variable arguments
+
+	### calculate the amount of stack space needed for the varargs
+	# store the original stack pointer, so it can be restored later
+	mov x0, sp
+	str x0, [sp, #-16]!
+	# x8 = excess arg count
+	ldr x8, [x20, #32]
+	# x8 = excess arg buffer size (8 bytes per value)
+	lsl x8, x8, #3
+	# allocate the stack space
+	sub sp, sp, x8
+
+	# re-align the stack, and take a pointer to the newly-allocated buffer
+	mov x0, sp
+	and x0, x0, #0xFFFFFFFFFFFFFFF0
+	mov sp, x0
+
+	ldr x1, [x20, #176]
+	mov x2, x8
+
+	# memcpy(stack vararg buffer, callvm excess buffer, arg size)
+	bl _memcpy
+
+	# Next, set up the fixed integer arguments
+	ldr x0, [x20, #48]
+	ldr x1, [x20, #56]
+	ldr x2, [x20, #64]
+	ldr x3, [x20, #72]
+	ldr x4, [x20, #80]
+	ldr x5, [x20, #88]
+	ldr x6, [x20, #96]
+	ldr x7, [x20, #104]
+
+	# Finally, set up the fixed double arguments
+	ldr d0, [x20, #112]
+	ldr d1, [x20, #120]
+	ldr d2, [x20, #128]
+	ldr d3, [x20, #136]
+	ldr d4, [x20, #144]
+	ldr d5, [x20, #152]
+	ldr d6, [x20, #160]
+	ldr d7, [x20, #168]
+
+	# call the function implementation
+	blr x19
+
+	# restore the saved stack pointer, and de-allocate the stack varargs buffer
+	ldr x9, [x29, #-32]
+	mov sp, x9
+
+	# restore callee-saved registers
+	ldp x19, x20, [sp], #16
+
+	# restore the saved stack frame and link pointer
+	ldp x29, x30, [sp], #16
+	ret
+
+
+.global _callvm_invoke_d
+.align 4
+
+# x0 = (function ptr) impl
+# x1 = (struct callvm) context
+_callvm_invoke_d:
+	b _callvm_invoke_i
+
+
+.global _callvm_invoke_v
+.align 4
+
+# x0 = (function ptr) impl
+# x1 = (struct callvm) context
+_callvm_invoke_v:
+	b _callvm_invoke_i

fx.reflection/sys/apple/aarch64/callvm.c

@@ -0,0 +1,110 @@
+#include <platform/callvm.h>
+#include <stdlib.h>
+
+#if 0
+		switch (arg->v_type.t_primitive) {
+		case FX_VALUE_TYPE_DOUBLE:
+			break;
+		default:
+			callvm_push_int(&vm, (uintptr_t)arg->v_pointer);
+			break;
+		}
+#endif
+
+void callvm_reset(struct callvm *vm, unsigned int max_fixed_args)
+{
+	vm->vm_arg_int_count = 0;
+	vm->vm_arg_double_count = 0;
+	vm->vm_arg_fixed = max_fixed_args;
+	vm->vm_arg_excess_count = 0;
+}
+
+static void expand_excess(struct callvm *vm)
+{
+	size_t new_capacity = vm->vm_arg_excess_max * 2;
+	if (!new_capacity) {
+		new_capacity = 4;
+	}
+
+	void *buf = realloc(
+		vm->vm_arg_excess,
+		new_capacity * sizeof *vm->vm_arg_excess);
+
+	if (!buf) {
+		return;
+	}
+
+	vm->vm_arg_excess = buf;
+	vm->vm_arg_excess_max = new_capacity;
+}
+
+static void push_excess(struct callvm *vm, uintptr_t value)
+{
+	if (vm->vm_arg_excess_count + 1 > vm->vm_arg_excess_max) {
+		expand_excess(vm);
+	}
+
+	vm->vm_arg_excess[vm->vm_arg_excess_count++] = value;
+	vm->vm_arg_count++;
+}
+
+static void push_int(struct callvm *vm, uintptr_t value)
+{
+	if (vm->vm_arg_int_count >= MAX_INT_ARGS) {
+		push_excess(vm, value);
+		return;
+	}
+
+	vm->vm_arg_int[vm->vm_arg_int_count++] = value;
+	vm->vm_arg_count++;
+}
+
+static void push_double(struct callvm *vm, double value)
+{
+	if (vm->vm_arg_double_count >= MAX_DOUBLE_ARGS) {
+		push_excess(vm, *(uintptr_t *)&value);
+		return;
+	}
+
+	vm->vm_arg_double[vm->vm_arg_double_count++] = value;
+	vm->vm_arg_count++;
+}
+
+void callvm_push(struct callvm *vm, const fx_value *value)
+{
+	if (vm->vm_arg_count >= vm->vm_arg_fixed) {
+		push_excess(vm, (uintptr_t)value->v_pointer);
+		return;
+	}
+
+	switch (value->v_type.t_primitive) {
+	case FX_VALUE_TYPE_DOUBLE:
+		push_double(vm, value->v_double);
+		break;
+	default:
+		push_int(vm, (uintptr_t)value->v_pointer);
+		break;
+	}
+}
+
+extern uintptr_t callvm_invoke_i(fx_function_impl impl, struct callvm *vm);
+extern double callvm_invoke_d(fx_function_impl impl, struct callvm *vm);
+extern void callvm_invoke_v(fx_function_impl impl, struct callvm *vm);
+
+fx_value callvm_invoke(
+	struct callvm *vm,
+	fx_function_impl impl,
+	fx_value_type return_type)
+{
+	switch (return_type) {
+	case FX_VALUE_TYPE_NONE:
+		callvm_invoke_v(impl, vm);
+		break;
+	case FX_VALUE_TYPE_DOUBLE:
+		return FX_VALUE_DOUBLE(callvm_invoke_d(impl, vm));
+	default:
+		return FX_VALUE_INT(callvm_invoke_i(impl, vm));
+	}
+
+	return FX_VALUE_EMPTY;
+}

fx.reflection/sys/apple/aarch64/include/platform/callvm.h

@@ -0,0 +1,36 @@
+#ifndef FX_REFLECTION_DARWIN_ARM64_CALLVM_H_
+#define FX_REFLECTION_DARWIN_ARM64_CALLVM_H_
+
+#include <fx/reflection/function.h>
+#include <fx/value.h>
+#include <stdint.h>
+
+#define MAX_FIXED_ARGS  ((unsigned int)-1)
+#define MAX_DOUBLE_ARGS 8
+#define MAX_INT_ARGS    8
+
+/* dyn-dispatch.S depends on the layout of this struct */
+struct callvm {
+	uint64_t vm_arg_int_count;
+	uint64_t vm_arg_double_count;
+
+	/* any args pushed after this limit is reached will be stored in the
+	 * excess buffer. used for calling varargs functions */
+	uint64_t vm_arg_count, vm_arg_fixed;
+
+	uint64_t vm_arg_excess_count;
+	uint64_t vm_arg_excess_max;
+
+	uintptr_t vm_arg_int[MAX_INT_ARGS];
+	double vm_arg_double[MAX_DOUBLE_ARGS];
+	uintptr_t *vm_arg_excess;
+};
+
+extern void callvm_reset(struct callvm *vm, unsigned int max_fixed_args);
+extern void callvm_push(struct callvm *vm, const fx_value *value);
+extern fx_value callvm_invoke(
+	struct callvm *vm,
+	fx_function_impl impl,
+	fx_value_type return_type);
+
+#endif

fx.reflection/sys/linux/amd64/callvm.S

@@ -0,0 +1,95 @@
+.extern memcpy
+.type memcpy, @function
+
+.global callvm_invoke_i
+.type callvm_invoke_i, @function
+
+# %rdi = (function ptr) impl
+# %rsi = (struct callvm) context
+callvm_invoke_i:
+	# save the stack frame pointer
+	push %rbp
+	mov %rsp, %rbp
+
+	# store function pointer for later
+	push %r12
+	push %r13
+	push %r14
+	push %r15
+
+	# move our parameters out of the way
+	mov %rdi, %r11
+	mov %rsi, %r12
+
+	# calculate the amount of stack space needed for the varargs
+	movq 32(%r12), %r13
+	shl $3, %r13
+
+	# allocate the stack space
+	push %rsp
+	sub %r13, %rsp
+	andq $0xFFFFFFFFFFFFFFF0, %rsp # re-align the stack
+
+	# copy the excess args to the stack
+	mov %rsp, %rdi
+	mov 160(%r12), %rsi
+	mov %r13, %rdx
+	call memcpy
+
+	# Next, set up the fixed integer arguments
+
+	movq 48(%r12), %rdi	# int arg 0
+	movq 56(%r12), %rsi	# int arg 1
+	movq 64(%r12), %rdx	# int arg 2
+	movq 72(%r12), %rcx	# int arg 3
+	movq 80(%r12), %r8	# int arg 4
+	movq 88(%r12), %r9	# int arg 5
+
+	# Finally, set up the fixed double arguments
+
+	movq 96(%r12), %xmm0	# double arg 0
+	movq 104(%r12), %xmm1	# double arg 1
+	movq 112(%r12), %xmm2	# double arg 2
+	movq 120(%r12), %xmm3	# double arg 3
+	movq 128(%r12), %xmm4	# double arg 4
+	movq 136(%r12), %xmm5	# double arg 5
+	movq 144(%r12), %xmm6	# double arg 6
+	movq 152(%r12), %xmm7	# double arg 7
+
+	# set the number of vararg double parameters
+	# as required by the ABI
+	mov 168(%r12), %rax
+
+	# call the function implementation
+	call *%r11
+
+	# Restore the stack pointer (deallocating the varargs buffer)
+	mov -40(%rbp), %rsp
+
+	# Restore callee-saved registers
+	pop %r15
+	pop %r14
+	pop %r13
+	pop %r12
+
+	# restore the saved stack frame
+	pop %rbp
+	ret
+
+
+.global callvm_invoke_d
+.type callvm_invoke_d, @function
+
+# %rdi = (function ptr) impl
+# %rsi = (struct callvm *) context
+callvm_invoke_d:
+	jmp callvm_invoke_i
+
+
+.global callvm_invoke_v
+.type callvm_invoke_v, @function
+
+# %rdi = (function ptr) impl
+# %rsi = (struct callvm *) context
+callvm_invoke_v:
+	jmp callvm_invoke_i

fx.reflection/sys/linux/amd64/callvm.c

@@ -0,0 +1,110 @@
+#include <platform/callvm.h>
+#include <stdlib.h>
+
+#if 0
+		switch (arg->v_type.t_primitive) {
+		case FX_VALUE_TYPE_DOUBLE:
+			break;
+		default:
+			callvm_push_int(&vm, (uintptr_t)arg->v_pointer);
+			break;
+		}
+#endif
+
+void callvm_reset(struct callvm* vm, unsigned int max_fixed_args)
+{
+        vm->vm_arg_int_count = 0;
+        vm->vm_arg_double_count = 0;
+        vm->vm_arg_fixed = max_fixed_args;
+        vm->vm_arg_excess_count = 0;
+        vm->vm_double_excess_count = 0;
+}
+
+static void expand_excess(struct callvm* vm)
+{
+        size_t new_capacity = vm->vm_arg_excess_max * 2;
+        if (!new_capacity) {
+                new_capacity = 4;
+        }
+
+        void* buf = realloc(
+            vm->vm_arg_excess,
+            new_capacity * sizeof *vm->vm_arg_excess);
+
+        if (!buf) {
+                return;
+        }
+
+        vm->vm_arg_excess = buf;
+        vm->vm_arg_excess_max = new_capacity;
+}
+
+static void push_excess(struct callvm* vm, uintptr_t value)
+{
+        if (vm->vm_arg_excess_count + 1 > vm->vm_arg_excess_max) {
+                expand_excess(vm);
+        }
+
+        vm->vm_arg_excess[vm->vm_arg_excess_count++] = value;
+        vm->vm_arg_count++;
+}
+
+static void push_int(struct callvm* vm, uintptr_t value)
+{
+        if (vm->vm_arg_int_count >= MAX_INT_ARGS) {
+                push_excess(vm, value);
+                return;
+        }
+
+        vm->vm_arg_int[vm->vm_arg_int_count++] = value;
+        vm->vm_arg_count++;
+}
+
+static void push_double(struct callvm* vm, double value)
+{
+        if (vm->vm_arg_double_count >= MAX_DOUBLE_ARGS) {
+                push_excess(vm, *(uintptr_t*)&value);
+                return;
+        }
+
+        vm->vm_arg_double[vm->vm_arg_double_count++] = value;
+        vm->vm_arg_count++;
+
+        if (vm->vm_arg_count > vm->vm_arg_fixed) {
+                vm->vm_double_excess_count++;
+        }
+}
+
+void callvm_push(struct callvm* vm, const fx_value* value)
+{
+        switch (value->v_type.t_primitive) {
+        case FX_VALUE_TYPE_DOUBLE:
+                push_double(vm, value->v_double);
+                break;
+        default:
+                push_int(vm, (uintptr_t)value->v_pointer);
+                break;
+        }
+}
+
+extern uintptr_t callvm_invoke_i(fx_function_impl impl, struct callvm* vm);
+extern double callvm_invoke_d(fx_function_impl impl, struct callvm* vm);
+extern void callvm_invoke_v(fx_function_impl impl, struct callvm* vm);
+
+fx_value callvm_invoke(
+    struct callvm* vm,
+    fx_function_impl impl,
+    fx_value_type return_type)
+{
+        switch (return_type) {
+        case FX_VALUE_TYPE_NONE:
+                callvm_invoke_v(impl, vm);
+                break;
+        case FX_VALUE_TYPE_DOUBLE:
+                return FX_VALUE_DOUBLE(callvm_invoke_d(impl, vm));
+        default:
+                return FX_VALUE_INT(callvm_invoke_i(impl, vm));
+        }
+
+        return FX_VALUE_EMPTY;
+}

fx.reflection/sys/linux/amd64/include/platform/callvm.h

@@ -0,0 +1,37 @@
+#ifndef FX_REFLECTION_DARWIN_ARM64_CALLVM_H_
+#define FX_REFLECTION_DARWIN_ARM64_CALLVM_H_
+
+#include <fx/reflection/function.h>
+#include <fx/value.h>
+#include <stdint.h>
+
+#define MAX_FIXED_ARGS  ((unsigned int)-1)
+#define MAX_DOUBLE_ARGS 8
+#define MAX_INT_ARGS    6
+
+/* dyn-dispatch.S depends on the layout of this struct */
+struct callvm {
+	uint64_t vm_arg_int_count;
+	uint64_t vm_arg_double_count;
+
+	/* any args pushed after this limit is reached will be stored in the
+	 * excess buffer. used for calling varargs functions */
+	uint64_t vm_arg_count, vm_arg_fixed;
+
+	uint64_t vm_arg_excess_count;
+	uint64_t vm_arg_excess_max;
+
+	uintptr_t vm_arg_int[MAX_INT_ARGS];
+	double vm_arg_double[MAX_DOUBLE_ARGS];
+	uintptr_t *vm_arg_excess;
+	uint64_t vm_double_excess_count;
+};
+
+extern void callvm_reset(struct callvm *vm, unsigned int max_fixed_args);
+extern void callvm_push(struct callvm *vm, const fx_value *value);
+extern fx_value callvm_invoke(
+	struct callvm *vm,
+	fx_function_impl impl,
+	fx_value_type return_type);
+
+#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

@@ -1,14 +1,17 @@
+#include <fx/bool.h>
 #include <fx/collections/array.h>
 #include <fx/collections/datetime.h>
 #include <fx/collections/dict.h>
 #include <fx/collections/hashmap.h>
-#include <fx/collections/number.h>
+#include <fx/double.h>
 #include <fx/error.h>
+#include <fx/int.h>
 #include <fx/serial/ctx.h>
 #include <fx/serial/toml.h>
 #include <fx/status.h>
 #include <fx/string.h>
 #include <fx/stringstream.h>
+#include <fx/uint.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -1688,22 +1691,22 @@ static fx_result parse_string(struct ctx *ctx, fx_object **result)
 static fx_result parse_int(struct ctx *ctx, fx_object **result)
 {
 	struct token *tok = peek_token(ctx);
-	fx_number *val = FX_LONGLONG(tok->tok_value.i.v);
+	fx_int *val = fx_int_create(tok->tok_value.i.v);
 	if (!val) {
 		return FX_RESULT_ERR(NO_MEMORY);
 	}
 
 	if (tok->tok_value.i.inf) {
 		if (tok->tok_value.i.v >= 0) {
-			fx_number_set_inf_positive(val, true);
+			fx_int_set_value_inf(val);
 		} else {
-			fx_number_set_inf_negative(val, true);
+			fx_int_set_value_inf_negative(val);
 		}
 	} else if (tok->tok_value.i.nan) {
 		if (tok->tok_value.i.v >= 0) {
-			fx_number_set_nan_positive(val, true);
+			fx_int_set_value_nan(val);
 		} else {
-			fx_number_set_nan_negative(val, true);
+			fx_int_set_value_nan_negative(val);
 		}
 	}
 
@@ -1714,22 +1717,22 @@ static fx_result parse_int(struct ctx *ctx, fx_object **result)
 static fx_result parse_float(struct ctx *ctx, fx_object **result)
 {
 	struct token *tok = peek_token(ctx);
-	fx_number *val = FX_DOUBLE(tok->tok_value.f.v);
+	fx_double *val = fx_double_create(tok->tok_value.f.v);
 	if (!val) {
 		return FX_RESULT_ERR(NO_MEMORY);
 	}
 
 	if (tok->tok_value.f.inf) {
 		if (tok->tok_value.f.v >= 0) {
-			fx_number_set_inf_positive(val, true);
+			fx_double_set_value_inf(val);
 		} else {
-			fx_number_set_inf_negative(val, true);
+			fx_double_set_value_inf_negative(val);
 		}
 	} else if (tok->tok_value.f.nan) {
 		if (tok->tok_value.f.v >= 0) {
-			fx_number_set_nan_positive(val, true);
+			fx_double_set_value_nan(val);
 		} else {
-			fx_number_set_nan_negative(val, true);
+			fx_double_set_value_nan_negative(val);
 		}
 	}
 
@@ -1740,7 +1743,7 @@ static fx_result parse_float(struct ctx *ctx, fx_object **result)
 static fx_result parse_bool(struct ctx *ctx, fx_object **result)
 {
 	struct token *tok = peek_token(ctx);
-	fx_number *val = FX_INT8(tok->tok_value.b);
+	fx_bool *val = fx_bool_create(tok->tok_value.b);
 	if (!val) {
 		return FX_RESULT_ERR(NO_MEMORY);
 	}
@@ -2319,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

@@ -0,0 +1,84 @@
+#include <fx/bool.h>
+#include <fx/stream.h>
+
+/*** PRIVATE DATA *************************************************************/
+
+struct fx_bool_p {
+	bool b_value;
+};
+
+/*** PRIVATE FUNCTIONS ********************************************************/
+
+static void bool_set_value(struct fx_bool_p *i, bool v)
+{
+	i->b_value = v;
+}
+
+static bool bool_get_value(struct fx_bool_p *i)
+{
+	return i->b_value;
+}
+
+/*** PUBLIC FUNCTIONS *********************************************************/
+
+fx_bool *fx_bool_create(bool value)
+{
+	fx_bool *i = fx_object_create(FX_TYPE_BOOL);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_bool_p *p = fx_object_get_private(i, FX_TYPE_BOOL);
+	p->b_value = value;
+
+	return i;
+}
+
+void fx_bool_set_value(fx_bool *i, bool v)
+{
+	FX_CLASS_DISPATCH_STATIC_V(FX_TYPE_BOOL, bool_set_value, i, v);
+}
+
+bool fx_bool_get_value(const fx_bool *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_BOOL, bool_get_value, i);
+}
+
+/*** VIRTUAL FUNCTIONS ********************************************************/
+
+static void bool_init(fx_object *obj, void *priv)
+{
+	struct fx_bool_p *i = priv;
+
+	i->b_value = false;
+}
+
+static void bool_fini(fx_object *obj, void *priv)
+{
+}
+
+static void bool_to_string(const fx_object *obj, fx_stream *out)
+{
+	struct fx_bool_p *i = fx_object_get_private(obj, FX_TYPE_BOOL);
+	if (i->b_value == false) {
+		fx_stream_write_cstr(out, "false", NULL);
+	} else {
+		fx_stream_write_cstr(out, "true", NULL);
+	}
+}
+
+/*** CLASS DEFINITION *********************************************************/
+
+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_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_TYPE_CLASS(fx_bool_class);
+	FX_TYPE_INSTANCE_PRIVATE(struct fx_bool_p);
+	FX_TYPE_INSTANCE_INIT(bool_init);
+	FX_TYPE_INSTANCE_FINI(bool_fini);
+FX_TYPE_DEFINITION_END(fx_bool)

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

@@ -0,0 +1,280 @@
+#include <fx/double.h>
+#include <fx/stream.h>
+#include <inttypes.h>
+#include <stdint.h>
+
+/*** PRIVATE DATA *************************************************************/
+
+enum double_type {
+	DOUBLE_REGULAR = 0,
+	DOUBLE_INF_POSITIVE,
+	DOUBLE_INF_NEGATIVE,
+	DOUBLE_NAN_POSITIVE,
+	DOUBLE_NAN_NEGATIVE,
+};
+
+struct fx_double_p {
+	enum double_type i_type;
+	double i_value;
+};
+
+/*** PRIVATE FUNCTIONS ********************************************************/
+
+static bool double_get_value(const struct fx_double_p *i)
+{
+	return i->i_value;
+}
+
+static void double_set_value(struct fx_double_p *i, double v)
+{
+	i->i_type = DOUBLE_REGULAR;
+	i->i_value = v;
+}
+
+static void double_set_value_nan(struct fx_double_p *i)
+{
+	i->i_type = DOUBLE_NAN_POSITIVE;
+	i->i_value = 0;
+}
+
+static void double_set_value_nan_negative(struct fx_double_p *i)
+{
+	i->i_type = DOUBLE_NAN_NEGATIVE;
+	i->i_value = 0;
+}
+
+static void double_set_value_inf(struct fx_double_p *i)
+{
+	i->i_type = DOUBLE_INF_POSITIVE;
+	i->i_value = 0;
+}
+
+static void double_set_value_inf_negative(struct fx_double_p *i)
+{
+	i->i_type = DOUBLE_INF_NEGATIVE;
+	i->i_value = 0;
+}
+
+static bool double_is_nan(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_NAN_POSITIVE
+	    || i->i_type == DOUBLE_NAN_NEGATIVE;
+}
+
+static bool double_is_nan_positive(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_NAN_POSITIVE;
+}
+
+static bool double_is_nan_negative(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_NAN_NEGATIVE;
+}
+
+static bool double_is_inf(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_INF_POSITIVE
+	    || i->i_type == DOUBLE_INF_NEGATIVE;
+}
+
+static bool double_is_inf_positive(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_INF_POSITIVE;
+}
+
+static bool double_is_inf_negative(struct fx_double_p *i)
+{
+	return i->i_type == DOUBLE_INF_NEGATIVE;
+}
+
+/*** PUBLIC FUNCTIONS *********************************************************/
+
+fx_double *fx_double_create(double value)
+{
+	fx_double *i = fx_object_create(FX_TYPE_DOUBLE);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_double_p *p = fx_object_get_private(i, FX_TYPE_DOUBLE);
+	p->i_type = DOUBLE_REGULAR;
+	p->i_value = value;
+
+	return i;
+}
+
+fx_double *fx_double_create_nan(void)
+{
+	fx_double *i = fx_object_create(FX_TYPE_DOUBLE);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_double_p *p = fx_object_get_private(i, FX_TYPE_DOUBLE);
+	p->i_type = DOUBLE_NAN_POSITIVE;
+	p->i_value = 0;
+
+	return i;
+}
+
+fx_double *fx_double_create_nan_negative(void)
+{
+	fx_double *i = fx_object_create(FX_TYPE_DOUBLE);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_double_p *p = fx_object_get_private(i, FX_TYPE_DOUBLE);
+	p->i_type = DOUBLE_NAN_NEGATIVE;
+	p->i_value = 0;
+
+	return i;
+}
+
+fx_double *fx_double_create_inf(void)
+{
+	fx_double *i = fx_object_create(FX_TYPE_DOUBLE);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_double_p *p = fx_object_get_private(i, FX_TYPE_DOUBLE);
+	p->i_type = DOUBLE_INF_POSITIVE;
+	p->i_value = 0;
+
+	return i;
+}
+
+fx_double *fx_double_create_inf_negative(void)
+{
+	fx_double *i = fx_object_create(FX_TYPE_DOUBLE);
+	if (!i) {
+		return NULL;
+	}
+
+	struct fx_double_p *p = fx_object_get_private(i, FX_TYPE_DOUBLE);
+	p->i_type = DOUBLE_INF_NEGATIVE;
+	p->i_value = 0;
+
+	return i;
+}
+
+double fx_double_get_value(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_get_value, i);
+}
+
+void fx_double_set_value(fx_double *i, double v)
+{
+	FX_CLASS_DISPATCH_STATIC_V(FX_TYPE_DOUBLE, double_set_value, i, v);
+}
+
+void fx_double_set_value_nan(fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_V0(FX_TYPE_DOUBLE, double_set_value_nan, i);
+}
+
+void fx_double_set_value_nan_negative(fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_V0(
+		FX_TYPE_DOUBLE,
+		double_set_value_nan_negative,
+		i);
+}
+
+void fx_double_set_value_inf(fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_V0(FX_TYPE_DOUBLE, double_set_value_inf, i);
+}
+
+void fx_double_set_value_inf_negative(fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_V0(
+		FX_TYPE_DOUBLE,
+		double_set_value_inf_negative,
+		i);
+}
+
+bool fx_double_is_nan(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_nan, i);
+}
+
+bool fx_double_is_nan_positive(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_nan_positive, i);
+}
+
+bool fx_double_is_nan_negative(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_nan_negative, i);
+}
+
+bool fx_double_is_inf(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_inf, i);
+}
+
+bool fx_double_is_inf_positive(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_inf_positive, i);
+}
+
+bool fx_double_is_inf_negative(const fx_double *i)
+{
+	FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_DOUBLE, double_is_inf_negative, i);
+}
+
+/*** VIRTUAL FUNCTIONS ********************************************************/
+
+static void double_init(fx_object *obj, void *priv)
+{
+	struct fx_double_p *i = priv;
+
+	i->i_type = DOUBLE_REGULAR;
+	i->i_value = 0;
+}
+
+static void double_fini(fx_object *obj, void *priv)
+{
+}
+
+static void double_to_string(const fx_object *obj, fx_stream *out)
+{
+	struct fx_double_p *i = fx_object_get_private(obj, FX_TYPE_DOUBLE);
+	switch (i->i_type) {
+	case DOUBLE_REGULAR:
+		fx_stream_write_fmt(out, NULL, "%" PRIdPTR, i->i_value);
+		break;
+	case DOUBLE_INF_POSITIVE:
+		fx_stream_write_cstr(out, "inf", NULL);
+		break;
+	case DOUBLE_INF_NEGATIVE:
+		fx_stream_write_cstr(out, "-inf", NULL);
+		break;
+	case DOUBLE_NAN_POSITIVE:
+		fx_stream_write_cstr(out, "NaN", NULL);
+		break;
+	case DOUBLE_NAN_NEGATIVE:
+		fx_stream_write_cstr(out, "-NaN", NULL);
+		break;
+	default:
+		break;
+	}
+}
+
+/*** CLASS DEFINITION *********************************************************/
+
+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_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_TYPE_CLASS(fx_double_class);
+	FX_TYPE_INSTANCE_PRIVATE(struct fx_double_p);
+	FX_TYPE_INSTANCE_INIT(double_init);
+	FX_TYPE_INSTANCE_FINI(double_fini);
+FX_TYPE_DEFINITION_END(fx_double)

fx/include/fx/bool.h

@@ -0,0 +1,25 @@
+#ifndef FX_BOOL_H_
+#define FX_BOOL_H_
+
+#include <fx/macros.h>
+
+FX_DECLS_BEGIN;
+
+#define FX_TYPE_BOOL (fx_bool_get_type())
+
+FX_DECLARE_TYPE(fx_bool);
+
+FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bool)
+FX_TYPE_CLASS_DECLARATION_END(fx_bool)
+
+FX_API fx_type_id fx_bool_get_type(void);
+
+FX_API fx_bool *fx_bool_create(bool value);
+
+FX_API void fx_bool_set_value(fx_bool *i, bool v);
+
+FX_API bool fx_bool_get_value(const fx_bool *i);
+
+FX_DECLS_END;
+
+#endif