#include "number.h"

#include <blue/core/stream.h>
#include <blue/ds/type.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

typedef int (*number_converter_t)(const struct b_number *, void *);

static number_converter_t converters[B_NUMBER_TYPE_COUNT][B_NUMBER_TYPE_COUNT];

static void number_to_string(struct b_dsref *obj, struct b_stream *out);

static struct b_dsref_type number_type = {
	.t_name = "corelib::number",
	.t_flags = B_DSREF_FUNDAMENTAL,
	.t_id = B_DSREF_TYPE_NUMBER,
	.t_instance_size = sizeof(b_number),
	.t_to_string = number_to_string,
};

struct b_number *b_number_create(b_number_type type, void *value_ptr)
{
	struct b_number *n
		= (struct b_number *)b_dsref_type_instantiate(&number_type);
	if (!n) {
		return NULL;
	}

	n->n_type = type;

	if (!value_ptr) {
		return n;
	}

	switch (n->n_type) {
	case B_NUMBER_INT8:
		memcpy(&n->n_value.v_int8, value_ptr, sizeof n->n_value.v_int8);
		break;
	case B_NUMBER_INT16:
		memcpy(&n->n_value.v_int16, value_ptr, sizeof n->n_value.v_int16);
		break;
	case B_NUMBER_INT32:
		memcpy(&n->n_value.v_int32, value_ptr, sizeof n->n_value.v_int32);
		break;
	case B_NUMBER_INT64:
		memcpy(&n->n_value.v_int64, value_ptr, sizeof n->n_value.v_int64);
		break;
	case B_NUMBER_FLOAT32:
		memcpy(&n->n_value.v_float32, value_ptr,
		       sizeof n->n_value.v_float32);
		break;
	case B_NUMBER_FLOAT64:
		memcpy(&n->n_value.v_float64, value_ptr,
		       sizeof n->n_value.v_float64);
		break;
	case B_NUMBER_CHAR:
		memcpy(&n->n_value.v_char, value_ptr, sizeof n->n_value.v_char);
		break;
	case B_NUMBER_SHORT:
		memcpy(&n->n_value.v_short, value_ptr, sizeof n->n_value.v_short);
		break;
	case B_NUMBER_INT:
		memcpy(&n->n_value.v_int, value_ptr, sizeof n->n_value.v_int);
		break;
	case B_NUMBER_LONG:
		memcpy(&n->n_value.v_long, value_ptr, sizeof n->n_value.v_long);
		break;
	case B_NUMBER_LONGLONG:
		memcpy(&n->n_value.v_longlong, value_ptr,
		       sizeof n->n_value.v_longlong);
		break;
	case B_NUMBER_FLOAT:
		memcpy(&n->n_value.v_float, value_ptr, sizeof n->n_value.v_float);
		break;
	case B_NUMBER_DOUBLE:
		memcpy(&n->n_value.v_double, value_ptr, sizeof n->n_value.v_double);
		break;
	case B_NUMBER_SIZE_T:
		memcpy(&n->n_value.v_size_t, value_ptr, sizeof n->n_value.v_size_t);
		break;
	default:
		break;
	}

	return n;
}

b_number_type b_number_get_type(const struct b_number *number)
{
	return number->n_type;
}

int b_number_get_value(
	const struct b_number *number, b_number_type type, void *value_ptr)
{
	b_number_type srb_type = number->n_type;
	b_number_type dest_type = type;

	number_converter_t converter = converters[srb_type][dest_type];
	if (!converter) {
		return -1;
	}

	return converter(number, value_ptr);
}

bool b_number_is_integer(const struct b_number *number)
{
	switch (number->n_type) {
	case B_NUMBER_INT8:
	case B_NUMBER_INT16:
	case B_NUMBER_INT32:
	case B_NUMBER_INT64:
	case B_NUMBER_SIZE_T:
	case B_NUMBER_CHAR:
	case B_NUMBER_SHORT:
	case B_NUMBER_INT:
	case B_NUMBER_LONG:
	case B_NUMBER_LONGLONG:
	case B_NUMBER_HANDLE:
		return true;
	default:
		return false;
	}
}

