2327 lines
58 KiB
C
2327 lines
58 KiB
C
#include <blue/core/stream.h>
|
|
#include <blue/ds/number.h>
|
|
#include <inttypes.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
/*** PRIVATE DATA *************************************************************/
|
|
|
|
enum b_number_flags {
|
|
NUMBER_F_INF = 0x01u,
|
|
NUMBER_F_NAN = 0x02u,
|
|
};
|
|
|
|
struct b_number_p {
|
|
b_number_type n_type;
|
|
enum b_number_flags n_flags;
|
|
union {
|
|
int8_t v_int8;
|
|
int16_t v_int16;
|
|
int32_t v_int32;
|
|
int64_t v_int64;
|
|
float v_float32;
|
|
double v_float64;
|
|
char v_char;
|
|
short v_short;
|
|
int v_int;
|
|
long v_long;
|
|
long long v_longlong;
|
|
float v_float;
|
|
double v_double;
|
|
size_t v_size_t;
|
|
} n_value;
|
|
};
|
|
|
|
typedef int (*number_converter_t)(const struct b_number_p *, void *);
|
|
|
|
static number_converter_t converters[B_NUMBER_TYPE_COUNT][B_NUMBER_TYPE_COUNT];
|
|
|
|
/*** PRIVATE FUNCTIONS ********************************************************/
|
|
|
|
static b_number_type number_get_number_type(const struct b_number_p *number)
|
|
{
|
|
return number->n_type;
|
|
}
|
|
|
|
static int number_get_value(
|
|
const struct b_number_p *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);
|
|
}
|
|
|
|
static bool number_is_integer(const struct b_number_p *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;
|
|
}
|
|
}
|
|
|
|
static bool number_is_float(const struct b_number_p *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;
|
|
}
|
|
}
|
|
|
|
static bool number_is_inf(const struct b_number_p *number)
|
|
{
|
|
return (number->n_flags & NUMBER_F_INF) != 0;
|
|
}
|
|
|
|
static bool number_is_inf_positive(const struct b_number_p *number)
|
|
{
|
|
if (!(number->n_flags & NUMBER_F_INF)) {
|
|
return false;
|
|
}
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
return number->n_value.v_int8 >= 0;
|
|
case B_NUMBER_INT16:
|
|
return number->n_value.v_int16 >= 0;
|
|
case B_NUMBER_INT32:
|
|
return number->n_value.v_int32 >= 0;
|
|
case B_NUMBER_INT64:
|
|
return number->n_value.v_int64 >= 0;
|
|
case B_NUMBER_FLOAT32:
|
|
return number->n_value.v_float32 >= 0;
|
|
case B_NUMBER_FLOAT64:
|
|
return number->n_value.v_float64 >= 0;
|
|
case B_NUMBER_CHAR:
|
|
return number->n_value.v_char >= 0;
|
|
case B_NUMBER_SHORT:
|
|
return number->n_value.v_short >= 0;
|
|
case B_NUMBER_INT:
|
|
return number->n_value.v_int >= 0;
|
|
case B_NUMBER_LONG:
|
|
return number->n_value.v_long >= 0;
|
|
case B_NUMBER_LONGLONG:
|
|
return number->n_value.v_longlong >= 0;
|
|
case B_NUMBER_FLOAT:
|
|
return number->n_value.v_float >= 0;
|
|
case B_NUMBER_DOUBLE:
|
|
return number->n_value.v_double >= 0;
|
|
case B_NUMBER_SIZE_T:
|
|
return number->n_value.v_size_t >= 0;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool number_is_inf_negative(const struct b_number_p *number)
|
|
{
|
|
if (!(number->n_flags & NUMBER_F_INF)) {
|
|
return false;
|
|
}
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
return number->n_value.v_int8 < 0;
|
|
case B_NUMBER_INT16:
|
|
return number->n_value.v_int16 < 0;
|
|
case B_NUMBER_INT32:
|
|
return number->n_value.v_int32 < 0;
|
|
case B_NUMBER_INT64:
|
|
return number->n_value.v_int64 < 0;
|
|
case B_NUMBER_FLOAT32:
|
|
return number->n_value.v_float32 < 0;
|
|
case B_NUMBER_FLOAT64:
|
|
return number->n_value.v_float64 < 0;
|
|
case B_NUMBER_CHAR:
|
|
return number->n_value.v_char < 0;
|
|
case B_NUMBER_SHORT:
|
|
return number->n_value.v_short < 0;
|
|
case B_NUMBER_INT:
|
|
return number->n_value.v_int < 0;
|
|
case B_NUMBER_LONG:
|
|
return number->n_value.v_long < 0;
|
|
case B_NUMBER_LONGLONG:
|
|
return number->n_value.v_longlong < 0;
|
|
case B_NUMBER_FLOAT:
|
|
return number->n_value.v_float < 0;
|
|
case B_NUMBER_DOUBLE:
|
|
return number->n_value.v_double < 0;
|
|
case B_NUMBER_SIZE_T:
|
|
return number->n_value.v_size_t < 0;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool number_is_nan(const struct b_number_p *number)
|
|
{
|
|
return (number->n_flags & NUMBER_F_NAN) != 0;
|
|
}
|
|
|
|
static bool number_is_nan_positive(const struct b_number_p *number)
|
|
{
|
|
if (!(number->n_flags & NUMBER_F_NAN)) {
|
|
return false;
|
|
}
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
return number->n_value.v_int8 >= 0;
|
|
case B_NUMBER_INT16:
|
|
return number->n_value.v_int16 >= 0;
|
|
case B_NUMBER_INT32:
|
|
return number->n_value.v_int32 >= 0;
|
|
case B_NUMBER_INT64:
|
|
return number->n_value.v_int64 >= 0;
|
|
case B_NUMBER_FLOAT32:
|
|
return number->n_value.v_float32 >= 0;
|
|
case B_NUMBER_FLOAT64:
|
|
return number->n_value.v_float64 >= 0;
|
|
case B_NUMBER_CHAR:
|
|
return number->n_value.v_char >= 0;
|
|
case B_NUMBER_SHORT:
|
|
return number->n_value.v_short >= 0;
|
|
case B_NUMBER_INT:
|
|
return number->n_value.v_int >= 0;
|
|
case B_NUMBER_LONG:
|
|
return number->n_value.v_long >= 0;
|
|
case B_NUMBER_LONGLONG:
|
|
return number->n_value.v_longlong >= 0;
|
|
case B_NUMBER_FLOAT:
|
|
return number->n_value.v_float >= 0;
|
|
case B_NUMBER_DOUBLE:
|
|
return number->n_value.v_double >= 0;
|
|
case B_NUMBER_SIZE_T:
|
|
return number->n_value.v_size_t >= 0;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool number_is_nan_negative(const struct b_number_p *number)
|
|
{
|
|
if (!(number->n_flags & NUMBER_F_NAN)) {
|
|
return false;
|
|
}
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
return number->n_value.v_int8 < 0;
|
|
case B_NUMBER_INT16:
|
|
return number->n_value.v_int16 < 0;
|
|
case B_NUMBER_INT32:
|
|
return number->n_value.v_int32 < 0;
|
|
case B_NUMBER_INT64:
|
|
return number->n_value.v_int64 < 0;
|
|
case B_NUMBER_FLOAT32:
|
|
return number->n_value.v_float32 < 0;
|
|
case B_NUMBER_FLOAT64:
|
|
return number->n_value.v_float64 < 0;
|
|
case B_NUMBER_CHAR:
|
|
return number->n_value.v_char < 0;
|
|
case B_NUMBER_SHORT:
|
|
return number->n_value.v_short < 0;
|
|
case B_NUMBER_INT:
|
|
return number->n_value.v_int < 0;
|
|
case B_NUMBER_LONG:
|
|
return number->n_value.v_long < 0;
|
|
case B_NUMBER_LONGLONG:
|
|
return number->n_value.v_longlong < 0;
|
|
case B_NUMBER_FLOAT:
|
|
return number->n_value.v_float < 0;
|
|
case B_NUMBER_DOUBLE:
|
|
return number->n_value.v_double < 0;
|
|
case B_NUMBER_SIZE_T:
|
|
return number->n_value.v_size_t < 0;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static void number_set_inf_positive(struct b_number_p *number, bool v)
|
|
{
|
|
if (!v) {
|
|
number->n_flags &= ~NUMBER_F_INF;
|
|
return;
|
|
}
|
|
|
|
number->n_flags &= ~NUMBER_F_NAN;
|
|
number->n_flags |= NUMBER_F_INF;
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
number->n_value.v_int8 = 0;
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
number->n_value.v_int16 = 0;
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
number->n_value.v_int32 = 0;
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
number->n_value.v_int64 = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
number->n_value.v_float32 = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
number->n_value.v_float64 = 0;
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
number->n_value.v_char = 0;
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
number->n_value.v_short = 0;
|
|
break;
|
|
case B_NUMBER_INT:
|
|
number->n_value.v_int = 0;
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
number->n_value.v_long = 0;
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
number->n_value.v_longlong = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
number->n_value.v_float = 0;
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
number->n_value.v_double = 0;
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
number->n_value.v_size_t = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void number_set_inf_negative(struct b_number_p *number, bool v)
|
|
{
|
|
if (!v) {
|
|
number->n_flags &= ~NUMBER_F_INF;
|
|
return;
|
|
}
|
|
|
|
number->n_flags &= ~NUMBER_F_NAN;
|
|
number->n_flags |= NUMBER_F_INF;
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
number->n_value.v_int8 = -1;
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
number->n_value.v_int16 = -1;
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
number->n_value.v_int32 = -1;
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
number->n_value.v_int64 = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
number->n_value.v_float32 = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
number->n_value.v_float64 = -1;
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
number->n_value.v_char = -1;
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
number->n_value.v_short = -1;
|
|
break;
|
|
case B_NUMBER_INT:
|
|
number->n_value.v_int = -1;
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
number->n_value.v_long = -1;
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
number->n_value.v_longlong = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
number->n_value.v_float = -1;
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
number->n_value.v_double = -1;
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
number->n_value.v_size_t = -1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void number_set_nan_positive(struct b_number_p *number, bool v)
|
|
{
|
|
if (!v) {
|
|
number->n_flags &= ~NUMBER_F_NAN;
|
|
return;
|
|
}
|
|
|
|
number->n_flags &= ~NUMBER_F_INF;
|
|
number->n_flags |= NUMBER_F_NAN;
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
number->n_value.v_int8 = 0;
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
number->n_value.v_int16 = 0;
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
number->n_value.v_int32 = 0;
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
number->n_value.v_int64 = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
number->n_value.v_float32 = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
number->n_value.v_float64 = 0;
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
number->n_value.v_char = 0;
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
number->n_value.v_short = 0;
|
|
break;
|
|
case B_NUMBER_INT:
|
|
number->n_value.v_int = 0;
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
number->n_value.v_long = 0;
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
number->n_value.v_longlong = 0;
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
number->n_value.v_float = 0;
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
number->n_value.v_double = 0;
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
number->n_value.v_size_t = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void number_set_nan_negative(struct b_number_p *number, bool v)
|
|
{
|
|
if (!v) {
|
|
number->n_flags &= ~NUMBER_F_NAN;
|
|
return;
|
|
}
|
|
|
|
number->n_flags &= ~NUMBER_F_INF;
|
|
number->n_flags |= NUMBER_F_NAN;
|
|
|
|
switch (number->n_type) {
|
|
case B_NUMBER_INT8:
|
|
number->n_value.v_int8 = -1;
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
number->n_value.v_int16 = -1;
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
number->n_value.v_int32 = -1;
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
number->n_value.v_int64 = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
number->n_value.v_float32 = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
number->n_value.v_float64 = -1;
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
number->n_value.v_char = -1;
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
number->n_value.v_short = -1;
|
|
break;
|
|
case B_NUMBER_INT:
|
|
number->n_value.v_int = -1;
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
number->n_value.v_long = -1;
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
number->n_value.v_longlong = -1;
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
number->n_value.v_float = -1;
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
number->n_value.v_double = -1;
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
number->n_value.v_size_t = -1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static size_t number_data_size(const struct b_number_p *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 print_inf(const struct b_number_p *n, struct b_stream *out)
|
|
{
|
|
switch (n->n_type) {
|
|
case B_NUMBER_INT8:
|
|
b_stream_write_string(out, n->n_value.v_int8 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
b_stream_write_string(out, n->n_value.v_int16 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
b_stream_write_string(out, n->n_value.v_int32 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
b_stream_write_string(out, n->n_value.v_int64 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_float32 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_float64 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
b_stream_write_string(out, n->n_value.v_char < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
b_stream_write_string(out, n->n_value.v_short < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT:
|
|
b_stream_write_string(out, n->n_value.v_int < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
b_stream_write_string(out, n->n_value.v_long < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_longlong < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
b_stream_write_string(out, n->n_value.v_float < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
b_stream_write_string(out, n->n_value.v_double < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
b_stream_write_string(out, n->n_value.v_size_t < 0 ? "-" : "", NULL);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
b_stream_write_string(out, "INF", NULL);
|
|
}
|
|
|
|
static void print_nan(const struct b_number_p *n, struct b_stream *out)
|
|
{
|
|
switch (n->n_type) {
|
|
case B_NUMBER_INT8:
|
|
b_stream_write_string(out, n->n_value.v_int8 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
b_stream_write_string(out, n->n_value.v_int16 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
b_stream_write_string(out, n->n_value.v_int32 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
b_stream_write_string(out, n->n_value.v_int64 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_float32 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_float64 < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
b_stream_write_string(out, n->n_value.v_char < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
b_stream_write_string(out, n->n_value.v_short < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_INT:
|
|
b_stream_write_string(out, n->n_value.v_int < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
b_stream_write_string(out, n->n_value.v_long < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
b_stream_write_string(
|
|
out, n->n_value.v_longlong < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
b_stream_write_string(out, n->n_value.v_float < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
b_stream_write_string(out, n->n_value.v_double < 0 ? "-" : "", NULL);
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
b_stream_write_string(out, n->n_value.v_size_t < 0 ? "-" : "", NULL);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
b_stream_write_string(out, "NaN", NULL);
|
|
}
|
|
|
|
/*** PUBLIC FUNCTIONS *********************************************************/
|
|
|
|
b_number *b_number_create(b_number_type type, void *value_ptr)
|
|
{
|
|
b_number *n = b_object_create(B_TYPE_NUMBER);
|
|
if (!n) {
|
|
return NULL;
|
|
}
|
|
|
|
struct b_number_p *p = b_object_get_private(n, B_TYPE_NUMBER);
|
|
|
|
p->n_type = type;
|
|
|
|
if (!value_ptr) {
|
|
return n;
|
|
}
|
|
|
|
switch (p->n_type) {
|
|
case B_NUMBER_INT8:
|
|
memcpy(&p->n_value.v_int8, value_ptr, sizeof p->n_value.v_int8);
|
|
break;
|
|
case B_NUMBER_INT16:
|
|
memcpy(&p->n_value.v_int16, value_ptr, sizeof p->n_value.v_int16);
|
|
break;
|
|
case B_NUMBER_INT32:
|
|
memcpy(&p->n_value.v_int32, value_ptr, sizeof p->n_value.v_int32);
|
|
break;
|
|
case B_NUMBER_INT64:
|
|
memcpy(&p->n_value.v_int64, value_ptr, sizeof p->n_value.v_int64);
|
|
break;
|
|
case B_NUMBER_FLOAT32:
|
|
memcpy(&p->n_value.v_float32, value_ptr,
|
|
sizeof p->n_value.v_float32);
|
|
break;
|
|
case B_NUMBER_FLOAT64:
|
|
memcpy(&p->n_value.v_float64, value_ptr,
|
|
sizeof p->n_value.v_float64);
|
|
break;
|
|
case B_NUMBER_CHAR:
|
|
memcpy(&p->n_value.v_char, value_ptr, sizeof p->n_value.v_char);
|
|
break;
|
|
case B_NUMBER_SHORT:
|
|
memcpy(&p->n_value.v_short, value_ptr, sizeof p->n_value.v_short);
|
|
break;
|
|
case B_NUMBER_INT:
|
|
memcpy(&p->n_value.v_int, value_ptr, sizeof p->n_value.v_int);
|
|
break;
|
|
case B_NUMBER_LONG:
|
|
memcpy(&p->n_value.v_long, value_ptr, sizeof p->n_value.v_long);
|
|
break;
|
|
case B_NUMBER_LONGLONG:
|
|
memcpy(&p->n_value.v_longlong, value_ptr,
|
|
sizeof p->n_value.v_longlong);
|
|
break;
|
|
case B_NUMBER_FLOAT:
|
|
memcpy(&p->n_value.v_float, value_ptr, sizeof p->n_value.v_float);
|
|
break;
|
|
case B_NUMBER_DOUBLE:
|
|
memcpy(&p->n_value.v_double, value_ptr, sizeof p->n_value.v_double);
|
|
break;
|
|
case B_NUMBER_SIZE_T:
|
|
memcpy(&p->n_value.v_size_t, value_ptr, sizeof p->n_value.v_size_t);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
b_number_type b_number_get_number_type(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_get_number_type, number);
|
|
}
|
|
|
|
int b_number_get_value(const b_number *number, b_number_type type, void *value_ptr)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(
|
|
B_TYPE_NUMBER, number_get_value, number, type, value_ptr);
|
|
}
|
|
|
|
bool b_number_is_integer(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_integer, number);
|
|
}
|
|
|
|
bool b_number_is_float(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_float, number);
|
|
}
|
|
|
|
bool b_number_is_inf(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf, number);
|
|
}
|
|
|
|
bool b_number_is_inf_positive(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf_positive, number);
|
|
}
|
|
|
|
bool b_number_is_inf_negative(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf_negative, number);
|
|
}
|
|
|
|
bool b_number_is_nan(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan, number);
|
|
}
|
|
|
|
bool b_number_is_nan_positive(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan_positive, number);
|
|
}
|
|
|
|
bool b_number_is_nan_negative(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan_negative, number);
|
|
}
|
|
|
|
void b_number_set_inf_positive(b_number *number, bool v)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_inf_positive, number, v);
|
|
}
|
|
|
|
void b_number_set_inf_negative(b_number *number, bool v)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_inf_negative, number, v);
|
|
}
|
|
|
|
void b_number_set_nan_positive(b_number *number, bool v)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_nan_positive, number, v);
|
|
}
|
|
|
|
void b_number_set_nan_negative(b_number *number, bool v)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_nan_negative, number, v);
|
|
}
|
|
|
|
size_t b_number_data_size(const b_number *number)
|
|
{
|
|
B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_data_size, number);
|
|
}
|
|
|
|
/*** VIRTUAL FUNCTIONS ********************************************************/
|
|
|
|
static void number_init(b_object *obj, void *priv)
|
|
{
|
|
struct b_number_p *number = priv;
|
|
}
|
|
|
|
static void number_fini(b_object *obj, void *priv)
|
|
{
|
|
struct b_number_p *number = priv;
|
|
}
|
|
|
|
static void number_to_string(const b_object *obj, struct b_stream *out)
|
|
{
|
|
struct b_number_p *number = b_object_get_private(obj, B_TYPE_NUMBER);
|
|
|
|
if (number->n_flags & NUMBER_F_INF) {
|
|
print_inf(number, out);
|
|
return;
|
|
}
|
|
|
|
if (number->n_flags & NUMBER_F_NAN) {
|
|
print_nan(number, out);
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*** CLASS DEFINITION *********************************************************/
|
|
|
|
B_TYPE_CLASS_DEFINITION_BEGIN(b_number)
|
|
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
|
|
B_INTERFACE_ENTRY(to_string) = number_to_string;
|
|
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
|
|
B_TYPE_CLASS_DEFINITION_END(b_number)
|
|
|
|
B_TYPE_DEFINITION_BEGIN(b_number)
|
|
B_TYPE_ID(0xa713b0ea, 0x240f, 0x4bc5, 0xbe73, 0xbc3e56401bd3);
|
|
B_TYPE_CLASS(b_number_class);
|
|
B_TYPE_INSTANCE_PRIVATE(struct b_number_p);
|
|
B_TYPE_INSTANCE_INIT(number_init);
|
|
B_TYPE_INSTANCE_FINI(number_fini);
|
|
B_TYPE_DEFINITION_END(b_number)
|
|
|
|
/*** MISC FUNCTIONS ***********************************************************/
|
|
|
|
/* ++++++++++++++++++ int8 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */
|
|
|
|
static int int8_to_int8(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_int16(const struct b_number_p *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_p *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_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = (short)number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = (int)number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = (long)number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_longlong(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int8;
|
|
return 0;
|
|
}
|
|
|
|
static int int8_to_size_t(const struct b_number_p *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_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = (char)number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int16;
|
|
return 0;
|
|
}
|
|
|
|
static int int16_to_size_t(const struct b_number_p *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_p *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_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = (float)number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = (char)number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = (short)number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = (float)number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int32;
|
|
return 0;
|
|
}
|
|
|
|
static int int32_to_size_t(const struct b_number_p *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_p *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_p *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_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = (float)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = (double)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = (char)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = (short)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = (int)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = (float)number->n_value.v_int64;
|
|
return 0;
|
|
}
|
|
|
|
static int int64_to_double(const struct b_number_p *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_p *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_p *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_p *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_p *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_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = (char)number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = (short)number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = (int)number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float32;
|
|
return 0;
|
|
}
|
|
|
|
static int float32_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float64;
|
|
return 0;
|
|
}
|
|
|
|
static int float64_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_char;
|
|
return 0;
|
|
}
|
|
|
|
static int char_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_short;
|
|
return 0;
|
|
}
|
|
|
|
static int short_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_int;
|
|
return 0;
|
|
}
|
|
|
|
static int int_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_long;
|
|
return 0;
|
|
}
|
|
|
|
static int long_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_longlong;
|
|
return 0;
|
|
}
|
|
|
|
static int longlong_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_float;
|
|
return 0;
|
|
}
|
|
|
|
static int float_to_size_t(const struct b_number_p *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_p *number, void *value_ptr)
|
|
{
|
|
*(int8_t *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_int16(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int16_t *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_int32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int32_t *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_int64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int64_t *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_float32(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_float64(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_char(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(char *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_short(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(short *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_int(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(int *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_long(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_longlong(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(long long *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_float(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(float *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_double(const struct b_number_p *number, void *value_ptr)
|
|
{
|
|
*(double *)value_ptr = number->n_value.v_double;
|
|
return 0;
|
|
}
|
|
|
|
static int double_to_size_t(const struct b_number_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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_p *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,
|
|
},
|
|
};
|