val.h

Go to the documentation of this file.

 
#ifndef LELY_CO_VAL_H_
#define LELY_CO_VAL_H_
 
#include <lely/co/type.h>
 
#include <float.h>
#include <stddef.h>
 
#define CO_BOOLEAN_MIN 0
 
#define CO_BOOLEAN_MAX 1
 
#define CO_INTEGER8_MIN INT8_MIN
 
#define CO_INTEGER8_MAX INT8_MAX
 
#define CO_INTEGER16_MIN INT16_MIN
 
#define CO_INTEGER16_MAX INT16_MAX
 
#define CO_INTEGER32_MIN INT32_MIN
 
#define CO_INTEGER32_MAX INT32_MAX
 
#define CO_UNSIGNED8_MIN 0
 
#define CO_UNSIGNED8_MAX UINT8_MAX
 
#define CO_UNSIGNED16_MIN 0
 
#define CO_UNSIGNED16_MAX UINT16_MAX
 
#define CO_UNSIGNED32_MIN 0
 
#define CO_UNSIGNED32_MAX UINT32_MAX
 
#define CO_REAL32_MIN (-FLT_MAX)
 
#define CO_REAL32_MAX FLT_MAX
 
#define CO_TIME_OF_DAY_MIN \
        { \
                0, 0 \
        }
 
#define CO_TIME_OF_DAY_MAX \
        { \
                UINT32_C(0x0fffffff), UINT16_MAX \
        }
 
#define CO_TIME_DIFF_MIN CO_TIME_OF_DAY_MIN
 
#define CO_TIME_DIFF_MAX CO_TIME_OF_DAY_MAX
 
#define CO_INTEGER24_MIN (-INT32_C(0x00800000))
 
#define CO_INTEGER24_MAX INT32_C(0x007fffff)
 
#define CO_REAL64_MIN (-DBL_MAX)
 
#define CO_REAL64_MAX DBL_MAX
 
#define CO_INTEGER40_MIN (-INT64_C(0x0000008000000000))
 
#define CO_INTEGER40_MAX INT64_C(0x0000007fffffffff)
 
#define CO_INTEGER48_MIN (-INT64_C(0x0000800000000000))
 
#define CO_INTEGER48_MAX INT64_C(0x00007fffffffffff)
 
#define CO_INTEGER56_MIN (-INT64_C(0x0080000000000000))
 
#define CO_INTEGER56_MAX INT64_C(0x007fffffffffffff)
 
#define CO_INTEGER64_MIN INT64_MIN
 
#define CO_INTEGER64_MAX INT64_MAX
 
#define CO_UNSIGNED24_MIN 0
 
#define CO_UNSIGNED24_MAX UINT32_C(0x00ffffff)
 
#define CO_UNSIGNED40_MIN 0
 
#define CO_UNSIGNED40_MAX UINT64_C(0x000000ffffffffff)
 
#define CO_UNSIGNED48_MIN 0
 
#define CO_UNSIGNED48_MAX UINT64_C(0x0000ffffffffffff)
 
#define CO_UNSIGNED56_MIN 0
 
#define CO_UNSIGNED56_MAX UINT64_C(0x00ffffffffffffff)
 
#define CO_UNSIGNED64_MIN 0
 
#define CO_UNSIGNED64_MAX UINT64_MAX
 
union co_val {
#define LELY_CO_DEFINE_TYPE(a, b, c, d) co_##b##_t c;
#include <lely/co/def/type.def>
#undef LELY_CO_DEFINE_TYPE
};
 
#if __STDC_VERSION__ >= 199901L
 
#define _CO_ARRAY(...) __VA_ARGS__
 
#define CO_VISIBLE_STRING_C(c) \
        (((struct { \
                size_t size; \
                union { \
                        union co_val val; \
                        char vs[sizeof(c)]; \
                } u; \
        }){ .size = sizeof(c) - 1, .u = { .vs = c } }) \
                                        .u.vs)
 
#define CO_OCTET_STRING_C(c) \
        (((struct { \
                size_t size; \
                union { \
                        union co_val val; \
                        uint8_t os[sizeof(c)]; \
                } u; \
        }){ .size = sizeof(c) - 1, .u = { .os = c } }) \
                                        .u.os)
 
#define CO_UNICODE_STRING_C(...) _CO_UNICODE_STRING_C(_CO_ARRAY(__VA_ARGS__))
 
// clang-format off
#define _CO_UNICODE_STRING_C(c) \
        (((struct { \
                size_t size; \
                union { \
                        union co_val val; \
                        char16_t us[sizeof((char16_t[])c) / sizeof(char16_t)]; \
                } u; \
        }){ .size = sizeof((char16_t[])c) - sizeof(char16_t), \
                        .u = { .us = c } }) \
                                        .u.us)
// clang-format on
 
#define CO_DOMAIN_C(type, ...) _CO_DOMAIN_C(type, _CO_ARRAY(__VA_ARGS__))
 
#define _CO_DOMAIN_C(type, c) \
        (((struct { \
                size_t size; \
                union { \
                        union co_val val; \
                        type dom[sizeof((type[])c) / sizeof(type)]; \
                } u; \
        }){ .size = sizeof((type[])c), .u = { .dom = c } }) \
                                        .u.dom)
 
#endif // __STDC_VERSION__ >= 199901L
 
// The file location struct from <lely/util/diag.h>.
struct floc;
 
#ifdef __cplusplus
extern "C" {
#endif
 
int co_val_init(co_unsigned16_t type, void *val);
 
int co_val_init_min(co_unsigned16_t type, void *val);
 
int co_val_init_max(co_unsigned16_t type, void *val);
 
int co_val_init_vs(char **val, const char *vs);
 
int co_val_init_vs_n(char **val, const char *vs, size_t n);
 
int co_val_init_os(uint8_t **val, const uint8_t *os, size_t n);
 
int co_val_init_us(char16_t **val, const char16_t *us);
 
int co_val_init_us_n(char16_t **val, const char16_t *us, size_t n);
 
int co_val_init_dom(void **val, const void *dom, size_t n);
 
void co_val_fini(co_unsigned16_t type, void *val);
 
const void *co_val_addressof(co_unsigned16_t type, const void *val);
 
size_t co_val_sizeof(co_unsigned16_t type, const void *val);
 
size_t co_val_make(co_unsigned16_t type, void *val, const void *ptr, size_t n);
 
size_t co_val_copy(co_unsigned16_t type, void *dst, const void *src);
 
size_t co_val_move(co_unsigned16_t type, void *dst, void *src);
 
int co_val_cmp(co_unsigned16_t type, const void *v1, const void *v2);
 
size_t co_val_read(co_unsigned16_t type, void *val, const uint8_t *begin,
                const uint8_t *end);
 
co_unsigned32_t co_val_read_sdo(
                co_unsigned16_t type, void *val, const void *ptr, size_t n);
 
size_t co_val_write(co_unsigned16_t type, const void *val, uint8_t *begin,
                uint8_t *end);
 
size_t co_val_lex(co_unsigned16_t type, void *val, const char *begin,
                const char *end, struct floc *at);
 
size_t co_val_print(co_unsigned16_t type, const void *val, char **pbegin,
                char *end);
 
#ifdef __cplusplus
}
#endif
 
#endif // !LELY_CO_VAL_H_