bool b_number_is_float(const struct b_number *number)
{
	switch (number->n_type) {
	case B_NUMBER_FLOAT:
	case B_NUMBER_DOUBLE:
	case B_NUMBER_FLOAT32:
	case B_NUMBER_FLOAT64:
		return true;
	default:
		return false;
	}
}

size_t b_number_data_size(const struct b_number *number)
{
	switch (number->n_type) {
	case B_NUMBER_INT8:
		return sizeof number->n_value.v_int8;
	case B_NUMBER_INT16:
		return sizeof number->n_value.v_int16;
	case B_NUMBER_INT32:
		return sizeof number->n_value.v_int32;
	case B_NUMBER_INT64:
		return sizeof number->n_value.v_int64;
	case B_NUMBER_FLOAT32:
		return sizeof number->n_value.v_float32;
	case B_NUMBER_FLOAT64:
		return sizeof number->n_value.v_float64;
	case B_NUMBER_CHAR:
		return sizeof number->n_value.v_char;
	case B_NUMBER_SHORT:
		return sizeof number->n_value.v_short;
	case B_NUMBER_INT:
		return sizeof number->n_value.v_int;
	case B_NUMBER_LONG:
		return sizeof number->n_value.v_long;
	case B_NUMBER_LONGLONG:
		return sizeof number->n_value.v_longlong;
	case B_NUMBER_FLOAT:
		return sizeof number->n_value.v_float;
	case B_NUMBER_DOUBLE:
		return sizeof number->n_value.v_double;
	case B_NUMBER_SIZE_T:
		return sizeof number->n_value.v_size_t;
	default:
		return 0;
	}
}

static void number_to_string(struct b_dsref *obj, struct b_stream *out)
{
	struct b_number *number = B_NUMBER(obj);
	switch (number->n_type) {
	case B_NUMBER_INT8:
		b_stream_write_fmt(out, NULL, "%" PRIu8, number->n_value.v_int8);
		break;
	case B_NUMBER_INT16:
		b_stream_write_fmt(out, NULL, "%" PRIu16, number->n_value.v_int16);
		break;
	case B_NUMBER_INT32:
		b_stream_write_fmt(out, NULL, "%" PRIu32, number->n_value.v_int32);
		break;
	case B_NUMBER_INT64:
		b_stream_write_fmt(out, NULL, "%" PRIu64, number->n_value.v_int64);
		break;
	case B_NUMBER_FLOAT32:
		b_stream_write_fmt(out, NULL, "%f", number->n_value.v_float32);
		break;
	case B_NUMBER_FLOAT64:
		b_stream_write_fmt(out, NULL, "%lf", number->n_value.v_float64);
		break;
	case B_NUMBER_CHAR:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_char);
		break;
	case B_NUMBER_SHORT:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_short);
		break;
	case B_NUMBER_INT:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_int);
		break;
	case B_NUMBER_LONG:
		b_stream_write_fmt(out, NULL, "%ld", number->n_value.v_long);
		break;
	case B_NUMBER_LONGLONG:
		b_stream_write_fmt(out, NULL, "%lld", number->n_value.v_longlong);
		break;
	case B_NUMBER_FLOAT:
		b_stream_write_fmt(out, NULL, "%f", number->n_value.v_float);
		break;
	case B_NUMBER_DOUBLE:
		b_stream_write_fmt(out, NULL, "%lf", number->n_value.v_double);
		break;
	case B_NUMBER_SIZE_T:
		b_stream_write_fmt(out, NULL, "%zu", number->n_value.v_size_t);
		break;
	case B_NUMBER_HANDLE:
		b_stream_write_fmt(
			out, NULL, "%016" PRIx64, number->n_value.v_size_t);
		break;
	default:
		break;
	}
}

