1682 lines
43 KiB
C
1682 lines
43 KiB
C
#include "number.h"
|
|
|
|
#include <blue/core/stream.h>
|
|
#include <blue/object/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(const struct b_object *obj, struct b_stream *out);
|
|
|
|
static struct b_object_type number_type = {
|
|
.t_name = "corelib::number",
|
|
.t_flags = B_OBJECT_FUNDAMENTAL,
|
|
.t_id = B_OBJECT_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_object_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(const struct b_object *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_object_type_id b_number_type_id(void)
|
|
{
|
|
return (b_object_type_id)&number_type;
|
|
}
|