From bc902047d3018a143c7d5a9583007a8f1ec6437d Mon Sep 17 00:00:00 2001 From: Max Wash Date: Mon, 25 May 2026 17:19:51 +0100 Subject: [PATCH] fx: implement value conversion interface --- fx/bool.c | 69 +++++- fx/cstr.c | 539 +++++++++++++++++++++++++++++++++++++++---- fx/float/double.c | 84 ++++++- fx/float/float.c | 84 ++++++- fx/include/fx/cstr.h | 6 +- fx/int/byte.c | 87 ++++++- fx/int/convert.h | 81 +++++++ fx/int/i16.c | 90 +++++++- fx/int/i32.c | 88 ++++++- fx/int/i64.c | 89 ++++++- fx/int/int.c | 87 ++++++- fx/int/iptr.c | 87 ++++++- fx/int/long.c | 87 ++++++- fx/int/longlong.c | 87 ++++++- fx/int/sbyte.c | 87 ++++++- fx/int/short.c | 86 ++++++- fx/int/size.c | 87 ++++++- fx/int/u16.c | 89 ++++++- fx/int/u32.c | 89 ++++++- fx/int/u64.c | 89 ++++++- fx/int/uint.c | 87 ++++++- fx/int/ulong.c | 87 ++++++- fx/int/ulonglong.c | 87 ++++++- fx/int/uptr.c | 87 ++++++- fx/int/ushort.c | 87 ++++++- 25 files changed, 2450 insertions(+), 77 deletions(-) create mode 100644 fx/int/convert.h diff --git a/fx/bool.c b/fx/bool.c index d544c0b..c9fec73 100644 --- a/fx/bool.c +++ b/fx/bool.c @@ -1,18 +1,85 @@ +#include "int/convert.h" + #include #include #include +HASH(bool) + +GENERIC_CONVERT(bool, i16, i16) +GENERIC_CONVERT(bool, u16, u16) +GENERIC_CONVERT(bool, i32, i32) +GENERIC_CONVERT(bool, u32, u32) +GENERIC_CONVERT(bool, i64, i64) +GENERIC_CONVERT(bool, u64, u64) +GENERIC_CONVERT(bool, iptr, iptr) +GENERIC_CONVERT(bool, uptr, uptr) +GENERIC_CONVERT(bool, sbyte, sbyte) +GENERIC_CONVERT(bool, byte, byte) +GENERIC_CONVERT(bool, short, short) +GENERIC_CONVERT(bool, ushort, unsigned short) +GENERIC_CONVERT(bool, int, int) +GENERIC_CONVERT(bool, uint, unsigned int) +GENERIC_CONVERT(bool, long, long) +GENERIC_CONVERT(bool, ulong, unsigned long) +GENERIC_CONVERT(bool, longlong, long long) +GENERIC_CONVERT(bool, ulonglong, unsigned long long) +GENERIC_CONVERT(bool, size, size_t) +GENERIC_CONVERT(bool, float, float) +GENERIC_CONVERT(bool, double, double) + +COMPARE(bool, bool) + +static fx_status to_string( + const fx_value *v, + fx_stream *out, + const char *format) +{ + return fx_stream_write_cstr(out, v->v_bool ? "true" : "false", NULL); +} + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_bool) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_bool) FX_TYPE_DEFINITION_BEGIN(fx_bool) __FX_VALUE_TYPE_ID(BOOL); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.bool"); FX_TYPE_CLASS(fx_bool_class); FX_TYPE_INSTANCE_PRIVATE(bool); diff --git a/fx/cstr.c b/fx/cstr.c index 8a5fccd..e6535c7 100644 --- a/fx/cstr.c +++ b/fx/cstr.c @@ -1,18 +1,498 @@ #include +#include +#include #include +#include +#include +#include #include +#include +#include +#include + +static fx_status to_string( + const fx_value *v, + fx_stream *out, + const char *format) +{ + if (!v->v_cstr) { + return FX_SUCCESS; + } + + return fx_stream_write_fmt(out, NULL, "%s", v->v_cstr); +} + +static i32 compare(const fx_value *left, const fx_value *right) +{ + const char *s; + if (!FX_OK(fx_value_get_cstr(right, &s))) { + return -1; + } + + return strcmp(left->v_cstr, s); +} + +static fx_status hash(const fx_value *v, uint64_t *out_hash) +{ + *out_hash = fx_hash_cstr(v->v_cstr); + return FX_SUCCESS; +} + +fx_status cstr_to_char(const char *in, fx_wchar *out) +{ + if (in[0] == '\0' || in[1] == '\0') { + *out = in[0]; + return FX_SUCCESS; + } + + return FX_ERR_BAD_STATE; +} + +fx_status cstr_to_bool(const char *in, bool *out) +{ + if (!strcmp(in, "1") || !strcmp(in, "true") || strcmp(in, "True")) { + *out = true; + return FX_SUCCESS; + } else if ( + !strcmp(in, "0") || !strcmp(in, "false") + || strcmp(in, "False")) { + *out = false; + return FX_SUCCESS; + } + + return FX_ERR_BAD_STATE; +} + +fx_status cstr_to_i16(const char *in, i16 *out) +{ + char *ep; + long v = strtol(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < INT16_MIN || v > INT16_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (i16)v; + return FX_SUCCESS; +} + +fx_status cstr_to_u16(const char *in, u16 *out) +{ + char *ep; + unsigned long v = strtoul(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINT16_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (u16)v; + return FX_SUCCESS; +} + +fx_status cstr_to_i32(const char *in, i32 *out) +{ + char *ep; + long long v = strtoll(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < INT32_MIN || v > INT32_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (i32)v; + return FX_SUCCESS; +} + +fx_status cstr_to_u32(const char *in, u32 *out) +{ + char *ep; + unsigned long long v = strtoull(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINT32_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (u32)v; + return FX_SUCCESS; +} + +fx_status cstr_to_i64(const char *in, i64 *out) +{ + char *ep; + long long v = strtoll(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < INT64_MIN || v > INT64_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (i64)v; + return FX_SUCCESS; +} + +fx_status cstr_to_u64(const char *in, u64 *out) +{ + char *ep; + unsigned long long v = strtoull(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINT64_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (u16)v; + return FX_SUCCESS; +} + +fx_status cstr_to_iptr(const char *in, iptr *out) +{ + char *ep; + intptr_t v = strtoimax(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < INTPTR_MIN || v > INTPTR_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (iptr)v; + return FX_SUCCESS; +} + +fx_status cstr_to_uptr(const char *in, uptr *out) +{ + char *ep; + uintptr_t v = strtoumax(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINTPTR_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (uptr)v; + return FX_SUCCESS; +} + +fx_status cstr_to_sbyte(const char *in, sbyte *out) +{ + char *ep; + long v = strtol(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > INT8_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (sbyte)v; + return FX_SUCCESS; +} + +fx_status cstr_to_byte(const char *in, byte *out) +{ + char *ep; + unsigned long v = strtoul(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINT8_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (byte)v; + return FX_SUCCESS; +} + +fx_status cstr_to_short(const char *in, short *out) +{ + char *ep; + long v = strtol(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < SHRT_MIN || v > SHRT_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (short)v; + return FX_SUCCESS; +} + +fx_status cstr_to_ushort(const char *in, unsigned short *out) +{ + char *ep; + unsigned long v = strtoul(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > USHRT_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (unsigned short)v; + return FX_SUCCESS; +} + +fx_status cstr_to_int(const char *in, int *out) +{ + char *ep; + long v = strtol(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < INT_MIN || v > INT_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (int)v; + return FX_SUCCESS; +} + +fx_status cstr_to_uint(const char *in, unsigned int *out) +{ + char *ep; + unsigned long v = strtoul(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > UINT_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (unsigned int)v; + return FX_SUCCESS; +} + +fx_status cstr_to_long(const char *in, long *out) +{ + char *ep; + long long v = strtoll(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < LONG_MIN || v > LONG_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (long)v; + return FX_SUCCESS; +} + +fx_status cstr_to_ulong(const char *in, unsigned long *out) +{ + char *ep; + unsigned long long v = strtoull(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > ULONG_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (unsigned long)v; + return FX_SUCCESS; +} + +fx_status cstr_to_longlong(const char *in, long long *out) +{ + char *ep; + long long v = strtoll(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v < LLONG_MIN || v > LLONG_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (long long)v; + return FX_SUCCESS; +} + +fx_status cstr_to_ulonglong(const char *in, unsigned long long *out) +{ + char *ep; + unsigned long long v = strtoull(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > ULLONG_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (unsigned long long)v; + return FX_SUCCESS; +} + +fx_status cstr_to_size(const char *in, size_t *out) +{ + char *ep; + unsigned long long v = strtoull(in, &ep, 0); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + if (v > SIZE_T_MAX) { + return FX_ERR_BAD_STATE; + } + + *out = (size_t)v; + return FX_SUCCESS; +} + +fx_status cstr_to_float(const char *in, float *out) +{ + char *ep; + float v = strtof(in, &ep); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + *out = v; + return FX_SUCCESS; +} + +fx_status cstr_to_double(const char *in, double *out) +{ + char *ep; + double v = strtod(in, &ep); + if (*ep) { + return FX_ERR_BAD_STATE; + } + + *out = v; + return FX_SUCCESS; +} + +fx_status cstr_to_cstr(const char *in, const char **out) +{ + *out = in; + return FX_SUCCESS; +} + +#define CSTR_CONVERTER(fx_type, c_type) \ + static fx_status to_##fx_type(const fx_value *in, c_type *out) \ + { \ + const char *s = NULL; \ + fx_value_get_cstr(in, &s); \ + return cstr_to_##fx_type(s, out); \ + } + +CSTR_CONVERTER(bool, bool) +CSTR_CONVERTER(i16, i16) +CSTR_CONVERTER(u16, u16) +CSTR_CONVERTER(i32, i32) +CSTR_CONVERTER(u32, u32) +CSTR_CONVERTER(i64, i64) +CSTR_CONVERTER(u64, u64) +CSTR_CONVERTER(iptr, iptr) +CSTR_CONVERTER(uptr, uptr) +CSTR_CONVERTER(sbyte, sbyte) +CSTR_CONVERTER(byte, byte) +CSTR_CONVERTER(short, short) +CSTR_CONVERTER(ushort, unsigned short) +CSTR_CONVERTER(int, int) +CSTR_CONVERTER(uint, unsigned int) +CSTR_CONVERTER(long, long) +CSTR_CONVERTER(ulong, unsigned long) +CSTR_CONVERTER(longlong, long long) +CSTR_CONVERTER(ulonglong, unsigned long long) +CSTR_CONVERTER(size, size_t) +CSTR_CONVERTER(float, float) +CSTR_CONVERTER(double, double) +CSTR_CONVERTER(cstr, const char *) + +static fx_status add(const fx_value *l, const fx_value *r, fx_value *out) +{ + const char *left = l->v_cstr; + const char *right = r->v_cstr; + fx_string *result = fx_string_create_from_cstr(left); + if (!result) { + return FX_ERR_NO_MEMORY; + } + + fx_string_append_cstr(result, right); + *out = FX_VALUE_OBJECT(result); + + return FX_SUCCESS; +} /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_cstr) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_INTERFACE_ENTRY(c_to_cstr) = to_cstr; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_cstr) FX_TYPE_DEFINITION_BEGIN(fx_cstr) __FX_VALUE_TYPE_ID(CSTR); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.cstr"); FX_TYPE_CLASS(fx_cstr_class); FX_TYPE_INSTANCE_PRIVATE(char *); @@ -70,64 +550,23 @@ size_t fx_strlen(const char *s, fx_strlen_flags flags) return out; } -int fx_wstrcmp(const fx_wchar *a, const fx_wchar *b) -{ - int i; - for (i = 0; a[i] == b[i]; i++) - if (a[i] == '\0') - return 0; - - return a[i] - b[i]; -} - -int fx_wastrcmp(const char *a, const fx_wchar *b) +size_t fx_strcmp_nocase(const char *a, const char *b) { while (1) { - fx_wchar ch_a = fx_wchar_utf8_codepoint_decode(a); - fx_wchar ch_b = *b; + char ch_a = tolower(*a); + char ch_b = tolower(*b); + + if (!ch_a && !ch_b) { + break; + } if (ch_a != ch_b) { return ch_a - ch_b; } - a += fx_wchar_utf8_codepoint_stride(a); + a++; b++; } return 0; } - -fx_wchar *fx_wstrdup(const fx_wchar *s) -{ - size_t len = fx_wstrlen(s); - fx_wchar *buf = calloc(len + 1, sizeof(fx_wchar)); - if (!buf) { - return NULL; - } - - memcpy(buf, s, len * sizeof(fx_wchar)); - - return buf; -} - -size_t fx_wstrlen(const fx_wchar *s) -{ - size_t len; - for (len = 0; s[len] != 0; len++) - ; - return len; -} - -size_t fx_wstrcspn(const fx_wchar *dest, const fx_wchar *src) -{ - size_t i = 0; - for (i = 0; dest[i]; i++) { - for (size_t ii = 0; src[ii]; ii++) { - if (dest[i] == src[ii]) { - return i; - } - } - } - - return i; -} diff --git a/fx/float/double.c b/fx/float/double.c index 5f5f6b2..6737e9f 100644 --- a/fx/float/double.c +++ b/fx/float/double.c @@ -1,17 +1,99 @@ +#include "../int/convert.h" + #include #include +BOOL_CONVERT(double) +GENERIC_CONVERT(double, i16, i16) +GENERIC_CONVERT(double, u16, u16) +GENERIC_CONVERT(double, i32, i32) +GENERIC_CONVERT(double, u32, u32) +GENERIC_CONVERT(double, i64, i64) +GENERIC_CONVERT(double, u64, u64) +GENERIC_CONVERT(double, iptr, iptr) +GENERIC_CONVERT(double, uptr, uptr) +GENERIC_CONVERT(double, sbyte, sbyte) +GENERIC_CONVERT(double, byte, byte) +GENERIC_CONVERT(double, short, short) +GENERIC_CONVERT(double, ushort, unsigned short) +GENERIC_CONVERT(double, int, int) +GENERIC_CONVERT(double, uint, unsigned int) +GENERIC_CONVERT(double, long, long) +GENERIC_CONVERT(double, ulong, unsigned long) +GENERIC_CONVERT(double, longlong, long long) +GENERIC_CONVERT(double, ulonglong, unsigned long long) +GENERIC_CONVERT(double, size, size_t) +GENERIC_CONVERT(double, float, float) + +TO_STRING(double, "%g") + +BINARY_OP(add, +, double) +BINARY_OP(subtract, -, double) +BINARY_OP(multiply, *, double) +BINARY_OP(divide, /, double) +PREFIX_OP(increment, ++, double) +PREFIX_OP(decrement, --, double) +IN_PLACE_OP(add_in_place, +=, double) +IN_PLACE_OP(subtract_in_place, -=, double) +IN_PLACE_OP(multiply_in_place, *=, double) +IN_PLACE_OP(divide_in_place, /=, double) + +COMPARE(double, double) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_double) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_double) FX_TYPE_DEFINITION_BEGIN(fx_double) __FX_VALUE_TYPE_ID(DOUBLE); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); FX_TYPE_NAME("fx.double"); FX_TYPE_CLASS(fx_double_class); FX_TYPE_INSTANCE_PRIVATE(double); diff --git a/fx/float/float.c b/fx/float/float.c index 66bc39e..7cdfc25 100644 --- a/fx/float/float.c +++ b/fx/float/float.c @@ -1,17 +1,99 @@ +#include "../int/convert.h" + #include #include +TO_STRING(float, "%g") + +BOOL_CONVERT(float) +GENERIC_CONVERT(float, i16, i16) +GENERIC_CONVERT(float, u16, u16) +GENERIC_CONVERT(float, i32, i32) +GENERIC_CONVERT(float, u32, u32) +GENERIC_CONVERT(float, i64, i64) +GENERIC_CONVERT(float, u64, u64) +GENERIC_CONVERT(float, iptr, iptr) +GENERIC_CONVERT(float, uptr, uptr) +GENERIC_CONVERT(float, sbyte, sbyte) +GENERIC_CONVERT(float, byte, byte) +GENERIC_CONVERT(float, short, short) +GENERIC_CONVERT(float, ushort, unsigned short) +GENERIC_CONVERT(float, int, int) +GENERIC_CONVERT(float, uint, unsigned int) +GENERIC_CONVERT(float, long, long) +GENERIC_CONVERT(float, ulong, unsigned long) +GENERIC_CONVERT(float, longlong, long long) +GENERIC_CONVERT(float, ulonglong, unsigned long long) +GENERIC_CONVERT(float, size, size_t) +GENERIC_CONVERT(float, double, double) + +BINARY_OP(add, +, float) +BINARY_OP(subtract, -, float) +BINARY_OP(multiply, *, float) +BINARY_OP(divide, /, float) +PREFIX_OP(increment, ++, float) +PREFIX_OP(decrement, --, float) +IN_PLACE_OP(add_in_place, +=, float) +IN_PLACE_OP(subtract_in_place, -=, float) +IN_PLACE_OP(multiply_in_place, *=, float) +IN_PLACE_OP(divide_in_place, /=, float) + +COMPARE(float, float) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_float) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_float) FX_TYPE_DEFINITION_BEGIN(fx_float) __FX_VALUE_TYPE_ID(FLOAT); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); FX_TYPE_NAME("fx.float"); FX_TYPE_CLASS(fx_float_class); FX_TYPE_INSTANCE_PRIVATE(float); diff --git a/fx/include/fx/cstr.h b/fx/include/fx/cstr.h index 78a67d2..5cfd2e2 100644 --- a/fx/include/fx/cstr.h +++ b/fx/include/fx/cstr.h @@ -24,11 +24,7 @@ FX_API fx_type_id fx_cstr_get_type(void); FX_API char *fx_strdup(const char *s); FX_API size_t fx_strlen(const char *s, fx_strlen_flags flags); -FX_API int fx_wstrcmp(const fx_wchar *a, const fx_wchar *b); -FX_API int fx_wastrcmp(const char *a, const fx_wchar *b); -FX_API fx_wchar *fx_wstrdup(const fx_wchar *s); -FX_API size_t fx_wstrlen(const fx_wchar *s); -FX_API size_t fx_wstrcspn(const fx_wchar *dest, const fx_wchar *src); +FX_API size_t fx_strcmp_nocase(const char *a, const char *b); FX_DECLS_END; diff --git a/fx/int/byte.c b/fx/int/byte.c index 2d3232f..0f3eaa4 100644 --- a/fx/int/byte.c +++ b/fx/int/byte.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(byte) +TO_STRING(byte, "%u") + +BOOL_CONVERT(byte) +GENERIC_CONVERT(byte, i16, i16) +GENERIC_CONVERT(byte, u16, u16) +GENERIC_CONVERT(byte, i32, i32) +GENERIC_CONVERT(byte, u32, u32) +GENERIC_CONVERT(byte, i64, i64) +GENERIC_CONVERT(byte, u64, u64) +GENERIC_CONVERT(byte, iptr, iptr) +GENERIC_CONVERT(byte, uptr, uptr) +GENERIC_CONVERT(byte, sbyte, sbyte) +GENERIC_CONVERT(byte, short, short) +GENERIC_CONVERT(byte, ushort, unsigned short) +GENERIC_CONVERT(byte, int, int) +GENERIC_CONVERT(byte, uint, unsigned int) +GENERIC_CONVERT(byte, long, long) +GENERIC_CONVERT(byte, ulong, unsigned long) +GENERIC_CONVERT(byte, longlong, long long) +GENERIC_CONVERT(byte, ulonglong, unsigned long long) +GENERIC_CONVERT(byte, size, size_t) +GENERIC_CONVERT(byte, float, float) +GENERIC_CONVERT(byte, double, double) + +BINARY_OP(add, +, byte) +BINARY_OP(subtract, -, byte) +BINARY_OP(multiply, *, byte) +BINARY_OP(divide, /, byte) +PREFIX_OP(increment, ++, byte) +PREFIX_OP(decrement, --, byte) +IN_PLACE_OP(add_in_place, +=, byte) +IN_PLACE_OP(subtract_in_place, -=, byte) +IN_PLACE_OP(multiply_in_place, *=, byte) +IN_PLACE_OP(divide_in_place, /=, byte) + +COMPARE(byte, byte) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_byte) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_byte) FX_TYPE_DEFINITION_BEGIN(fx_byte) __FX_VALUE_TYPE_ID(BYTE); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.byte"); FX_TYPE_CLASS(fx_byte_class); FX_TYPE_INSTANCE_PRIVATE(byte); diff --git a/fx/int/convert.h b/fx/int/convert.h new file mode 100644 index 0000000..0db03d5 --- /dev/null +++ b/fx/int/convert.h @@ -0,0 +1,81 @@ +#ifndef INT_CONVERT_H_ +#define INT_CONVERT_H_ + +#include +#include +#include +#include +#include + +#define HASH(type_name) \ + static fx_status hash(const fx_value *v, uint64_t *out_hash) \ + { \ + *out_hash = v->v_##type_name; \ + return FX_SUCCESS; \ + } + +#define TO_STRING(type_name, fmt) \ + static fx_status to_string( \ + const fx_value *v, \ + fx_stream *out, \ + const char *format) \ + { \ + return fx_stream_write_fmt(out, NULL, fmt, v->v_##type_name); \ + } + +#define BINARY_OP(op_name, op_sym, type_name) \ + static fx_status op_name( \ + const fx_value *left, \ + const fx_value *right, \ + fx_value *out) \ + { \ + out->v_type = left->v_type; \ + out->v_##type_name = left->v_##type_name op_sym \ + right->v_##type_name; \ + return FX_SUCCESS; \ + } + +#define PREFIX_OP(op_name, op_sym, type_name) \ + static fx_status op_name(fx_value *value) \ + { \ + value->v_##type_name op_sym; \ + return FX_SUCCESS; \ + } + +#define IN_PLACE_OP(op_name, op_sym, type_name) \ + static fx_status op_name(fx_value *left, const fx_value *right) \ + { \ + left->v_##type_name op_sym right->v_##type_name; \ + return FX_SUCCESS; \ + } + +#define BOOL_CONVERT(fx_from) \ + static fx_status to_bool(const fx_value *in, bool *out) \ + { \ + *out = in->v_##fx_from != 0 ? true : false; \ + return FX_SUCCESS; \ + } +#define GENERIC_CONVERT(fx_from, fx_to, c_to) \ + static fx_status to_##fx_to(const fx_value *in, c_to *out) \ + { \ + *out = (c_to)in->v_##fx_from; \ + return FX_SUCCESS; \ + } + +#define COMPARE(fx_type, c_type) \ + static i32 compare(const fx_value *left, const fx_value *right) \ + { \ + c_type right_v = 0; \ + if (!FX_OK(fx_value_get_##fx_type(right, &right_v))) { \ + return -1; \ + } \ + if (left->v_##fx_type < right_v) { \ + return -1; \ + } else if (left->v_##fx_type > right_v) { \ + return 1; \ + } else { \ + return 0; \ + } \ + } + +#endif diff --git a/fx/int/i16.c b/fx/int/i16.c index 608170e..9a29731 100644 --- a/fx/int/i16.c +++ b/fx/int/i16.c @@ -1,5 +1,9 @@ +#include "convert.h" + +#include #include #include +#include #define SWAP16(v) (((v << 8) & 0xFF00) | ((v >> 8) & 0x00FF)) @@ -38,17 +42,101 @@ i16 fx_i16_stoh(i16 v) return SWAP16(v); #endif } + +HASH(i16) +TO_STRING(i16, "%" PRId16) + +BOOL_CONVERT(i16) +GENERIC_CONVERT(i16, u16, u16) +GENERIC_CONVERT(i16, i32, i32) +GENERIC_CONVERT(i16, u32, u32) +GENERIC_CONVERT(i16, i64, i64) +GENERIC_CONVERT(i16, u64, u64) +GENERIC_CONVERT(i16, iptr, iptr) +GENERIC_CONVERT(i16, uptr, uptr) +GENERIC_CONVERT(i16, sbyte, sbyte) +GENERIC_CONVERT(i16, byte, byte) +GENERIC_CONVERT(i16, short, short) +GENERIC_CONVERT(i16, ushort, unsigned short) +GENERIC_CONVERT(i16, int, int) +GENERIC_CONVERT(i16, uint, unsigned int) +GENERIC_CONVERT(i16, long, long) +GENERIC_CONVERT(i16, ulong, unsigned long) +GENERIC_CONVERT(i16, longlong, long long) +GENERIC_CONVERT(i16, ulonglong, unsigned long long) +GENERIC_CONVERT(i16, size, size_t) +GENERIC_CONVERT(i16, float, float) +GENERIC_CONVERT(i16, double, double) + +BINARY_OP(add, +, i16) +BINARY_OP(subtract, -, i16) +BINARY_OP(multiply, *, i16) +BINARY_OP(divide, /, i16) +PREFIX_OP(increment, ++, i16) +PREFIX_OP(decrement, --, i16) +IN_PLACE_OP(add_in_place, +=, i16) +IN_PLACE_OP(subtract_in_place, -=, i16) +IN_PLACE_OP(multiply_in_place, *=, i16) +IN_PLACE_OP(divide_in_place, /=, i16) + +COMPARE(i16, i16) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_i16) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_i16) FX_TYPE_DEFINITION_BEGIN(fx_i16) __FX_VALUE_TYPE_ID(I16); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.i16"); FX_TYPE_CLASS(fx_i16_class); FX_TYPE_INSTANCE_PRIVATE(i16); diff --git a/fx/int/i32.c b/fx/int/i32.c index 48dbb2d..651ffd8 100644 --- a/fx/int/i32.c +++ b/fx/int/i32.c @@ -1,3 +1,6 @@ +#include "convert.h" + +#include #include #include @@ -41,17 +44,100 @@ i32 fx_i32_stoh(i32 v) #endif } +HASH(i32) +TO_STRING(i32, "%" PRId32) + +BOOL_CONVERT(i32) +GENERIC_CONVERT(i32, i16, i16) +GENERIC_CONVERT(i32, u16, u16) +GENERIC_CONVERT(i32, u32, u32) +GENERIC_CONVERT(i32, i64, i64) +GENERIC_CONVERT(i32, u64, u64) +GENERIC_CONVERT(i32, iptr, iptr) +GENERIC_CONVERT(i32, uptr, uptr) +GENERIC_CONVERT(i32, sbyte, sbyte) +GENERIC_CONVERT(i32, byte, byte) +GENERIC_CONVERT(i32, short, short) +GENERIC_CONVERT(i32, ushort, unsigned short) +GENERIC_CONVERT(i32, int, int) +GENERIC_CONVERT(i32, uint, unsigned int) +GENERIC_CONVERT(i32, long, long) +GENERIC_CONVERT(i32, ulong, unsigned long) +GENERIC_CONVERT(i32, longlong, long long) +GENERIC_CONVERT(i32, ulonglong, unsigned long long) +GENERIC_CONVERT(i32, size, size_t) +GENERIC_CONVERT(i32, float, float) +GENERIC_CONVERT(i32, double, double) + +BINARY_OP(add, +, i32) +BINARY_OP(subtract, -, i32) +BINARY_OP(multiply, *, i32) +BINARY_OP(divide, /, i32) +PREFIX_OP(increment, ++, i32) +PREFIX_OP(decrement, --, i32) +IN_PLACE_OP(add_in_place, +=, i32) +IN_PLACE_OP(subtract_in_place, -=, i32) +IN_PLACE_OP(multiply_in_place, *=, i32) +IN_PLACE_OP(divide_in_place, /=, i32) + +COMPARE(i32, i32) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_i32) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_i32) FX_TYPE_DEFINITION_BEGIN(fx_i32) __FX_VALUE_TYPE_ID(I32); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.i32"); FX_TYPE_CLASS(fx_i32_class); FX_TYPE_INSTANCE_PRIVATE(i32); diff --git a/fx/int/i64.c b/fx/int/i64.c index ac1b99d..00b39e4 100644 --- a/fx/int/i64.c +++ b/fx/int/i64.c @@ -1,5 +1,9 @@ +#include "convert.h" + +#include #include #include +#include /* clang-format off */ #define SWAP64(v) \ @@ -45,17 +49,100 @@ i64 fx_i64_stoh(i64 v) #endif } +HASH(i64) +TO_STRING(i64, "%" PRId64) + +BOOL_CONVERT(i64) +GENERIC_CONVERT(i64, i16, i16) +GENERIC_CONVERT(i64, u16, u16) +GENERIC_CONVERT(i64, i32, i32) +GENERIC_CONVERT(i64, u32, u32) +GENERIC_CONVERT(i64, u64, u64) +GENERIC_CONVERT(i64, iptr, iptr) +GENERIC_CONVERT(i64, uptr, uptr) +GENERIC_CONVERT(i64, sbyte, sbyte) +GENERIC_CONVERT(i64, byte, byte) +GENERIC_CONVERT(i64, short, short) +GENERIC_CONVERT(i64, ushort, unsigned short) +GENERIC_CONVERT(i64, int, int) +GENERIC_CONVERT(i64, uint, unsigned int) +GENERIC_CONVERT(i64, long, long) +GENERIC_CONVERT(i64, ulong, unsigned long) +GENERIC_CONVERT(i64, longlong, long long) +GENERIC_CONVERT(i64, ulonglong, unsigned long long) +GENERIC_CONVERT(i64, size, size_t) +GENERIC_CONVERT(i64, float, float) +GENERIC_CONVERT(i64, double, double) + +BINARY_OP(add, +, i64) +BINARY_OP(subtract, -, i64) +BINARY_OP(multiply, *, i64) +BINARY_OP(divide, /, i64) +PREFIX_OP(increment, ++, i64) +PREFIX_OP(decrement, --, i64) +IN_PLACE_OP(add_in_place, +=, i64) +IN_PLACE_OP(subtract_in_place, -=, i64) +IN_PLACE_OP(multiply_in_place, *=, i64) +IN_PLACE_OP(divide_in_place, /=, i64) + +COMPARE(i64, i64) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_i64) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_i64) FX_TYPE_DEFINITION_BEGIN(fx_i64) __FX_VALUE_TYPE_ID(I64); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.i64"); FX_TYPE_CLASS(fx_i64_class); FX_TYPE_INSTANCE_PRIVATE(i64); diff --git a/fx/int/int.c b/fx/int/int.c index 632e4f1..460221b 100644 --- a/fx/int/int.c +++ b/fx/int/int.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(int) +TO_STRING(int, "%d") + +BOOL_CONVERT(int) +GENERIC_CONVERT(int, i16, i16) +GENERIC_CONVERT(int, u16, u16) +GENERIC_CONVERT(int, i32, i32) +GENERIC_CONVERT(int, u32, u32) +GENERIC_CONVERT(int, i64, i64) +GENERIC_CONVERT(int, u64, u64) +GENERIC_CONVERT(int, iptr, iptr) +GENERIC_CONVERT(int, uptr, uptr) +GENERIC_CONVERT(int, sbyte, sbyte) +GENERIC_CONVERT(int, byte, byte) +GENERIC_CONVERT(int, short, short) +GENERIC_CONVERT(int, ushort, unsigned short) +GENERIC_CONVERT(int, uint, unsigned int) +GENERIC_CONVERT(int, long, long) +GENERIC_CONVERT(int, ulong, unsigned long) +GENERIC_CONVERT(int, longlong, long long) +GENERIC_CONVERT(int, ulonglong, unsigned long long) +GENERIC_CONVERT(int, size, size_t) +GENERIC_CONVERT(int, float, float) +GENERIC_CONVERT(int, double, double) + +BINARY_OP(add, +, int) +BINARY_OP(subtract, -, int) +BINARY_OP(multiply, *, int) +BINARY_OP(divide, /, int) +PREFIX_OP(increment, ++, int) +PREFIX_OP(decrement, --, int) +IN_PLACE_OP(add_in_place, +=, int) +IN_PLACE_OP(subtract_in_place, -=, int) +IN_PLACE_OP(multiply_in_place, *=, int) +IN_PLACE_OP(divide_in_place, /=, int) + +COMPARE(int, int) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_int) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_int) FX_TYPE_DEFINITION_BEGIN(fx_int) __FX_VALUE_TYPE_ID(INT); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.int"); FX_TYPE_CLASS(fx_int_class); FX_TYPE_INSTANCE_PRIVATE(int); diff --git a/fx/int/iptr.c b/fx/int/iptr.c index 5796ce5..6bc543d 100644 --- a/fx/int/iptr.c +++ b/fx/int/iptr.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(iptr) +TO_STRING(iptr, "%" PRIdPTR) + +BOOL_CONVERT(iptr) +GENERIC_CONVERT(iptr, i16, i16) +GENERIC_CONVERT(iptr, u16, u16) +GENERIC_CONVERT(iptr, i32, i32) +GENERIC_CONVERT(iptr, u32, u32) +GENERIC_CONVERT(iptr, i64, i64) +GENERIC_CONVERT(iptr, u64, u64) +GENERIC_CONVERT(iptr, uptr, uptr) +GENERIC_CONVERT(iptr, sbyte, sbyte) +GENERIC_CONVERT(iptr, byte, byte) +GENERIC_CONVERT(iptr, short, short) +GENERIC_CONVERT(iptr, ushort, unsigned short) +GENERIC_CONVERT(iptr, int, int) +GENERIC_CONVERT(iptr, uint, unsigned int) +GENERIC_CONVERT(iptr, long, long) +GENERIC_CONVERT(iptr, ulong, unsigned long) +GENERIC_CONVERT(iptr, longlong, long long) +GENERIC_CONVERT(iptr, ulonglong, unsigned long long) +GENERIC_CONVERT(iptr, size, size_t) +GENERIC_CONVERT(iptr, float, float) +GENERIC_CONVERT(iptr, double, double) + +BINARY_OP(add, +, iptr) +BINARY_OP(subtract, -, iptr) +BINARY_OP(multiply, *, iptr) +BINARY_OP(divide, /, iptr) +PREFIX_OP(increment, ++, iptr) +PREFIX_OP(decrement, --, iptr) +IN_PLACE_OP(add_in_place, +=, iptr) +IN_PLACE_OP(subtract_in_place, -=, iptr) +IN_PLACE_OP(multiply_in_place, *=, iptr) +IN_PLACE_OP(divide_in_place, /=, iptr) + +COMPARE(iptr, iptr) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_iptr) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_iptr) FX_TYPE_DEFINITION_BEGIN(fx_iptr) __FX_VALUE_TYPE_ID(IPTR); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.iptr"); FX_TYPE_CLASS(fx_iptr_class); FX_TYPE_INSTANCE_PRIVATE(iptr); diff --git a/fx/int/long.c b/fx/int/long.c index c103fad..bb7e678 100644 --- a/fx/int/long.c +++ b/fx/int/long.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(long) +TO_STRING(long, "%ld") + +BOOL_CONVERT(long) +GENERIC_CONVERT(long, i16, i16) +GENERIC_CONVERT(long, u16, u16) +GENERIC_CONVERT(long, i32, i32) +GENERIC_CONVERT(long, u32, u32) +GENERIC_CONVERT(long, i64, i64) +GENERIC_CONVERT(long, u64, u64) +GENERIC_CONVERT(long, iptr, iptr) +GENERIC_CONVERT(long, uptr, uptr) +GENERIC_CONVERT(long, sbyte, sbyte) +GENERIC_CONVERT(long, byte, byte) +GENERIC_CONVERT(long, short, short) +GENERIC_CONVERT(long, ushort, unsigned short) +GENERIC_CONVERT(long, int, int) +GENERIC_CONVERT(long, uint, unsigned int) +GENERIC_CONVERT(long, ulong, unsigned long) +GENERIC_CONVERT(long, longlong, long long) +GENERIC_CONVERT(long, ulonglong, unsigned long long) +GENERIC_CONVERT(long, size, size_t) +GENERIC_CONVERT(long, float, float) +GENERIC_CONVERT(long, double, double) + +BINARY_OP(add, +, long) +BINARY_OP(subtract, -, long) +BINARY_OP(multiply, *, long) +BINARY_OP(divide, /, long) +PREFIX_OP(increment, ++, long) +PREFIX_OP(decrement, --, long) +IN_PLACE_OP(add_in_place, +=, long) +IN_PLACE_OP(subtract_in_place, -=, long) +IN_PLACE_OP(multiply_in_place, *=, long) +IN_PLACE_OP(divide_in_place, /=, long) + +COMPARE(long, long) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_long) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_long) FX_TYPE_DEFINITION_BEGIN(fx_long) __FX_VALUE_TYPE_ID(LONG); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.long"); FX_TYPE_CLASS(fx_long_class); FX_TYPE_INSTANCE_PRIVATE(long); diff --git a/fx/int/longlong.c b/fx/int/longlong.c index 338be0f..2aa954f 100644 --- a/fx/int/longlong.c +++ b/fx/int/longlong.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(longlong) +TO_STRING(longlong, "%lld") + +BOOL_CONVERT(longlong) +GENERIC_CONVERT(longlong, i16, i16) +GENERIC_CONVERT(longlong, u16, u16) +GENERIC_CONVERT(longlong, i32, i32) +GENERIC_CONVERT(longlong, u32, u32) +GENERIC_CONVERT(longlong, i64, i64) +GENERIC_CONVERT(longlong, u64, u64) +GENERIC_CONVERT(longlong, iptr, iptr) +GENERIC_CONVERT(longlong, uptr, uptr) +GENERIC_CONVERT(longlong, sbyte, sbyte) +GENERIC_CONVERT(longlong, byte, byte) +GENERIC_CONVERT(longlong, short, short) +GENERIC_CONVERT(longlong, ushort, unsigned short) +GENERIC_CONVERT(longlong, int, int) +GENERIC_CONVERT(longlong, uint, unsigned int) +GENERIC_CONVERT(longlong, long, long) +GENERIC_CONVERT(longlong, ulong, unsigned long) +GENERIC_CONVERT(longlong, ulonglong, unsigned long long) +GENERIC_CONVERT(longlong, size, size_t) +GENERIC_CONVERT(longlong, float, float) +GENERIC_CONVERT(longlong, double, double) + +BINARY_OP(add, +, longlong) +BINARY_OP(subtract, -, longlong) +BINARY_OP(multiply, *, longlong) +BINARY_OP(divide, /, longlong) +PREFIX_OP(increment, ++, longlong) +PREFIX_OP(decrement, --, longlong) +IN_PLACE_OP(add_in_place, +=, longlong) +IN_PLACE_OP(subtract_in_place, -=, longlong) +IN_PLACE_OP(multiply_in_place, *=, longlong) +IN_PLACE_OP(divide_in_place, /=, longlong) + +COMPARE(longlong, long long) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_longlong) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_longlong) FX_TYPE_DEFINITION_BEGIN(fx_longlong) __FX_VALUE_TYPE_ID(LONGLONG); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.longlong"); FX_TYPE_CLASS(fx_longlong_class); FX_TYPE_INSTANCE_PRIVATE(long long); diff --git a/fx/int/sbyte.c b/fx/int/sbyte.c index 51102cd..2ae6e27 100644 --- a/fx/int/sbyte.c +++ b/fx/int/sbyte.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(sbyte) +TO_STRING(sbyte, "%d") + +BOOL_CONVERT(sbyte) +GENERIC_CONVERT(sbyte, i16, i16) +GENERIC_CONVERT(sbyte, u16, u16) +GENERIC_CONVERT(sbyte, i32, i32) +GENERIC_CONVERT(sbyte, u32, u32) +GENERIC_CONVERT(sbyte, i64, i64) +GENERIC_CONVERT(sbyte, u64, u64) +GENERIC_CONVERT(sbyte, iptr, iptr) +GENERIC_CONVERT(sbyte, uptr, uptr) +GENERIC_CONVERT(sbyte, byte, byte) +GENERIC_CONVERT(sbyte, short, short) +GENERIC_CONVERT(sbyte, ushort, unsigned short) +GENERIC_CONVERT(sbyte, int, int) +GENERIC_CONVERT(sbyte, uint, unsigned int) +GENERIC_CONVERT(sbyte, long, long) +GENERIC_CONVERT(sbyte, ulong, unsigned long) +GENERIC_CONVERT(sbyte, longlong, long long) +GENERIC_CONVERT(sbyte, ulonglong, unsigned long long) +GENERIC_CONVERT(sbyte, size, size_t) +GENERIC_CONVERT(sbyte, float, float) +GENERIC_CONVERT(sbyte, double, double) + +BINARY_OP(add, +, sbyte) +BINARY_OP(subtract, -, sbyte) +BINARY_OP(multiply, *, sbyte) +BINARY_OP(divide, /, sbyte) +PREFIX_OP(increment, ++, sbyte) +PREFIX_OP(decrement, --, sbyte) +IN_PLACE_OP(add_in_place, +=, sbyte) +IN_PLACE_OP(subtract_in_place, -=, sbyte) +IN_PLACE_OP(multiply_in_place, *=, sbyte) +IN_PLACE_OP(divide_in_place, /=, sbyte) + +COMPARE(sbyte, sbyte) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_sbyte) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_sbyte) FX_TYPE_DEFINITION_BEGIN(fx_sbyte) __FX_VALUE_TYPE_ID(SBYTE); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.sbyte"); FX_TYPE_CLASS(fx_sbyte_class); FX_TYPE_INSTANCE_PRIVATE(sbyte); diff --git a/fx/int/short.c b/fx/int/short.c index d35377c..60968d1 100644 --- a/fx/int/short.c +++ b/fx/int/short.c @@ -1,18 +1,102 @@ +#include "convert.h" #include #include +HASH(short) +TO_STRING(short, "%d") + +BOOL_CONVERT(short) +GENERIC_CONVERT(short, i16, i16) +GENERIC_CONVERT(short, u16, u16) +GENERIC_CONVERT(short, i32, i32) +GENERIC_CONVERT(short, u32, u32) +GENERIC_CONVERT(short, i64, i64) +GENERIC_CONVERT(short, u64, u64) +GENERIC_CONVERT(short, iptr, iptr) +GENERIC_CONVERT(short, uptr, uptr) +GENERIC_CONVERT(short, sbyte, sbyte) +GENERIC_CONVERT(short, byte, byte) +GENERIC_CONVERT(short, ushort, unsigned short) +GENERIC_CONVERT(short, int, int) +GENERIC_CONVERT(short, uint, unsigned int) +GENERIC_CONVERT(short, long, long) +GENERIC_CONVERT(short, ulong, unsigned long) +GENERIC_CONVERT(short, longlong, long long) +GENERIC_CONVERT(short, ulonglong, unsigned long long) +GENERIC_CONVERT(short, size, size_t) +GENERIC_CONVERT(short, float, float) +GENERIC_CONVERT(short, double, double) + +BINARY_OP(add, +, short) +BINARY_OP(subtract, -, short) +BINARY_OP(multiply, *, short) +BINARY_OP(divide, /, short) +PREFIX_OP(increment, ++, short) +PREFIX_OP(decrement, --, short) +IN_PLACE_OP(add_in_place, +=, short) +IN_PLACE_OP(subtract_in_place, -=, short) +IN_PLACE_OP(multiply_in_place, *=, short) +IN_PLACE_OP(divide_in_place, /=, short) + +COMPARE(short, short) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_short) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_short) FX_TYPE_DEFINITION_BEGIN(fx_short) __FX_VALUE_TYPE_ID(SHORT); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.short"); FX_TYPE_CLASS(fx_short_class); FX_TYPE_INSTANCE_PRIVATE(short); diff --git a/fx/int/size.c b/fx/int/size.c index 35f6403..15e691a 100644 --- a/fx/int/size.c +++ b/fx/int/size.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(size) +TO_STRING(size, "%zu") + +BOOL_CONVERT(size) +GENERIC_CONVERT(size, i16, i16) +GENERIC_CONVERT(size, u16, u16) +GENERIC_CONVERT(size, i32, i32) +GENERIC_CONVERT(size, u32, u32) +GENERIC_CONVERT(size, i64, i64) +GENERIC_CONVERT(size, u64, u64) +GENERIC_CONVERT(size, iptr, iptr) +GENERIC_CONVERT(size, uptr, uptr) +GENERIC_CONVERT(size, sbyte, sbyte) +GENERIC_CONVERT(size, byte, byte) +GENERIC_CONVERT(size, short, short) +GENERIC_CONVERT(size, ushort, unsigned short) +GENERIC_CONVERT(size, int, int) +GENERIC_CONVERT(size, uint, unsigned int) +GENERIC_CONVERT(size, long, long) +GENERIC_CONVERT(size, ulong, unsigned long) +GENERIC_CONVERT(size, longlong, long long) +GENERIC_CONVERT(size, ulonglong, unsigned long long) +GENERIC_CONVERT(size, float, float) +GENERIC_CONVERT(size, double, double) + +BINARY_OP(add, +, size) +BINARY_OP(subtract, -, size) +BINARY_OP(multiply, *, size) +BINARY_OP(divide, /, size) +PREFIX_OP(increment, ++, size) +PREFIX_OP(decrement, --, size) +IN_PLACE_OP(add_in_place, +=, size) +IN_PLACE_OP(subtract_in_place, -=, size) +IN_PLACE_OP(multiply_in_place, *=, size) +IN_PLACE_OP(divide_in_place, /=, size) + +COMPARE(size, size_t) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_size) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_size) FX_TYPE_DEFINITION_BEGIN(fx_size) __FX_VALUE_TYPE_ID(SIZE); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); FX_TYPE_NAME("fx.size"); FX_TYPE_CLASS(fx_size_class); FX_TYPE_INSTANCE_PRIVATE(size_t); diff --git a/fx/int/u16.c b/fx/int/u16.c index 7854336..246218b 100644 --- a/fx/int/u16.c +++ b/fx/int/u16.c @@ -1,5 +1,9 @@ +#include "convert.h" + +#include #include #include +#include #define SWAP16(v) (((v << 8) & 0xFF00) | ((v >> 8) & 0x00FF)) @@ -39,17 +43,100 @@ u16 fx_u16_stoh(u16 v) #endif } +HASH(u16) +TO_STRING(u16, "%" PRIu16) + +BOOL_CONVERT(u16) +GENERIC_CONVERT(u16, i16, i16) +GENERIC_CONVERT(u16, i32, i32) +GENERIC_CONVERT(u16, u32, u32) +GENERIC_CONVERT(u16, i64, i64) +GENERIC_CONVERT(u16, u64, u64) +GENERIC_CONVERT(u16, iptr, iptr) +GENERIC_CONVERT(u16, uptr, uptr) +GENERIC_CONVERT(u16, sbyte, sbyte) +GENERIC_CONVERT(u16, byte, byte) +GENERIC_CONVERT(u16, short, short) +GENERIC_CONVERT(u16, ushort, unsigned short) +GENERIC_CONVERT(u16, int, int) +GENERIC_CONVERT(u16, uint, unsigned int) +GENERIC_CONVERT(u16, long, long) +GENERIC_CONVERT(u16, ulong, unsigned long) +GENERIC_CONVERT(u16, longlong, long long) +GENERIC_CONVERT(u16, ulonglong, unsigned long long) +GENERIC_CONVERT(u16, size, size_t) +GENERIC_CONVERT(u16, float, float) +GENERIC_CONVERT(u16, double, double) + +BINARY_OP(add, +, u16) +BINARY_OP(subtract, -, u16) +BINARY_OP(multiply, *, u16) +BINARY_OP(divide, /, u16) +PREFIX_OP(increment, ++, u16) +PREFIX_OP(decrement, --, u16) +IN_PLACE_OP(add_in_place, +=, u16) +IN_PLACE_OP(subtract_in_place, -=, u16) +IN_PLACE_OP(multiply_in_place, *=, u16) +IN_PLACE_OP(divide_in_place, /=, u16) + +COMPARE(u16, u16) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_u16) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_u16) FX_TYPE_DEFINITION_BEGIN(fx_u16) __FX_VALUE_TYPE_ID(U16); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.u16"); FX_TYPE_CLASS(fx_u16_class); FX_TYPE_INSTANCE_PRIVATE(u16); diff --git a/fx/int/u32.c b/fx/int/u32.c index a47dd4a..1c3b4a3 100644 --- a/fx/int/u32.c +++ b/fx/int/u32.c @@ -1,5 +1,9 @@ +#include "convert.h" + +#include #include #include +#include #define SWAP32(v) \ (((v << 24) & 0xFF000000) | ((v << 8) & 0x00FF0000) \ @@ -41,17 +45,100 @@ u32 fx_u32_stoh(u32 v) #endif } +HASH(u32) +TO_STRING(u32, "%" PRIu32) + +BOOL_CONVERT(u32) +GENERIC_CONVERT(u32, i16, i16) +GENERIC_CONVERT(u32, u16, u16) +GENERIC_CONVERT(u32, i32, i32) +GENERIC_CONVERT(u32, i64, i64) +GENERIC_CONVERT(u32, u64, u64) +GENERIC_CONVERT(u32, iptr, iptr) +GENERIC_CONVERT(u32, uptr, uptr) +GENERIC_CONVERT(u32, sbyte, sbyte) +GENERIC_CONVERT(u32, byte, byte) +GENERIC_CONVERT(u32, short, short) +GENERIC_CONVERT(u32, ushort, unsigned short) +GENERIC_CONVERT(u32, int, int) +GENERIC_CONVERT(u32, uint, unsigned int) +GENERIC_CONVERT(u32, long, long) +GENERIC_CONVERT(u32, ulong, unsigned long) +GENERIC_CONVERT(u32, longlong, long long) +GENERIC_CONVERT(u32, ulonglong, unsigned long long) +GENERIC_CONVERT(u32, size, size_t) +GENERIC_CONVERT(u32, float, float) +GENERIC_CONVERT(u32, double, double) + +BINARY_OP(add, +, u32) +BINARY_OP(subtract, -, u32) +BINARY_OP(multiply, *, u32) +BINARY_OP(divide, /, u32) +PREFIX_OP(increment, ++, u32) +PREFIX_OP(decrement, --, u32) +IN_PLACE_OP(add_in_place, +=, u32) +IN_PLACE_OP(subtract_in_place, -=, u32) +IN_PLACE_OP(multiply_in_place, *=, u32) +IN_PLACE_OP(divide_in_place, /=, u32) + +COMPARE(u32, u32) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_u32) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_u32) FX_TYPE_DEFINITION_BEGIN(fx_u32) __FX_VALUE_TYPE_ID(U32); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.u32"); FX_TYPE_CLASS(fx_u32_class); FX_TYPE_INSTANCE_PRIVATE(u32); diff --git a/fx/int/u64.c b/fx/int/u64.c index c27afc9..ef43199 100644 --- a/fx/int/u64.c +++ b/fx/int/u64.c @@ -1,5 +1,9 @@ +#include "convert.h" + +#include #include #include +#include /* clang-format off */ #define SWAP64(v) \ @@ -45,17 +49,100 @@ u64 fx_u64_stoh(u64 v) #endif } +HASH(u64) +TO_STRING(u64, "%" PRIu64) + +BOOL_CONVERT(u64) +GENERIC_CONVERT(u64, i16, i16) +GENERIC_CONVERT(u64, u16, u16) +GENERIC_CONVERT(u64, i32, i32) +GENERIC_CONVERT(u64, u32, u32) +GENERIC_CONVERT(u64, i64, i64) +GENERIC_CONVERT(u64, iptr, iptr) +GENERIC_CONVERT(u64, uptr, uptr) +GENERIC_CONVERT(u64, sbyte, sbyte) +GENERIC_CONVERT(u64, byte, byte) +GENERIC_CONVERT(u64, short, short) +GENERIC_CONVERT(u64, ushort, unsigned short) +GENERIC_CONVERT(u64, int, int) +GENERIC_CONVERT(u64, uint, unsigned int) +GENERIC_CONVERT(u64, long, long) +GENERIC_CONVERT(u64, ulong, unsigned long) +GENERIC_CONVERT(u64, longlong, long long) +GENERIC_CONVERT(u64, ulonglong, unsigned long long) +GENERIC_CONVERT(u64, size, size_t) +GENERIC_CONVERT(u64, float, float) +GENERIC_CONVERT(u64, double, double) + +BINARY_OP(add, +, u64) +BINARY_OP(subtract, -, u64) +BINARY_OP(multiply, *, u64) +BINARY_OP(divide, /, u64) +PREFIX_OP(increment, ++, u64) +PREFIX_OP(decrement, --, u64) +IN_PLACE_OP(add_in_place, +=, u64) +IN_PLACE_OP(subtract_in_place, -=, u64) +IN_PLACE_OP(multiply_in_place, *=, u64) +IN_PLACE_OP(divide_in_place, /=, u64) + +COMPARE(u64, u64) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_u64) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_u64) FX_TYPE_DEFINITION_BEGIN(fx_u64) __FX_VALUE_TYPE_ID(U64); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.u64"); FX_TYPE_CLASS(fx_u64_class); FX_TYPE_INSTANCE_PRIVATE(u64); diff --git a/fx/int/uint.c b/fx/int/uint.c index ba74279..8ccbcb9 100644 --- a/fx/int/uint.c +++ b/fx/int/uint.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(uint) +TO_STRING(uint, "%u") + +BOOL_CONVERT(uint) +GENERIC_CONVERT(uint, i16, i16) +GENERIC_CONVERT(uint, u16, u16) +GENERIC_CONVERT(uint, i32, i32) +GENERIC_CONVERT(uint, u32, u32) +GENERIC_CONVERT(uint, i64, i64) +GENERIC_CONVERT(uint, u64, u64) +GENERIC_CONVERT(uint, iptr, iptr) +GENERIC_CONVERT(uint, uptr, uptr) +GENERIC_CONVERT(uint, sbyte, sbyte) +GENERIC_CONVERT(uint, byte, byte) +GENERIC_CONVERT(uint, short, short) +GENERIC_CONVERT(uint, ushort, unsigned short) +GENERIC_CONVERT(uint, int, int) +GENERIC_CONVERT(uint, long, long) +GENERIC_CONVERT(uint, ulong, unsigned long) +GENERIC_CONVERT(uint, longlong, long long) +GENERIC_CONVERT(uint, ulonglong, unsigned long long) +GENERIC_CONVERT(uint, size, size_t) +GENERIC_CONVERT(uint, float, float) +GENERIC_CONVERT(uint, double, double) + +BINARY_OP(add, +, uint) +BINARY_OP(subtract, -, uint) +BINARY_OP(multiply, *, uint) +BINARY_OP(divide, /, uint) +PREFIX_OP(increment, ++, uint) +PREFIX_OP(decrement, --, uint) +IN_PLACE_OP(add_in_place, +=, uint) +IN_PLACE_OP(subtract_in_place, -=, uint) +IN_PLACE_OP(multiply_in_place, *=, uint) +IN_PLACE_OP(divide_in_place, /=, uint) + +COMPARE(uint, unsigned int) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_uint) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_uint) FX_TYPE_DEFINITION_BEGIN(fx_uint) __FX_VALUE_TYPE_ID(UINT); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.uint"); FX_TYPE_CLASS(fx_uint_class); FX_TYPE_INSTANCE_PRIVATE(unsigned int); diff --git a/fx/int/ulong.c b/fx/int/ulong.c index ab17ffe..7b321f7 100644 --- a/fx/int/ulong.c +++ b/fx/int/ulong.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(ulong) +TO_STRING(ulong, "%lu") + +BOOL_CONVERT(ulong) +GENERIC_CONVERT(ulong, i16, i16) +GENERIC_CONVERT(ulong, u16, u16) +GENERIC_CONVERT(ulong, i32, i32) +GENERIC_CONVERT(ulong, u32, u32) +GENERIC_CONVERT(ulong, i64, i64) +GENERIC_CONVERT(ulong, u64, u64) +GENERIC_CONVERT(ulong, iptr, iptr) +GENERIC_CONVERT(ulong, uptr, uptr) +GENERIC_CONVERT(ulong, sbyte, sbyte) +GENERIC_CONVERT(ulong, byte, byte) +GENERIC_CONVERT(ulong, short, short) +GENERIC_CONVERT(ulong, ushort, unsigned short) +GENERIC_CONVERT(ulong, int, int) +GENERIC_CONVERT(ulong, uint, unsigned int) +GENERIC_CONVERT(ulong, long, long) +GENERIC_CONVERT(ulong, longlong, long long) +GENERIC_CONVERT(ulong, ulonglong, unsigned long long) +GENERIC_CONVERT(ulong, size, size_t) +GENERIC_CONVERT(ulong, float, float) +GENERIC_CONVERT(ulong, double, double) + +BINARY_OP(add, +, ulong) +BINARY_OP(subtract, -, ulong) +BINARY_OP(multiply, *, ulong) +BINARY_OP(divide, /, ulong) +PREFIX_OP(increment, ++, ulong) +PREFIX_OP(decrement, --, ulong) +IN_PLACE_OP(add_in_place, +=, ulong) +IN_PLACE_OP(subtract_in_place, -=, ulong) +IN_PLACE_OP(multiply_in_place, *=, ulong) +IN_PLACE_OP(divide_in_place, /=, ulong) + +COMPARE(ulong, unsigned long) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_ulong) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_ulong) FX_TYPE_DEFINITION_BEGIN(fx_ulong) __FX_VALUE_TYPE_ID(ULONG); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.ulong"); FX_TYPE_CLASS(fx_ulong_class); FX_TYPE_INSTANCE_PRIVATE(unsigned long); diff --git a/fx/int/ulonglong.c b/fx/int/ulonglong.c index 527bece..d4508b6 100644 --- a/fx/int/ulonglong.c +++ b/fx/int/ulonglong.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(ulonglong) +TO_STRING(ulonglong, "%llu") + +BOOL_CONVERT(ulonglong) +GENERIC_CONVERT(ulonglong, i16, i16) +GENERIC_CONVERT(ulonglong, u16, u16) +GENERIC_CONVERT(ulonglong, i32, i32) +GENERIC_CONVERT(ulonglong, u32, u32) +GENERIC_CONVERT(ulonglong, i64, i64) +GENERIC_CONVERT(ulonglong, u64, u64) +GENERIC_CONVERT(ulonglong, iptr, iptr) +GENERIC_CONVERT(ulonglong, uptr, uptr) +GENERIC_CONVERT(ulonglong, sbyte, sbyte) +GENERIC_CONVERT(ulonglong, byte, byte) +GENERIC_CONVERT(ulonglong, short, short) +GENERIC_CONVERT(ulonglong, ushort, unsigned short) +GENERIC_CONVERT(ulonglong, int, int) +GENERIC_CONVERT(ulonglong, uint, unsigned int) +GENERIC_CONVERT(ulonglong, long, long) +GENERIC_CONVERT(ulonglong, ulong, unsigned long) +GENERIC_CONVERT(ulonglong, longlong, long long) +GENERIC_CONVERT(ulonglong, size, size_t) +GENERIC_CONVERT(ulonglong, float, float) +GENERIC_CONVERT(ulonglong, double, double) + +BINARY_OP(add, +, ulonglong) +BINARY_OP(subtract, -, ulonglong) +BINARY_OP(multiply, *, ulonglong) +BINARY_OP(divide, /, ulonglong) +PREFIX_OP(increment, ++, ulonglong) +PREFIX_OP(decrement, --, ulonglong) +IN_PLACE_OP(add_in_place, +=, ulonglong) +IN_PLACE_OP(subtract_in_place, -=, ulonglong) +IN_PLACE_OP(multiply_in_place, *=, ulonglong) +IN_PLACE_OP(divide_in_place, /=, ulonglong) + +COMPARE(ulonglong, unsigned long long) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_ulonglong) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_ulonglong) FX_TYPE_DEFINITION_BEGIN(fx_ulonglong) __FX_VALUE_TYPE_ID(ULONGLONG); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.ulonglong"); FX_TYPE_CLASS(fx_ulonglong_class); FX_TYPE_INSTANCE_PRIVATE(unsigned long long); diff --git a/fx/int/uptr.c b/fx/int/uptr.c index b93ea1d..b0d354d 100644 --- a/fx/int/uptr.c +++ b/fx/int/uptr.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(uptr) +TO_STRING(uptr, "%" PRIuPTR) + +BOOL_CONVERT(uptr) +GENERIC_CONVERT(uptr, i16, i16) +GENERIC_CONVERT(uptr, u16, u16) +GENERIC_CONVERT(uptr, i32, i32) +GENERIC_CONVERT(uptr, u32, u32) +GENERIC_CONVERT(uptr, i64, i64) +GENERIC_CONVERT(uptr, u64, u64) +GENERIC_CONVERT(uptr, iptr, iptr) +GENERIC_CONVERT(uptr, sbyte, sbyte) +GENERIC_CONVERT(uptr, byte, byte) +GENERIC_CONVERT(uptr, short, short) +GENERIC_CONVERT(uptr, ushort, unsigned short) +GENERIC_CONVERT(uptr, int, int) +GENERIC_CONVERT(uptr, uint, unsigned int) +GENERIC_CONVERT(uptr, long, long) +GENERIC_CONVERT(uptr, ulong, unsigned long) +GENERIC_CONVERT(uptr, longlong, long long) +GENERIC_CONVERT(uptr, ulonglong, unsigned long long) +GENERIC_CONVERT(uptr, size, size_t) +GENERIC_CONVERT(uptr, float, float) +GENERIC_CONVERT(uptr, double, double) + +BINARY_OP(add, +, uptr) +BINARY_OP(subtract, -, uptr) +BINARY_OP(multiply, *, uptr) +BINARY_OP(divide, /, uptr) +PREFIX_OP(increment, ++, uptr) +PREFIX_OP(decrement, --, uptr) +IN_PLACE_OP(add_in_place, +=, uptr) +IN_PLACE_OP(subtract_in_place, -=, uptr) +IN_PLACE_OP(multiply_in_place, *=, uptr) +IN_PLACE_OP(divide_in_place, /=, uptr) + +COMPARE(uptr, uptr) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_uptr) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_ushort) = to_ushort; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_uptr) FX_TYPE_DEFINITION_BEGIN(fx_uptr) __FX_VALUE_TYPE_ID(UPTR); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.uptr"); FX_TYPE_CLASS(fx_uptr_class); FX_TYPE_INSTANCE_PRIVATE(uptr); diff --git a/fx/int/ushort.c b/fx/int/ushort.c index 6cfa512..a0f6f60 100644 --- a/fx/int/ushort.c +++ b/fx/int/ushort.c @@ -1,17 +1,102 @@ +#include "convert.h" + #include #include +HASH(ushort) +TO_STRING(ushort, "%u") + +BOOL_CONVERT(ushort) +GENERIC_CONVERT(ushort, i16, i16) +GENERIC_CONVERT(ushort, u16, u16) +GENERIC_CONVERT(ushort, i32, i32) +GENERIC_CONVERT(ushort, u32, u32) +GENERIC_CONVERT(ushort, i64, i64) +GENERIC_CONVERT(ushort, u64, u64) +GENERIC_CONVERT(ushort, iptr, iptr) +GENERIC_CONVERT(ushort, uptr, uptr) +GENERIC_CONVERT(ushort, sbyte, sbyte) +GENERIC_CONVERT(ushort, byte, byte) +GENERIC_CONVERT(ushort, short, short) +GENERIC_CONVERT(ushort, int, int) +GENERIC_CONVERT(ushort, uint, unsigned int) +GENERIC_CONVERT(ushort, long, long) +GENERIC_CONVERT(ushort, ulong, unsigned long) +GENERIC_CONVERT(ushort, longlong, long long) +GENERIC_CONVERT(ushort, ulonglong, unsigned long long) +GENERIC_CONVERT(ushort, size, size_t) +GENERIC_CONVERT(ushort, float, float) +GENERIC_CONVERT(ushort, double, double) + +BINARY_OP(add, +, ushort) +BINARY_OP(subtract, -, ushort) +BINARY_OP(multiply, *, ushort) +BINARY_OP(divide, /, ushort) +PREFIX_OP(increment, ++, ushort) +PREFIX_OP(decrement, --, ushort) +IN_PLACE_OP(add_in_place, +=, ushort) +IN_PLACE_OP(subtract_in_place, -=, ushort) +IN_PLACE_OP(multiply_in_place, *=, ushort) +IN_PLACE_OP(divide_in_place, /=, ushort) + +COMPARE(ushort, unsigned short) + /*** CLASS DEFINITION *********************************************************/ FX_TYPE_CLASS_BEGIN(fx_ushort) FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT) - FX_INTERFACE_ENTRY(to_string) = NULL; + FX_INTERFACE_ENTRY(to_string) = to_string; + FX_INTERFACE_ENTRY(hash) = hash; FX_TYPE_VTABLE_INTERFACE_END(fx_object, FX_TYPE_OBJECT) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_comparable, FX_TYPE_COMPARABLE) + FX_INTERFACE_ENTRY(c_compare) = compare; + FX_TYPE_VTABLE_INTERFACE_END(fx_comparable, FX_TYPE_COMPARABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_operable, FX_TYPE_OPERABLE) + FX_INTERFACE_ENTRY(op_add) = add; + FX_INTERFACE_ENTRY(op_subtract) = subtract; + FX_INTERFACE_ENTRY(op_multiply) = multiply; + FX_INTERFACE_ENTRY(op_divide) = divide; + FX_INTERFACE_ENTRY(op_increment) = increment; + FX_INTERFACE_ENTRY(op_decrement) = decrement; + FX_INTERFACE_ENTRY(op_add_in_place) = add_in_place; + FX_INTERFACE_ENTRY(op_subtract_in_place) = subtract_in_place; + FX_INTERFACE_ENTRY(op_multiply_in_place) = multiply_in_place; + FX_INTERFACE_ENTRY(op_divide_in_place) = divide_in_place; + FX_TYPE_VTABLE_INTERFACE_END(fx_operable, FX_TYPE_OPERABLE) + + FX_TYPE_VTABLE_INTERFACE_BEGIN(fx_convertible, FX_TYPE_CONVERTIBLE) + FX_INTERFACE_ENTRY(c_to_bool) = to_bool; + FX_INTERFACE_ENTRY(c_to_i16) = to_i16; + FX_INTERFACE_ENTRY(c_to_u16) = to_u16; + FX_INTERFACE_ENTRY(c_to_i32) = to_i32; + FX_INTERFACE_ENTRY(c_to_u32) = to_u32; + FX_INTERFACE_ENTRY(c_to_i64) = to_i64; + FX_INTERFACE_ENTRY(c_to_u64) = to_u64; + FX_INTERFACE_ENTRY(c_to_iptr) = to_iptr; + FX_INTERFACE_ENTRY(c_to_uptr) = to_uptr; + FX_INTERFACE_ENTRY(c_to_sbyte) = to_sbyte; + FX_INTERFACE_ENTRY(c_to_byte) = to_byte; + FX_INTERFACE_ENTRY(c_to_short) = to_short; + FX_INTERFACE_ENTRY(c_to_int) = to_int; + FX_INTERFACE_ENTRY(c_to_uint) = to_uint; + FX_INTERFACE_ENTRY(c_to_long) = to_long; + FX_INTERFACE_ENTRY(c_to_ulong) = to_ulong; + FX_INTERFACE_ENTRY(c_to_longlong) = to_longlong; + FX_INTERFACE_ENTRY(c_to_ulonglong) = to_ulonglong; + FX_INTERFACE_ENTRY(c_to_size) = to_size; + FX_INTERFACE_ENTRY(c_to_float) = to_float; + FX_INTERFACE_ENTRY(c_to_double) = to_double; + FX_TYPE_VTABLE_INTERFACE_END(fx_convertible, FX_TYPE_CONVERTIBLE) FX_TYPE_CLASS_END(fx_ushort) FX_TYPE_DEFINITION_BEGIN(fx_ushort) __FX_VALUE_TYPE_ID(USHORT); FX_TYPE_EXTENDS(FX_TYPE_VALUE_TYPE); + FX_TYPE_IMPLEMENTS(FX_TYPE_CONVERTIBLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_OPERABLE); + FX_TYPE_IMPLEMENTS(FX_TYPE_COMPARABLE); FX_TYPE_NAME("fx.ushort"); FX_TYPE_CLASS(fx_ushort_class); FX_TYPE_INSTANCE_PRIVATE(unsigned short);