255 lines
6.9 KiB
C
255 lines
6.9 KiB
C
#ifndef BLUELIB_NUMBER_H
|
|
#define BLUELIB_NUMBER_H
|
|
|
|
#include <blue/object/object.h>
|
|
#include <blue/object/type.h>
|
|
#include <stdbool.h>
|
|
|
|
#define B_NUMBER(p) ((b_number *)(p))
|
|
|
|
#define B_INT8(v) (b_number_create_int8(v))
|
|
#define B_INT16(v) (b_number_create_int16(v))
|
|
#define B_INT32(v) (b_number_create_int32(v))
|
|
#define B_INT64(v) (b_number_create_int64(v))
|
|
#define B_FLOAT32(v) (b_number_create_float32(v))
|
|
#define B_FLOAT64(v) (b_number_create_float64(v))
|
|
#define B_CHAR(v) (b_number_create_char(v))
|
|
#define B_SHORT(v) (b_number_create_short(v))
|
|
#define B_INT(v) (b_number_create_int(v))
|
|
#define B_LONG(v) (b_number_create_long(v))
|
|
#define B_LONGLONG(v) (b_number_create_longlong(v))
|
|
#define B_FLOAT(v) (b_number_create_float(v))
|
|
#define B_DOUBLE(v) (b_number_create_double(v))
|
|
#define B_SIZE_T(v) (b_number_create_size_t(v))
|
|
|
|
#define B_RV_INT8(v) B_RV(b_number_create_int8(v))
|
|
#define B_RV_INT16(v) B_RV(b_number_create_int16(v))
|
|
#define B_RV_INT32(v) B_RV(b_number_create_int32(v))
|
|
#define B_RV_INT64(v) B_RV(b_number_create_int64(v))
|
|
#define B_RV_FLOAT32(v) B_RV(b_number_create_float32(v))
|
|
#define B_RV_FLOAT64(v) B_RV(b_number_create_float64(v))
|
|
#define B_RV_CHAR(v) B_RV(b_number_create_char(v))
|
|
#define B_RV_SHORT(v) B_RV(b_number_create_short(v))
|
|
#define B_RV_INT(v) B_RV(b_number_create_int(v))
|
|
#define B_RV_LONG(v) B_RV(b_number_create_long(v))
|
|
#define B_RV_LONGLONG(v) B_RV(b_number_create_longlong(v))
|
|
#define B_RV_FLOAT(v) B_RV(b_number_create_float(v))
|
|
#define B_RV_DOUBLE(v) B_RV(b_number_create_double(v))
|
|
#define B_RV_SIZE_T(v) B_RV(b_number_create_size_t(v))
|
|
|
|
#define B_NUMBER_IVAL(p) (b_number_get_size_t(p))
|
|
#define B_NUMBER_FVAL(p) (b_number_get_double(p))
|
|
|
|
typedef struct b_number b_number;
|
|
|
|
typedef enum b_number_type {
|
|
B_NUMBER_INT8,
|
|
B_NUMBER_INT16,
|
|
B_NUMBER_INT32,
|
|
B_NUMBER_INT64,
|
|
B_NUMBER_FLOAT32,
|
|
B_NUMBER_FLOAT64,
|
|
B_NUMBER_CHAR,
|
|
B_NUMBER_SHORT,
|
|
B_NUMBER_INT,
|
|
B_NUMBER_LONG,
|
|
B_NUMBER_LONGLONG,
|
|
B_NUMBER_FLOAT,
|
|
B_NUMBER_DOUBLE,
|
|
B_NUMBER_SIZE_T,
|
|
B_NUMBER_HANDLE,
|
|
B_NUMBER_TYPE_COUNT,
|
|
|
|
B_NUMBER_BYTE = B_NUMBER_INT8,
|
|
B_NUMBER_WORD = B_NUMBER_INT16,
|
|
B_NUMBER_DWORD = B_NUMBER_INT32,
|
|
B_NUMBER_QWORD = B_NUMBER_INT64,
|
|
} b_number_type;
|
|
|
|
BLUE_API b_number *b_number_create(b_number_type type, void *value_ptr);
|
|
static inline b_number *b_number_retain(b_number *number)
|
|
{
|
|
return B_NUMBER(b_retain(B_OBJECT(number)));
|
|
}
|
|
static inline void b_number_release(b_number *number)
|
|
{
|
|
b_release(B_OBJECT(number));
|
|
}
|
|
|
|
static inline b_number *b_number_create_int8(int8_t value)
|
|
{
|
|
return b_number_create(B_NUMBER_INT8, &value);
|
|
}
|
|
static inline b_number *b_number_create_int16(int16_t value)
|
|
{
|
|
return b_number_create(B_NUMBER_INT16, &value);
|
|
}
|
|
static inline b_number *b_number_create_int32(int32_t value)
|
|
{
|
|
return b_number_create(B_NUMBER_INT32, &value);
|
|
}
|
|
static inline b_number *b_number_create_int64(int64_t value)
|
|
{
|
|
return b_number_create(B_NUMBER_INT64, &value);
|
|
}
|
|
static inline b_number *b_number_create_float32(float value)
|
|
{
|
|
return b_number_create(B_NUMBER_FLOAT32, &value);
|
|
}
|
|
static inline b_number *b_number_create_float64(double value)
|
|
{
|
|
return b_number_create(B_NUMBER_FLOAT64, &value);
|
|
}
|
|
static inline b_number *b_number_create_char(char value)
|
|
{
|
|
return b_number_create(B_NUMBER_CHAR, &value);
|
|
}
|
|
static inline b_number *b_number_create_short(short value)
|
|
{
|
|
return b_number_create(B_NUMBER_SHORT, &value);
|
|
}
|
|
static inline b_number *b_number_create_int(int value)
|
|
{
|
|
return b_number_create(B_NUMBER_INT, &value);
|
|
}
|
|
static inline b_number *b_number_create_long(long value)
|
|
{
|
|
return b_number_create(B_NUMBER_LONG, &value);
|
|
}
|
|
static inline b_number *b_number_create_longlong(long long value)
|
|
{
|
|
return b_number_create(B_NUMBER_LONGLONG, &value);
|
|
}
|
|
static inline b_number *b_number_create_float(float value)
|
|
{
|
|
return b_number_create(B_NUMBER_FLOAT, &value);
|
|
}
|
|
static inline b_number *b_number_create_double(double value)
|
|
{
|
|
return b_number_create(B_NUMBER_DOUBLE, &value);
|
|
}
|
|
static inline b_number *b_number_create_size_t(size_t value)
|
|
{
|
|
return b_number_create(B_NUMBER_SIZE_T, &value);
|
|
}
|
|
|
|
BLUE_API b_number_type b_number_get_type(const b_number *number);
|
|
BLUE_API int b_number_get_value(
|
|
const b_number *number, b_number_type type, void *value_ptr);
|
|
|
|
static inline int8_t b_number_get_int8(const b_number *number)
|
|
{
|
|
int8_t v;
|
|
b_number_get_value(number, B_NUMBER_INT8, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline int16_t b_number_get_int16(const b_number *number)
|
|
{
|
|
int16_t v;
|
|
b_number_get_value(number, B_NUMBER_INT16, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline int32_t b_number_get_int32(const b_number *number)
|
|
{
|
|
int32_t v;
|
|
b_number_get_value(number, B_NUMBER_INT32, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline int64_t b_number_get_int64(const b_number *number)
|
|
{
|
|
int64_t v;
|
|
b_number_get_value(number, B_NUMBER_INT64, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline float b_number_get_float32(const b_number *number)
|
|
{
|
|
float v;
|
|
b_number_get_value(number, B_NUMBER_FLOAT32, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline double b_number_get_float64(const b_number *number)
|
|
{
|
|
double v;
|
|
b_number_get_value(number, B_NUMBER_FLOAT64, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline char b_number_get_char(const b_number *number)
|
|
{
|
|
char v;
|
|
b_number_get_value(number, B_NUMBER_CHAR, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline short b_number_get_short(const b_number *number)
|
|
{
|
|
short v;
|
|
b_number_get_value(number, B_NUMBER_SHORT, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline int b_number_get_int(const b_number *number)
|
|
{
|
|
int v;
|
|
b_number_get_value(number, B_NUMBER_INT, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline long b_number_get_long(const b_number *number)
|
|
{
|
|
long v;
|
|
b_number_get_value(number, B_NUMBER_LONG, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline long long b_number_get_longlong(const b_number *number)
|
|
{
|
|
long long v;
|
|
b_number_get_value(number, B_NUMBER_LONGLONG, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline float b_number_get_float(const b_number *number)
|
|
{
|
|
float v;
|
|
b_number_get_value(number, B_NUMBER_FLOAT, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline double b_number_get_double(const b_number *number)
|
|
{
|
|
double v;
|
|
b_number_get_value(number, B_NUMBER_DOUBLE, &v);
|
|
return v;
|
|
}
|
|
|
|
static inline size_t b_number_get_size_t(const b_number *number)
|
|
{
|
|
size_t v;
|
|
b_number_get_value(number, B_NUMBER_SIZE_T, &v);
|
|
return v;
|
|
}
|
|
|
|
BLUE_API bool b_number_is_integer(const b_number *number);
|
|
BLUE_API bool b_number_is_float(const b_number *number);
|
|
BLUE_API bool b_number_is_inf(const b_number *number);
|
|
BLUE_API bool b_number_is_inf_positive(const b_number *number);
|
|
BLUE_API bool b_number_is_inf_negative(const b_number *number);
|
|
BLUE_API bool b_number_is_nan(const b_number *number);
|
|
BLUE_API bool b_number_is_nan_positive(const b_number *number);
|
|
BLUE_API bool b_number_is_nan_negative(const b_number *number);
|
|
|
|
BLUE_API void b_number_set_inf_positive(b_number *number, bool v);
|
|
BLUE_API void b_number_set_inf_negative(b_number *number, bool v);
|
|
BLUE_API void b_number_set_nan_positive(b_number *number, bool v);
|
|
BLUE_API void b_number_set_nan_negative(b_number *number, bool v);
|
|
|
|
BLUE_API size_t b_number_data_size(const b_number *number);
|
|
|
|
#endif
|