/* ++++++++++++++++++ int8 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int8_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = (int64_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int8;
	return 0;
}

static int int8_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_int8;
	return 0;
}

static int int8_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = (long)number->n_value.v_int8;
	return 0;
}

static int int8_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = (long long)number->n_value.v_int8;
	return 0;
}

static int int8_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = (size_t)number->n_value.v_int8;
	return 0;
}

/* ++++++++++++++++++ int16 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int16_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int16;
	return 0;
}

static int int16_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int16;
	return 0;
}

static int int16_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

/* ++++++++++++++++++ int32 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int32_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int32;
	return 0;
}

static int int32_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int32;
	return 0;
}

static int int32_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int32;
	return 0;
}

static int int32_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int32;
	return 0;
}

static int int32_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int32;
	return 0;
}

static int int32_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int32;
	return 0;
}

static int int32_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

/* ++++++++++++++++++ int64 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int64_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int64;
	return 0;
}

static int int64_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = (double)number->n_value.v_int64;
	return 0;
}

static int int64_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int64;
	return 0;
}

static int int64_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int64;
	return 0;
}

static int int64_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_int64;
	return 0;
}

static int int64_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int64;
	return 0;
}

static int int64_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = (double)number->n_value.v_int64;
	return 0;
}

static int int64_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int64;
	return 0;
}

/* ++++++++++++++++++ float32 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float32_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = (int64_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_float32;
	return 0;
}

static int float32_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_float32;
	return 0;
}

static int float32_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_float32;
	return 0;
}

static int float32_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float32;
	return 0;
}

/* ++++++++++++++++++ float64 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float64_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

/* ++++++++++++++++++ char -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int char_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_char;
	return 0;
}

/* ++++++++++++++++++ short -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int short_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_short;
	return 0;
}

/* ++++++++++++++++++ int -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int;
	return 0;
}

/* ++++++++++++++++++ long -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int long_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_long;
	return 0;
}

/* ++++++++++++++++++ longlong -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int longlong_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

/* ++++++++++++++++++ float -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float;
	return 0;
}

/* ++++++++++++++++++ double -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int double_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_double;
	return 0;
}

/* ++++++++++++++++++ size_t -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int size_t_to_int8(const struct b_number *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int16(const struct b_number *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int32(const struct b_number *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int64(const struct b_number *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float32(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float64(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_char(const struct b_number *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_short(const struct b_number *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int(const struct b_number *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_long(const struct b_number *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_longlong(const struct b_number *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float(const struct b_number *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_double(const struct b_number *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_size_t(const struct b_number *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static number_converter_t converters[B_NUMBER_TYPE_COUNT][B_NUMBER_TYPE_COUNT] = {
	/* int8_t -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT8] = {
		[B_NUMBER_INT8]     = int8_to_int8,
		[B_NUMBER_INT16]    = int8_to_int16,
		[B_NUMBER_INT32]    = int8_to_int32,
		[B_NUMBER_INT64]    = int8_to_int64,
		[B_NUMBER_FLOAT32]  = int8_to_float32,
		[B_NUMBER_FLOAT64]  = int8_to_float64,
		[B_NUMBER_CHAR]     = int8_to_char,
		[B_NUMBER_SHORT]    = int8_to_short,
		[B_NUMBER_INT]      = int8_to_int,
		[B_NUMBER_LONG]     = int8_to_long,
		[B_NUMBER_LONGLONG] = int8_to_longlong,
		[B_NUMBER_FLOAT]    = int8_to_float,
		[B_NUMBER_DOUBLE]   = int8_to_double,
		[B_NUMBER_SIZE_T]   = int8_to_size_t,
	},
	/* int16 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT16] = {
		[B_NUMBER_INT8]     = int16_to_int8,
		[B_NUMBER_INT16]    = int16_to_int16,
		[B_NUMBER_INT32]    = int16_to_int32,
		[B_NUMBER_INT64]    = int16_to_int64,
		[B_NUMBER_FLOAT32]  = int16_to_float32,
		[B_NUMBER_FLOAT64]  = int16_to_float64,
		[B_NUMBER_CHAR]     = int16_to_char,
		[B_NUMBER_SHORT]    = int16_to_short,
		[B_NUMBER_INT]      = int16_to_int,
		[B_NUMBER_LONG]     = int16_to_long,
		[B_NUMBER_LONGLONG] = int16_to_longlong,
		[B_NUMBER_FLOAT]    = int16_to_float,
		[B_NUMBER_DOUBLE]   = int16_to_double,
		[B_NUMBER_SIZE_T]   = int16_to_size_t,
	},
	/* int32 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT32] = {
		[B_NUMBER_INT8]     = int32_to_int8,
		[B_NUMBER_INT16]    = int32_to_int16,
		[B_NUMBER_INT32]    = int32_to_int32,
		[B_NUMBER_INT64]    = int32_to_int64,
		[B_NUMBER_FLOAT32]  = int32_to_float32,
		[B_NUMBER_FLOAT64]  = int32_to_float64,
		[B_NUMBER_CHAR]     = int32_to_char,
		[B_NUMBER_SHORT]    = int32_to_short,
		[B_NUMBER_INT]      = int32_to_int,
		[B_NUMBER_LONG]     = int32_to_long,
		[B_NUMBER_LONGLONG] = int32_to_longlong,
		[B_NUMBER_FLOAT]    = int32_to_float,
		[B_NUMBER_DOUBLE]   = int32_to_double,
		[B_NUMBER_SIZE_T]   = int32_to_size_t,
	},
	/* int64 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT64] = {
		[B_NUMBER_INT8]     = int64_to_int8,
		[B_NUMBER_INT16]    = int64_to_int16,
		[B_NUMBER_INT32]    = int64_to_int32,
		[B_NUMBER_INT64]    = int64_to_int64,
		[B_NUMBER_FLOAT32]  = int64_to_float32,
		[B_NUMBER_FLOAT64]  = int64_to_float64,
		[B_NUMBER_CHAR]     = int64_to_char,
		[B_NUMBER_SHORT]    = int64_to_short,
		[B_NUMBER_INT]      = int64_to_int,
		[B_NUMBER_LONG]     = int64_to_long,
		[B_NUMBER_LONGLONG] = int64_to_longlong,
		[B_NUMBER_FLOAT]    = int64_to_float,
		[B_NUMBER_DOUBLE]   = int64_to_double,
		[B_NUMBER_SIZE_T]   = int64_to_size_t,
	},
	/* float32 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT32] = {
		[B_NUMBER_INT8]     = float32_to_int8,
		[B_NUMBER_INT16]    = float32_to_int16,
		[B_NUMBER_INT32]    = float32_to_int32,
		[B_NUMBER_INT64]    = float32_to_int64,
		[B_NUMBER_FLOAT32]  = float32_to_float32,
		[B_NUMBER_FLOAT64]  = float32_to_float64,
		[B_NUMBER_CHAR]     = float32_to_char,
		[B_NUMBER_SHORT]    = float32_to_short,
		[B_NUMBER_INT]      = float32_to_int,
		[B_NUMBER_LONG]     = float32_to_long,
		[B_NUMBER_LONGLONG] = float32_to_longlong,
		[B_NUMBER_FLOAT]    = float32_to_float,
		[B_NUMBER_DOUBLE]   = float32_to_double,
		[B_NUMBER_SIZE_T]   = float32_to_size_t,
	},
	/* float64 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT64] = {
		[B_NUMBER_INT8]     = float64_to_int8,
		[B_NUMBER_INT16]    = float64_to_int16,
		[B_NUMBER_INT32]    = float64_to_int32,
		[B_NUMBER_INT64]    = float64_to_int64,
		[B_NUMBER_FLOAT32]  = float64_to_float32,
		[B_NUMBER_FLOAT64]  = float64_to_float64,
		[B_NUMBER_CHAR]     = float64_to_char,
		[B_NUMBER_SHORT]    = float64_to_short,
		[B_NUMBER_INT]      = float64_to_int,
		[B_NUMBER_LONG]     = float64_to_long,
		[B_NUMBER_LONGLONG] = float64_to_longlong,
		[B_NUMBER_FLOAT]    = float64_to_float,
		[B_NUMBER_DOUBLE]   = float64_to_double,
		[B_NUMBER_SIZE_T]   = float64_to_size_t,
	},
	/* char > xyz CONVERTER CALLBACKS */
	[B_NUMBER_CHAR] = {
		[B_NUMBER_INT8]     = char_to_int8,
		[B_NUMBER_INT16]    = char_to_int16,
		[B_NUMBER_INT32]    = char_to_int32,
		[B_NUMBER_INT64]    = char_to_int64,
		[B_NUMBER_FLOAT32]  = char_to_float32,
		[B_NUMBER_FLOAT64]  = char_to_float64,
		[B_NUMBER_CHAR]     = char_to_char,
		[B_NUMBER_SHORT]    = char_to_short,
		[B_NUMBER_INT]      = char_to_int,
		[B_NUMBER_LONG]     = char_to_long,
		[B_NUMBER_LONGLONG] = char_to_longlong,
		[B_NUMBER_FLOAT]    = char_to_float,
		[B_NUMBER_DOUBLE]   = char_to_double,
		[B_NUMBER_SIZE_T]   = char_to_size_t,
	},
	/* short -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_SHORT] = {
		[B_NUMBER_INT8]     = short_to_int8,
		[B_NUMBER_INT16]    = short_to_int16,
		[B_NUMBER_INT32]    = short_to_int32,
		[B_NUMBER_INT64]    = short_to_int64,
		[B_NUMBER_FLOAT32]  = short_to_float32,
		[B_NUMBER_FLOAT64]  = short_to_float64,
		[B_NUMBER_CHAR]     = short_to_char,
		[B_NUMBER_SHORT]    = short_to_short,
		[B_NUMBER_INT]      = short_to_int,
		[B_NUMBER_LONG]     = short_to_long,
		[B_NUMBER_LONGLONG] = short_to_longlong,
		[B_NUMBER_FLOAT]    = short_to_float,
		[B_NUMBER_DOUBLE]   = short_to_double,
		[B_NUMBER_SIZE_T]   = short_to_size_t,
	},
	/* int -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT] = {
		[B_NUMBER_INT8]     = int_to_int8,
		[B_NUMBER_INT16]    = int_to_int16,
		[B_NUMBER_INT32]    = int_to_int32,
		[B_NUMBER_INT64]    = int_to_int64,
		[B_NUMBER_FLOAT32]  = int_to_float32,
		[B_NUMBER_FLOAT64]  = int_to_float64,
		[B_NUMBER_CHAR]     = int_to_char,
		[B_NUMBER_SHORT]    = int_to_short,
		[B_NUMBER_INT]      = int_to_int,
		[B_NUMBER_LONG]     = int_to_long,
		[B_NUMBER_LONGLONG] = int_to_longlong,
		[B_NUMBER_FLOAT]    = int_to_float,
		[B_NUMBER_DOUBLE]   = int_to_double,
		[B_NUMBER_SIZE_T]   = int_to_size_t,
	},
	/* long -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_LONG] = {
		[B_NUMBER_INT8]     = long_to_int8,
		[B_NUMBER_INT16]    = long_to_int16,
		[B_NUMBER_INT32]    = long_to_int32,
		[B_NUMBER_INT64]    = long_to_int64,
		[B_NUMBER_FLOAT32]  = long_to_float32,
		[B_NUMBER_FLOAT64]  = long_to_float64,
		[B_NUMBER_CHAR]     = long_to_char,
		[B_NUMBER_SHORT]    = long_to_short,
		[B_NUMBER_INT]      = long_to_int,
		[B_NUMBER_LONG]     = long_to_long,
		[B_NUMBER_LONGLONG] = long_to_longlong,
		[B_NUMBER_FLOAT]    = long_to_float,
		[B_NUMBER_DOUBLE]   = long_to_double,
		[B_NUMBER_SIZE_T]   = long_to_size_t,
	},
	/* longlong -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_LONGLONG] = {
		[B_NUMBER_INT8]     = longlong_to_int8,
		[B_NUMBER_INT16]    = longlong_to_int16,
		[B_NUMBER_INT32]    = longlong_to_int32,
		[B_NUMBER_INT64]    = longlong_to_int64,
		[B_NUMBER_FLOAT32]  = longlong_to_float32,
		[B_NUMBER_FLOAT64]  = longlong_to_float64,
		[B_NUMBER_CHAR]     = longlong_to_char,
		[B_NUMBER_SHORT]    = longlong_to_short,
		[B_NUMBER_INT]      = longlong_to_int,
		[B_NUMBER_LONG]     = longlong_to_long,
		[B_NUMBER_LONGLONG] = longlong_to_longlong,
		[B_NUMBER_FLOAT]    = longlong_to_float,
		[B_NUMBER_DOUBLE]   = longlong_to_double,
		[B_NUMBER_SIZE_T]   = longlong_to_size_t,
	},
	/* float -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT] = {
		[B_NUMBER_INT8]     = float_to_int8,
		[B_NUMBER_INT16]    = float_to_int16,
		[B_NUMBER_INT32]    = float_to_int32,
		[B_NUMBER_INT64]    = float_to_int64,
		[B_NUMBER_FLOAT32]  = float_to_float32,
		[B_NUMBER_FLOAT64]  = float_to_float64,
		[B_NUMBER_CHAR]     = float_to_char,
		[B_NUMBER_SHORT]    = float_to_short,
		[B_NUMBER_INT]      = float_to_int,
		[B_NUMBER_LONG]     = float_to_long,
		[B_NUMBER_LONGLONG] = float_to_longlong,
		[B_NUMBER_FLOAT]    = float_to_float,
		[B_NUMBER_DOUBLE]   = float_to_double,
		[B_NUMBER_SIZE_T]   = float_to_size_t,
	},
	/* double -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_DOUBLE] = {
		[B_NUMBER_INT8]     = double_to_int8,
		[B_NUMBER_INT16]    = double_to_int16,
		[B_NUMBER_INT32]    = double_to_int32,
		[B_NUMBER_INT64]    = double_to_int64,
		[B_NUMBER_FLOAT32]  = double_to_float32,
		[B_NUMBER_FLOAT64]  = double_to_float64,
		[B_NUMBER_CHAR]     = double_to_char,
		[B_NUMBER_SHORT]    = double_to_short,
		[B_NUMBER_INT]      = double_to_int,
		[B_NUMBER_LONG]     = double_to_long,
		[B_NUMBER_LONGLONG] = double_to_longlong,
		[B_NUMBER_FLOAT]    = double_to_float,
		[B_NUMBER_DOUBLE]   = double_to_double,
		[B_NUMBER_SIZE_T]   = double_to_size_t,
	},
	/* size_t -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_SIZE_T] = {
		[B_NUMBER_INT8]     = size_t_to_int8,
		[B_NUMBER_INT16]    = size_t_to_int16,
		[B_NUMBER_INT32]    = size_t_to_int32,
		[B_NUMBER_INT64]    = size_t_to_int64,
		[B_NUMBER_FLOAT32]  = size_t_to_float32,
		[B_NUMBER_FLOAT64]  = size_t_to_float64,
		[B_NUMBER_CHAR]     = size_t_to_char,
		[B_NUMBER_SHORT]    = size_t_to_short,
		[B_NUMBER_INT]      = size_t_to_int,
		[B_NUMBER_LONG]     = size_t_to_long,
		[B_NUMBER_LONGLONG] = size_t_to_longlong,
		[B_NUMBER_FLOAT]    = size_t_to_float,
		[B_NUMBER_DOUBLE]   = size_t_to_double,
		[B_NUMBER_SIZE_T]   = size_t_to_size_t,
	},
};

b_dsref_type_id b_number_type_id(void)
{
	return (b_dsref_type_id)&number_type;
}