stype.h

Go to the documentation of this file.

#pragma once
 
 
 
 
#include <cx/debug/assert.h>
#include <cx/platform/base.h>
#include <cx/platform/cpp.h>
#include <cx/string/strliteral.h>
#include <cx/utils/macros/optarg.h>
#include <cx/utils/macros/salieri.h>
#include <cx/utils/macros/unused.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
// extra files that can be included for specific functions
#define STYPE_FOREACH_ALL <cx/stype/alltypes.inc>
 
CX_C_BEGIN
 
// do this as a typedef instead of a #define
#ifdef bool
#undef bool
#endif
 
// IMPORTANT NOTE!
// Always initialize string to NULL or 0 first!
typedef struct str_ref* _Nullable string;
typedef const struct str_ref* _Nullable strref;
typedef struct hashtable_ref* hashtable;
typedef struct closure_ref* closure;
typedef struct cchain_ref* cchain;
typedef struct BufferHeader* Buffer;
typedef struct ObjInst ObjInst;
typedef struct ObjInst_WeakRef ObjInst_WeakRef;
typedef struct StructBase StructBase;
typedef struct SUID SUID;
typedef struct stvar stvar;
typedef struct SerWriter SerWriter;
typedef struct SerReader SerReader;
 
enum STYPE_ID_CONSTANTS {
    STCLASS_BASIC   = 0x00000000,   // basic discrete types
    STCLASS_CX      = 0x00010000,   // "CX framework" types (strings, objects, containers)
    STCLASS_DYNAMIC = 0x00020000,   // dynamically defined types created at runtime
    STCLASS_USER    = 0x00100000,   // start of user-defined static type range
 
    // subtypes for STCLASS_BASIC types
    STST_INT   = 0x0100,
    STST_UINT  = 0x0200,
    STST_FLOAT = 0x0300,
    STST_PTR   = 0x0400,
 
    // subtypes for STCLASS_CX types
    // these intentionally don't overlap with the basic subtypes, to allow for easier checks
    STST_OPAQUE    = 0x1000,   // opaque byte blocks, often with custom ops
    STST_MISC      = 0x1100,   // miscallenous CX-related types like SUIDs
    STST_OBJ       = 0x1200,   // object-like types that use pointer handles
    STST_CONTAINER = 0x1300,   // container types
};
 
#define STYPE_CLASS_MASK 0xffff0000
#define STYPE_CLASS(v)   ((v) & STYPE_CLASS_MASK)
 
// subtypes are only valid for STCLASS_BASIC and STCLASS_CX
#define STYPE_HAS_SUBTYPE(v) (STYPE_CLASS(v) == STCLASS_BASIC || STYPE_CLASS(v) == STCLASS_CX)
#define STYPE_SUBTYPE_MASK   0x0000ff00
#define STYPE_SUBTYPE(v)     ((v) & STYPE_SUBTYPE_MASK)
 
typedef signed char int8;
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16;
typedef int int32;
typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef intptr_t intptr;
typedef uintptr_t uintptr;
#ifndef __cplusplus
#if __STDC_VERSION__ < 202311L
// C23 made bool a keyword, so the typedef is both unnecessary and illegal there.
typedef _Bool bool;
#endif
#elif !defined(_Bool)
// Some C++ standard library / compiler configurations (e.g. GNU-extension stdbool.h
// under C++) already #define _Bool as a macro expanding to the built-in bool type.
// Only add the typedef when that hasn't happened, otherwise it becomes a
// self-referential "typedef bool bool;"
typedef bool _Bool;
#endif
 
// limits for integer types
 
#define MIN_INT8   (-0x7f - 1)
#define MAX_INT8   0x7f
#define MAX_UINT8  0xff
#define MIN_INT16  (-0x7fff - 1)
#define MAX_INT16  0x7fff
#define MAX_UINT16 0xffff
#define MIN_INT32  (-0x7fffffffL - 1)
#define MAX_INT32  0x7fffffffL
#define MAX_UINT32 0xffffffffUL
#define MAX_INT64  0x7fffffffffffffffLL
#define MIN_INT64  (-0x7fffffffffffffffLL - 1)
#define MAX_UINT64 0xffffffffffffffffULL
 
#if defined(_64BIT)
#define MIN_INTPTR  MIN_INT64
#define MAX_INTPTR  MAX_INT64
#define MAX_UINTPTR MAX_UINT64
#elif defined(_32BIT)
#define MIN_INTPTR  MIN_INT32
#define MAX_INTPTR  MAX_INT32
#define MAX_UINTPTR MAX_UINT32
#endif
 
typedef float float32;
typedef double float64;
 
typedef struct STypeOps STypeOps;
// stype is a pointer to the canonical STypeInfo structure for the type
typedef struct STypeInfo STypeInfo;
typedef const STypeInfo* stype;
typedef struct STypeInfoExt STypeInfoExt;
 
// standardize on uint32 for function call flags
typedef uint32 flags_t;
 
// sarrays are special because of the pointer union
typedef union sa_ref {
    void* _is_sarray;
    void* a;
} sa_ref;
typedef union sa_ref* sahandle;
 
// This is the type that is used for passing as a parameter by-value, as well as variants. Should be
// no larger than 64 bits wide, but can be smaller.
#define SType_none      void*
#define SType_opaque    void*
#define SType_int8      int8
#define SType_int16     int16
#define SType_int32     int32
#define SType_int64     int64
#define SType_uint8     uint8
#define SType_uint16    uint16
#define SType_uint32    uint32
#define SType_uint64    uint64
#define SType_intptr    intptr
#define SType_uintptr   uintptr
#define SType_bool      _Bool
#define SType_size      size_t
#define SType_float32   float32
#define SType_float64   float64
#define SType_ptr       void*
#define SType_string    string
#define SType_strref    strref
#define SType_object    ObjInst*
#define SType_weakref   ObjInst_WeakRef*
#define SType_suid      SUID*
#define SType_stvar     stvar*
#define SType_sarray    sa_ref
#define SType_hashtable hashtable
#define SType_closure   closure
#define SType_cchain    cchain
#define SType_buffer    Buffer
#define SType_struct    StructBase*
#define SType_structp   StructBase*
#define stTypeDef(name) SType_##name
 
 
#define stTypeCast(name, v) ((SType_##name)(v))
 
#define stPtrCast(name, v) ((SType_##name*)(v))
 
// container that can be aliased for any type
#define CONTAINER_TYPE(type) stTypeDef(type) st_##type
typedef union stgeneric {
    uint64 st_generic;
    CONTAINER_TYPE(none);
    CONTAINER_TYPE(opaque);
    CONTAINER_TYPE(int8);
    CONTAINER_TYPE(int16);
    CONTAINER_TYPE(int32);
    CONTAINER_TYPE(int64);
    CONTAINER_TYPE(uint8);
    CONTAINER_TYPE(uint16);
    CONTAINER_TYPE(uint32);
    CONTAINER_TYPE(uint64);
    CONTAINER_TYPE(intptr);
    CONTAINER_TYPE(uintptr);
    CONTAINER_TYPE(bool);
    CONTAINER_TYPE(size);
    CONTAINER_TYPE(float32);
    CONTAINER_TYPE(float64);
    CONTAINER_TYPE(ptr);
    CONTAINER_TYPE(string);
    CONTAINER_TYPE(strref);
    CONTAINER_TYPE(object);
    CONTAINER_TYPE(weakref);
    CONTAINER_TYPE(suid);
    CONTAINER_TYPE(stvar);
    CONTAINER_TYPE(sarray);
    CONTAINER_TYPE(hashtable);
    CONTAINER_TYPE(closure);
    CONTAINER_TYPE(cchain);
    CONTAINER_TYPE(buffer);
    CONTAINER_TYPE(struct);
    CONTAINER_TYPE(structp);
} stgeneric;
 
_Static_assert(sizeof(stgeneric) == sizeof(uint64), "stype container too large");
 
#ifndef __cplusplus
#define stgeneric(type, val)           ((stgeneric) { .st_##type = stCheck(type, val) })
#define stgeneric_unchecked(type, val) ((stgeneric) { .st_##type = (val) })
#define stgensarray(val)               stgeneric(ptr, (val)._is_sarray)
#else
// C++ definitions of stgeneric / stgeneric_unchecked / stgensarray live in
// stype_cxx.hpp
#endif
 
// Compact variant structure. This is most often used for passing arrays of values that
// the type is not known at compile time, as part of the type-safe varargs replacement
// mechanism.
 
typedef struct stvar {
    stgeneric data;
    stype _type;        // low bit: STVAR_OwnsData; use stvarType()/setters below
    const char* _key;   // optional key; NULL or program-lifetime. Use stvarKey().
} stvar;
 
// Low-bit tag stashed in the _type pointer. stype is a pointer to a canonical STypeInfo
// descriptor which is always at least pointer-aligned, so bit 0 is free to record whether
// this stvar owns a heap allocation holding an oversized (PassPtr) value.
enum { STVAR_OwnsData = 1 };
 
_meta_inline stype stvarType(const stvar* v)
{
    return (stype)((uintptr)v->_type & ~(uintptr)STVAR_OwnsData);
}
 
#define stvarTypeId(v) (stvarType(v)->id)
 
// True if this variant owns a heap allocation backing a PassPtr value.
_meta_inline bool _stvarOwns(const stvar* v)
{
    return ((uintptr)v->_type & STVAR_OwnsData) != 0;
}
 
// Set the type descriptor and ownership tag together. t must be a clean (untagged) stype.
_meta_inline void _stvarSetType(stvar* v, stype t, bool owns)
{
    dbgAssert(((uintptr)t & STVAR_OwnsData) == 0);   // alignment sanity
    v->_type = (stype)((uintptr)t | (owns ? STVAR_OwnsData : 0));
}
 
_meta_inline const char* stvarKey(const stvar* v)
{
    return v->_key;
}
 
// Attach a key name to a variant. nm must be NULL or have program lifetime -- it is
// pointer-copied, never duplicated. Prefer the stvark() macro, which stringizes a token
// and so cannot be handed a pointer that dangles.
_meta_inline void _stvarSetKey(stvar* v, const char* nm)
{
    v->_key = nm;
}
 
// The type that's actually used for storage in containers, etc.
#define STStorageType_none      void
#define STStorageType_opaque    void
#define STStorageType_int8      int8
#define STStorageType_int16     int16
#define STStorageType_int32     int32
#define STStorageType_int64     int64
#define STStorageType_uint8     uint8
#define STStorageType_uint16    uint16
#define STStorageType_uint32    uint32
#define STStorageType_uint64    uint64
#define STStorageType_intptr    intptr
#define STStorageType_uintptr   uintptr
#define STStorageType_bool      _Bool
#define STStorageType_size      size_t
#define STStorageType_float32   float32
#define STStorageType_float64   float64
#define STStorageType_ptr       void*
#define STStorageType_string    string
#define STStorageType_strref    string
#define STStorageType_object    ObjInst*
#define STStorageType_weakref   ObjInst_WeakRef*
#define STStorageType_suid      SUID
#define STStorageType_stvar     stvar
#define STStorageType_sarray    sa_ref
#define STStorageType_hashtable hashtable
#define STStorageType_closure   closure
#define STStorageType_cchain    cchain
#define STStorageType_buffer    Buffer
#define STStorageType_struct    StructBase
#define STStorageType_structp   StructBase*
#define stStorageType(name)     STStorageType_##name
 
enum STYPE_ID {
    // none is a special type for empty argument lists, variants, etc
    STypeId_none   = STCLASS_BASIC | 0,
    // opaque is a magic catch-all type for custom structures and such
    STypeId_opaque = STCLASS_CX | STST_OPAQUE | 1,
    // generic scalar types
    STypeId_int8   = STCLASS_BASIC | STST_INT | 1,
    STypeId_int16  = STCLASS_BASIC | STST_INT | 2,
    STypeId_int32  = STCLASS_BASIC | STST_INT | 4,
    STypeId_int64  = STCLASS_BASIC | STST_INT | 8,
    STypeId_intptr = STCLASS_BASIC | STST_INT |
        sizeof(intptr),   // alias for one of the other int types
    STypeId_uint8   = STCLASS_BASIC | STST_UINT | 1,
    STypeId_uint16  = STCLASS_BASIC | STST_UINT | 2,
    STypeId_uint32  = STCLASS_BASIC | STST_UINT | 4,
    STypeId_uint64  = STCLASS_BASIC | STST_UINT | 8,
    STypeId_uintptr = STCLASS_BASIC | STST_UINT | sizeof(intptr),
    STypeId_bool    = STCLASS_BASIC | STST_UINT | 3,             // fill in a gap in the ID sequence
    STypeId_size = STCLASS_BASIC | STST_UINT | sizeof(size_t),   // alias for one of the uint types
    STypeId_float32   = STCLASS_BASIC | STST_FLOAT | 4,
    STypeId_float64   = STCLASS_BASIC | STST_FLOAT | 8,
    STypeId_ptr       = STCLASS_BASIC | STST_PTR | sizeof(void*),
    // most of the CX class are "object-like" types and use pointers as handles
    STypeId_suid      = STCLASS_CX | STST_MISC | 0,   // notable exception
    STypeId_string    = STCLASS_CX | STST_OBJ | 0,
    STypeId_strref    = STCLASS_CX | STST_OBJ | 0,
    STypeId_object    = STCLASS_CX | STST_OBJ | 1,
    STypeId_weakref   = STCLASS_CX | STST_OBJ | 2,
    STypeId_stvar     = STCLASS_CX | STST_OBJ | 3,
    STypeId_closure   = STCLASS_CX | STST_OBJ | 4,
    STypeId_buffer    = STCLASS_CX | STST_OBJ | 5,
    STypeId_struct    = STCLASS_CX | STST_OBJ | 6,
    STypeId_structp   = STCLASS_CX | STST_OBJ | 7,
    STypeId_sarray    = STCLASS_CX | STST_CONTAINER | 0,
    STypeId_hashtable = STCLASS_CX | STST_CONTAINER | 1,
    STypeId_cchain    = STCLASS_CX | STST_CONTAINER | 2,
};
 
#define stTypeId(name) STypeId_##name
 
// The actual storage size of the type
enum STYPE_SIZE {
    STypeSize_none      = 0,
    // opaque is not really size 0, but filled by by macros later
    STypeSize_opaque    = 0,
    STypeSize_int8      = sizeof(int8),
    STypeSize_int16     = sizeof(int16),
    STypeSize_int32     = sizeof(int32),
    STypeSize_int64     = sizeof(int64),
    STypeSize_intptr    = sizeof(intptr),
    STypeSize_uint8     = sizeof(int8),
    STypeSize_uint16    = sizeof(int16),
    STypeSize_uint32    = sizeof(int32),
    STypeSize_uint64    = sizeof(int64),
    STypeSize_uintptr   = sizeof(uintptr),
    STypeSize_bool      = sizeof(_Bool),
    STypeSize_size      = sizeof(size_t),
    STypeSize_float32   = sizeof(float32),
    STypeSize_float64   = sizeof(float64),
    STypeSize_ptr       = sizeof(void*),
    STypeSize_string    = sizeof(void*),
    STypeSize_strref    = sizeof(void*),
    STypeSize_object    = sizeof(ObjInst*),
    STypeSize_weakref   = sizeof(ObjInst_WeakRef*),
    // SUID is special because it's always passed by reference, but stored as the full 16 bytes
    STypeSize_suid      = 16,
    STypeSize_stvar     = sizeof(stvar),
    STypeSize_sarray    = sizeof(sa_ref),
    STypeSize_hashtable = sizeof(hashtable),
    STypeSize_closure   = sizeof(closure),
    STypeSize_cchain    = sizeof(cchain),
    STypeSize_buffer    = sizeof(Buffer),
    // similar to opaque, not known at compile time
    STypeSize_struct    = 0,
    STypeSize_structp   = sizeof(StructBase*),
};
 
#define stTypeSize(name) STypeSize_##name
 
enum STYPE_FLAGS {
    STypeFlag_Object    = (1 << 0),   // "object-like" type -- pointer to managed object
    STypeFlag_PassPtr   = (1 << 1),   // type is passed by pointer rather than by value,
                                      // does not apply to 'handle' style objects
    STypeFlag_Temporary = (1 << 2),   // type info is temporary, i.e. constructed as a compound
                                      // literal or otherwise dynamic. must be registered into the
                                      // global type registry before use
};
#define stFlag(name) STypeFlag_##name
 
#define stHasFlag(st, fname) (((st)->flags & stFlag(fname)) != 0)
 
#define stGetSize(st) ((st)->size)
 
// Static type checks
// These types all include the marker as either the first member, or as part of
// a union that coincides with the first member. Therefore we can take their address
// and get the address of the parent structure that we already had (essentially a no-op)
// while checking that they exist, thus verifying the type is correct.
// Note the magic of the comma operator -- these prevent compilation if something is wrong,
// but get optimized away entirely and do not emit any code.
// The use of unused_noeval further improves this by hiding it in a conditional branch that
// is guaranteed to not be evaluated, preventing any side effects such as function calls or
// postfix operators.
// The seemingly redundant (h) && portions of the expression are there solely to suppress
// warnings from stupid compilers that don't understand it can never actually be dereferenced.
#define saCheckType(name, h) ((sa_##name*)(unused_noeval((h) && &((h)->is_sarray_##name)), (h)))
#define saCheck(s)           (unused_noeval(&((s)._is_sarray)), (s.a))
#define saCheckPtr(h)        (unused_noeval((h != NULL) && &((h)->_is_sarray)), (h))
#define htCheck(h)           (unused_noeval((h) && &((h)->_is_hashtable)), (h))
#define htCheckPtr(h)        (unused_noeval((h) && (*h) && &((*h)->_is_hashtable)), (h))
#define objInstCheck(o)      (unused_noeval((o) && &((o)->_is_ObjInst)), (o))
#define objInstCheckPtr(o)   (unused_noeval((o != NULL) && (*o) && &((*o)->_is_ObjInst)), (o))
#define objInstCheckClass(cls, o) (unused_noeval((o) && &((o)->_is_##cls)), (cls*)(o))
#define objInstCheckClassPtr(cls, o) \
    (unused_noeval((o != NULL) && (*o) && &((*o)->_is_##cls)), (cls**)(o))
#define objWeakRefCheck(o)    (unused_noeval((o) && &((o)->_is_ObjInst_WeakRef)), (o))
#define objWeakRefCheckPtr(o) (unused_noeval((o) && (*o) && &((*o)->_is_ObjInst_WeakRef)), (o))
#define objWeakRefCheckClass(cls, o) \
    (unused_noeval((o) && &((o)->_is_##cls##_WeakRef)), (cls##_WeakRef*)(o))
#define objWeakRefCheckClassPtr(cls, o) \
    (unused_noeval((o) && (*o) && &((*o)->_is_##cls##_WeakRef)), (cls##_WeakRef**)(o))
#define strCheck(s)          (unused_noeval((s) && &((s)->_is_string)), (s))
#define strCheckPtr(s)       (unused_noeval((s != NULL) && (*s) && &((*s)->_is_string)), (s))
#define closureCheck(c)      (unused_noeval((c) && &((c)->_is_closure)), (c))
#define closureCheckPtr(c)   (unused_noeval((c != NULL) && (*c) && &((*c)->_is_closure)), (c))
#define cchainCheck(c)       (unused_noeval((c) && &((c)->_is_closure_chain)), (c))
#define cchainCheckPtr(c)    (unused_noeval((c != NULL) && (*c) && &((*c)->_is_closure_chain)), (c))
#define bufferCheck(c)       (unused_noeval((c) && &((c)->_is_buffer)), (c))
#define bufferCheckPtr(c)    (unused_noeval((c != NULL) && (*c) && &((*c)->_is_buffer)), (c))
#define structCheckPtr(s)    (unused_noeval((s != NULL) && &((s)->_is_struct)), (s))
#define structCheckPtrPtr(s) (unused_noeval((s != NULL) && (*s) && &((*s)->_is_struct)), (s))
 
// most of these are no-ops, but some can do extra type checking
#define STypeCheck_opaque(type, val)    (val)
#define STypeCheck_int8(type, val)      (val)
#define STypeCheck_int16(type, val)     (val)
#define STypeCheck_int32(type, val)     (val)
#define STypeCheck_int64(type, val)     (val)
#define STypeCheck_intptr(type, val)    (val)
#define STypeCheck_uint8(type, val)     (val)
#define STypeCheck_uint16(type, val)    (val)
#define STypeCheck_uint32(type, val)    (val)
#define STypeCheck_uint64(type, val)    (val)
#define STypeCheck_uintptr(type, val)   (val)
#define STypeCheck_bool(type, val)      (val)
#define STypeCheck_size(type, val)      (val)
#define STypeCheck_float32(type, val)   (val)
#define STypeCheck_float64(type, val)   (val)
#define STypeCheck_ptr(type, val)       (val)
#define STypeCheck_string(type, val)    strCheck(val)
#define STypeCheck_strref(type, val)    strCheck(val)
#define STypeCheck_object(type, val)    objInstCheck(val)
#define STypeCheck_weakref(type, val)   objWeakRefCheck(val)
#define STypeCheck_suid(type, val)      (unused_noeval((((val).low), ((val).high))), (val))
#define STypeCheck_stvar(type, val)     (unused_noeval((((val).data), ((val)._type))), (val))
#define STypeCheck_sarray(type, val)    saCheck(val)
#define STypeCheck_hashtable(type, val) htCheck(val)
#define STypeCheck_closure(type, val)   closureCheck(val)
#define STypeCheck_cchain(type, val)    cchainCheck(val)
#define STypeCheck_buffer(type, val)    bufferCheck(val)
// We get the pointer for bare structs, similar to opaque, but we can type check the structure
#define STypeCheck_struct(type, val)    structCheckPtr(val)
#define STypeCheck_structp(type, val)   structCheckPtr(val)
 
#define stCheck(type, val) STypeCheck_##type(type, val)
 
#define STypeCheckPtr_gen(type, ptr)       (unused_noeval((stTypeDef(type)*)(ptr)), ptr)
#define STypeCheckPtr_opaque(type, ptr)    (ptr)
#define STypeCheckPtr_int8(type, ptr)      (ptr)
#define STypeCheckPtr_int16(type, ptr)     (ptr)
#define STypeCheckPtr_int32(type, ptr)     (ptr)
#define STypeCheckPtr_int64(type, ptr)     (ptr)
#define STypeCheckPtr_intptr(type, ptr)    (ptr)
#define STypeCheckPtr_uint8(type, ptr)     (ptr)
#define STypeCheckPtr_uint16(type, ptr)    (ptr)
#define STypeCheckPtr_uint32(type, ptr)    (ptr)
#define STypeCheckPtr_uint64(type, ptr)    (ptr)
#define STypeCheckPtr_uintptr(type, ptr)   (ptr)
#define STypeCheckPtr_bool(type, ptr)      (ptr)
#define STypeCheckPtr_size(type, ptr)      (ptr)
#define STypeCheckPtr_float32(type, ptr)   (ptr)
#define STypeCheckPtr_float64(type, ptr)   (ptr)
#define STypeCheckPtr_ptr(type, ptr)       (ptr)
#define STypeCheckPtr_string(type, ptr)    strCheckPtr(ptr)
#define STypeCheckPtr_strref(type, ptr)    strCheckPtr(ptr)
#define STypeCheckPtr_object(type, ptr)    objInstCheckPtr(ptr)
#define STypeCheckPtr_weakref(type, ptr)   objWeakRefCheckPtr(ptr)
#define STypeCheckPtr_suid(type, ptr)      (unused_noeval((((ptr)->low), ((ptr)->high))), (ptr))
#define STypeCheckPtr_stvar(type, ptr)     (unused_noeval((((ptr)->data), ((ptr)->_type))), (ptr))
#define STypeCheckPtr_sarray(type, ptr)    saCheckPtr(ptr)
#define STypeCheckPtr_hashtable(type, ptr) htCheckPtr(ptr)
#define STypeCheckPtr_closure(type, ptr)   closureCheckPtr(ptr)
#define STypeCheckPtr_cchain(type, ptr)    cchainCheckPtr(ptr)
#define STypeCheckPtr_buffer(type, ptr)    bufferCheckPtr(ptr)
#define STypeCheckPtr_struct(type, ptr)    structCheckPtr(ptr)
#define STypeCheckPtr_structp(type, ptr)   structCheckPtrPtr(ptr)
 
#define stCheckPtr(type, ptr) STypeCheckPtr_##type(type, ptr)
 
// C99 compound literals are lvalues and can force the compiler to create a temporary
// on the stack if necessary, so that we can pass pointers to arbitrary expressions
#define stRvalAddr(type, rval) ((stStorageType(type)[1]) { rval })
 
 
// Canonical type information for builtin types
extern const STypeInfo _sti_none;
extern const STypeInfo _sti_int8;
extern const STypeInfo _sti_int16;
extern const STypeInfo _sti_int32;
extern const STypeInfo _sti_int64;
extern const STypeInfo _sti_uint8;
extern const STypeInfo _sti_uint16;
extern const STypeInfo _sti_uint32;
extern const STypeInfo _sti_uint64;
extern const STypeInfo _sti_bool;
extern const STypeInfo _sti_float32;
extern const STypeInfo _sti_float64;
extern const STypeInfo _sti_ptr;
extern const STypeInfo _sti_string;
extern const STypeInfo _sti_object;
extern const STypeInfo _sti_weakref;
extern const STypeInfo _sti_suid;
extern const STypeInfo _sti_stvar;
extern const STypeInfo _sti_sarray;
extern const STypeInfo _sti_hashtable;
extern const STypeInfo _sti_closure;
extern const STypeInfo _sti_cchain;
extern const STypeInfo _sti_buffer;
extern const STypeInfo _sti_structp;
 
extern const STypeOps _stops_opaque;
extern const STypeOps _stops_struct;
 
// canonical type info name for static types
#define stTypeInfo(name) _sti_##name
 
// MEGA PREPROCESSOR HACKS INCOMING
// this enables the use of opaque(realtype) as type name in functions like saCreate
#ifndef __cplusplus
#define _sti_opaque(realtype)                                          \
    ((const STypeInfo) { .id    = stTypeId(opaque),                    \
                         .flags = stFlag(PassPtr) | stFlag(Temporary), \
                         .size  = (uint16)sizeof(realtype),            \
                         .ops   = _stops_opaque })
#define _sti_struct(realtype)                                                           \
    ((const STypeInfo) { .id    = stTypeId(struct),                                     \
                         .flags = stFlag(PassPtr) | stFlag(Object) | stFlag(Temporary), \
                         .size  = (uint16)sizeof(realtype),                             \
                         .ops   = _stops_struct })
#else
// C++ versions of _sti_opaque / _sti_struct are defined in stype_cxx.hpp
#endif
 
// aliases for types that don't have their own info
 
#define _sti_strref _sti_string
 
// these are architecture-dependant alises
#if defined(_64BIT)
#define _sti_intptr  _sti_int64
#define _sti_uintptr _sti_uint64
#define _sti_size    _sti_uint64
#else
#define _sti_intptr  _sti_int32
#define _sti_uintptr _sti_uint32
#define _sti_size    _sti_uint32
#endif
 
 
#define stType(name) (&stTypeInfo(name))
 
// Macros for passing arguments by value
 
// none ignores the value
#define STypeArg_none(type, val)    ((stgeneric) { 0 })
// opqaue is a special case that must always be passed by pointer, and
// the caller must supply an lvalue
#define STypeArg_opaque(type, val)  stgeneric(type, &(val))
// but everything else gets put into a container
#define STypeArg_int8(type, val)    stgeneric(type, val)
#define STypeArg_int16(type, val)   stgeneric(type, val)
#define STypeArg_int32(type, val)   stgeneric(type, val)
#define STypeArg_int64(type, val)   stgeneric(type, val)
#define STypeArg_intptr(type, val)  stgeneric(type, val)
#define STypeArg_uint8(type, val)   stgeneric(type, val)
#define STypeArg_uint16(type, val)  stgeneric(type, val)
#define STypeArg_uint32(type, val)  stgeneric(type, val)
#define STypeArg_uint64(type, val)  stgeneric(type, val)
#define STypeArg_uintptr(type, val) stgeneric(type, val)
#define STypeArg_bool(type, val)    stgeneric(type, val)
#define STypeArg_size(type, val)    stgeneric(type, val)
#define STypeArg_float32(type, val) stgeneric(type, val)
#define STypeArg_float64(type, val) stgeneric(type, val)
#define STypeArg_ptr(type, val)     stgeneric(type, val)
#define STypeArg_string(type, val)  stgeneric(type, val)
#define STypeArg_strref(type, val)  stgeneric(type, val)
#define STypeArg_object(type, val)  stgeneric(type, objInstBase(val))
#define STypeArg_weakref(type, val) stgeneric(type, objWeakRefBase(val))
// SUID and stvar are too big, so make a copy and pass a pointer
#define STypeArg_suid(type, val)    stgeneric_unchecked(type, stRvalAddr(type, stCheck(type, val)))
#define STypeArg_stvar(type, val)   stgeneric_unchecked(type, stRvalAddr(type, stCheck(type, val)))
#define STypeArg_sarray(type, val)  stgensarray(val)
#define STypeArg_hashtable(type, val) stgeneric(type, val)
#define STypeArg_closure(type, val)   stgeneric(type, val)
#define STypeArg_cchain(type, val)    stgeneric(type, val)
#define STypeArg_buffer(type, val)    stgeneric(type, val)
// struct works like opaque
#define STypeArg_struct(type, val)    stgeneric(type, &(val))
#define STypeArg_structp(type, val)   stgeneric(type, val)
 
#define stArg(type, val) STypeArg_##type(type, val)
 
// And for passing a pointer-to-pointer, mostly for functions that want to
// consume or reallocate the object
 
#define STypeArgPtr_none(type, val)      NULL
// opaque is already passed in as a pointer
#define STypeArgPtr_opaque(type, val)    &stgeneric(type, val)
#define STypeArgPtr_int8(type, val)      (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_int16(type, val)     (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_int32(type, val)     (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_int64(type, val)     (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_intptr(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_uint8(type, val)     (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_uint16(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_uint32(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_uint64(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_uintptr(type, val)   (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_bool(type, val)      (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_size(type, val)      (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_float32(type, val)   (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_float64(type, val)   (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_ptr(type, val)       (stgeneric*)stCheckPtr(type, (void**)(val))
#define STypeArgPtr_string(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_strref(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_object(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_weakref(type, val)   (stgeneric*)stCheckPtr(type, val)
// same for the other pass-by-pointer cases (SUID, stvar)
#define STypeArgPtr_suid(type, val)      &stgeneric_unchecked(type, stCheckPtr(type, val))
#define STypeArgPtr_stvar(type, val)     &stgeneric_unchecked(type, stCheckPtr(type, val))
#define STypeArgPtr_sarray(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_hashtable(type, val) (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_closure(type, val)   (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_cchain(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_buffer(type, val)    (stgeneric*)stCheckPtr(type, val)
#define STypeArgPtr_struct(type, val)    &stgeneric(type, val)
#define STypeArgPtr_structp(type, val)   (stgeneric*)stCheckPtr(type, val)
 
#define stArgPtr(type, val) STypeArgPtr_##type(type, val)
 
// Macros for type-checked inline metafunctions.
// These expand to a pair of parameters for type, followed by a pointer.
 
#define STypeCheckedArg_none(type, val)      stType(type), stArg(type, val)
#define STypeCheckedArg_opaque(type, val)    (&_sti_opaque(val)), stArg(type, val)
#define STypeCheckedArg_int8(type, val)      stType(type), stArg(type, val)
#define STypeCheckedArg_int16(type, val)     stType(type), stArg(type, val)
#define STypeCheckedArg_int32(type, val)     stType(type), stArg(type, val)
#define STypeCheckedArg_int64(type, val)     stType(type), stArg(type, val)
#define STypeCheckedArg_intptr(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_uint8(type, val)     stType(type), stArg(type, val)
#define STypeCheckedArg_uint16(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_uint32(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_uint64(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_uintptr(type, val)   stType(type), stArg(type, val)
#define STypeCheckedArg_bool(type, val)      stType(type), stArg(type, val)
#define STypeCheckedArg_size(type, val)      stType(type), stArg(type, val)
#define STypeCheckedArg_float32(type, val)   stType(type), stArg(type, val)
#define STypeCheckedArg_float64(type, val)   stType(type), stArg(type, val)
#define STypeCheckedArg_ptr(type, val)       stType(type), stArg(type, val)
#define STypeCheckedArg_string(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_strref(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_object(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_weakref(type, val)   stType(type), stArg(type, val)
#define STypeCheckedArg_suid(type, val)      stType(type), stArg(type, val)
#define STypeCheckedArg_stvar(type, val)     stType(type), stArg(type, val)
#define STypeCheckedArg_sarray(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_hashtable(type, val) stType(type), stArg(type, val)
#define STypeCheckedArg_closure(type, val)   stType(type), stArg(type, val)
#define STypeCheckedArg_cchain(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_buffer(type, val)    stType(type), stArg(type, val)
#define STypeCheckedArg_struct(type, val)    (&_sti_struct(val)), stArg(type, val)
#define STypeCheckedArg_structp(type, val)   stType(type), stArg(type, val)
 
#define stCheckedArg(type, val) STypeCheckedArg_##type(type, val)
 
// Type checking of pointers to types, mostly for functions that want to
// consume object-like variables and destroy them
 
#define STypeCheckedPtrArg_none(type, val)      stType(type), stArgPtr(type, val)
// go the opposite direction for opaque since it's already passed in as a pointer
#define STypeCheckedPtrArg_opaque(type, val)    (&_sti_opaque(*val)), stArgPtr(type, val)
#define STypeCheckedPtrArg_int8(type, val)      stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_int16(type, val)     stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_int32(type, val)     stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_int64(type, val)     stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_intptr(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_uint8(type, val)     stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_uint16(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_uint32(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_uint64(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_uintptr(type, val)   stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_bool(type, val)      stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_size(type, val)      stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_float32(type, val)   stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_float64(type, val)   stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_ptr(type, val)       stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_string(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_strref(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_object(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_weakref(type, val)   stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_suid(type, val)      stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_stvar(type, val)     stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_sarray(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_hashtable(type, val) stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_closure(type, val)   stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_cchain(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_buffer(type, val)    stType(type), stArgPtr(type, val)
#define STypeCheckedPtrArg_struct(type, val)    (&_sti_struct(*val)), stArgPtr(type, val)
#define STypeCheckedPtrArg_structp(type, val)   stType(type), stArgPtr(type, val)
 
#define stCheckedPtrArg(type, val) STypeCheckedPtrArg_##type(type, val)
 
 
 
enum STYPE_OPS_FLAGS {
    ST_CaseInsensitive = 0x00000001,
 
    ST_Equality = 0x00000002,
 
    ST_Overflow = 0x00000004,
 
    ST_Lossless = 0x00000008,
};
 
 
 
#define _stCopyDest_Anno_(typvar)     _Post_valid_ _When_(stHasFlag(typvar, PassPtr), _Pre_valid_)
#define _stCopyDest_Anno_opt_(typvar) _Out_opt_ _When_(stHasFlag(typvar, PassPtr), _Pre_opt_valid_)
 
typedef void (*stDtorFunc)(stype st, _Pre_notnull_ _Post_invalid_ stgeneric* gen, flags_t flags);
 
typedef intptr (*stCmpFunc)(stype st, _In_ stgeneric gen1, _In_ stgeneric gen2, flags_t flags);
 
typedef uint32 (*stHashFunc)(stype st, _In_ stgeneric gen, flags_t flags);
 
typedef void (*stCopyFunc)(stype st, _stCopyDest_Anno_(st) stgeneric* dest, _In_ stgeneric src,
                           flags_t flags);
 
typedef _Success_(return)
_Check_return_ bool (*stConvertFunc)(stype destst, _stCopyDest_Anno_(destst) stgeneric* dest,
                                     stype srcst, _In_ stgeneric src, flags_t flags);
 
typedef bool (*stSerializeFunc)(stype st, stgeneric val, _Inout_ SerWriter* w);
 
typedef bool (*stDeserializeFunc)(stype st, _Inout_ stgeneric* val, _Inout_ SerReader* r);
 
typedef struct STypeOps {
    stDtorFunc dtor;
    stCmpFunc cmp;
    stHashFunc hash;
    stCopyFunc copy;
    stConvertFunc convert;
    stSerializeFunc serialize;      
    stDeserializeFunc deserialize;  
} STypeOps;
 
typedef struct STypeInfo {
    uint32 id;      
    uint16 size;    
    uint16 flags;   
 
    STypeOps ops;   
} STypeInfo;
 
 
 
enum STypeInfoExtFlagsEnum {
    STIE_TypeSet = (1 << 0),
};
 
typedef struct STypeInfoExt {
    stype type;     
    uint32 flags;   
 
    strref name;
 
    const void* detail;
 
    const STypeInfoExt* param[2];   
} STypeInfoExt;
 
extern const STypeInfoExt _stie_none;
extern const STypeInfoExt _stie_bool;        
extern const STypeInfoExt _stie_int8;        
extern const STypeInfoExt _stie_int16;       
extern const STypeInfoExt _stie_int32;       
extern const STypeInfoExt _stie_int64;       
extern const STypeInfoExt _stie_uint8;       
extern const STypeInfoExt _stie_uint16;      
extern const STypeInfoExt _stie_uint32;      
extern const STypeInfoExt _stie_uint64;      
extern const STypeInfoExt _stie_float32;     
extern const STypeInfoExt _stie_float64;     
extern const STypeInfoExt _stie_string;      
extern const STypeInfoExt _stie_suid;        
extern const STypeInfoExt _stie_object;      
extern const STypeInfoExt _stie_buffer;      
extern const STypeInfoExt _stie_stvar;       
extern const STypeInfoExt _stie_sarray;      
extern const STypeInfoExt _stie_hashtable;   
 
#define stExt(name) (&_stie_##name)
 
 
 
_meta_inline stgeneric _stStoredVal(stype st, _In_ const void* storage)
{
    stgeneric ret;
    switch (st->size) {
    case 1:
        ret.st_uint8 = *(uint8*)storage;
        break;
    case 2:
        ret.st_uint16 = *(uint16*)storage;
        break;
    case 4:
        ret.st_uint32 = *(uint32*)storage;
        break;
    case 8:
        ret.st_uint64 = *(uint64*)storage;
        break;
    default:
        devFatalError("Invalid small stype size");
        ret.st_uint64 = 0;
    }
    return ret;
}
 
#define stStored(st, storage) \
    (stHasFlag(st, PassPtr) ? stgeneric(ptr, (void*)(storage)) : _stStoredVal(st, storage))
 
#define stStoredPtr(st, storage) \
    (stHasFlag(st, PassPtr) ? &stgeneric(ptr, ((void*)(storage))) : (stgeneric*)((void*)(storage)))
 
#define stGenPtr(st, gen) (stHasFlag(st, PassPtr) ? (gen).st_ptr : &(gen))
 
 
 
// inlining these lets most of it get optimized out and specialized if the type is known at
// compile-time
 
#define stDestroy(type, pobj, ...) \
    _stDestroy(stType(type), stArgPtr(type, pobj), opt_flags(__VA_ARGS__))
_meta_inline void _stDestroy(stype st, _Pre_notnull_ _Post_invalid_ stgeneric* gen, flags_t flags)
{
    if (!st)
        return;
 
    if (st->ops.dtor)
        st->ops.dtor(st, gen, flags);
}
 
#ifdef _COMPILER_GCC
// GCC incorrectly emits an array bounds warning on the second memcpy in _stCopy; and we use -Werror
// which turns it into an error. The warning is provably a false positive because it's triggering on
// the int8 case where the size is 1, but the branch that accesses st_ptr is never reached because
// int8 does not have the PassPtr flag.
// The same line also triggers a maybe-uninitialized warning.
// This section also suppresses an incorrect nonnull warning in _stCmp that follows the same pattern
// of the compiler thinking we're accessing the pointer version when we are not.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wunknown-warning-option"
#pragma GCC diagnostic ignored "-Warray-bounds"
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#pragma GCC diagnostic ignored "-Wnonnull"
#endif
 
#define stCmp(type, obj1, obj2, ...) \
    _stCmp(stType(type), stArg(type, obj1), stArg(type, obj2), opt_flags(__VA_ARGS__))
_meta_inline intptr _stCmp(stype st, _In_ stgeneric gen1, _In_ stgeneric gen2, flags_t flags)
{
    if (!st)
        return 1;   // treat null type as always greater (sorts last), mirrors stCmp_none
 
    if (st->ops.cmp)
        return st->ops.cmp(st, gen1, gen2, flags);
 
    if (!stHasFlag(st, PassPtr))
        return memcmp(&gen1, &gen2, st->size);
    else
        return memcmp(gen1.st_ptr, gen2.st_ptr, st->size);
}
 
#define stCopy(type, pdest, src, ...) \
    _stCopy(stType(type), stArgPtr(type, pdest), stArg(type, src), opt_flags(__VA_ARGS__))
_meta_inline void _stCopy(stype st, _stCopyDest_Anno_(st) stgeneric* dest, _In_ stgeneric src,
                          flags_t flags)
{
    if (!st)
        return;
 
    if (st->ops.copy)
        st->ops.copy(st, dest, src, flags);
    else if (!stHasFlag(st, PassPtr))
        memcpy(dest, &src, st->size);
    else
        memcpy(dest->st_ptr, src.st_ptr, st->size);
}
 
#ifdef _COMPILER_GCC
#pragma GCC diagnostic pop
#endif
 
uint32 stHash_gen(stype st, _In_ stgeneric stgen, flags_t flags);
 
#define stHash(type, obj, ...) _stHash(stType(type), stArg(type, obj), opt_flags(__VA_ARGS__))
_meta_inline uint32 _stHash(stype st, _In_ stgeneric gen, flags_t flags)
{
    if (!st)
        return 0;
 
    if (st->ops.hash)
        return st->ops.hash(st, gen, flags);
    else
        return stHash_gen(st, gen, flags);
}
 
// Internal: look up or insert a Temporary descriptor in the global type registry.
// Recursively canonicalizes param[0]/param[1] before keying. Thread-safe via RWLock.
// Always returns a non-Temporary canonical pointer.
stype _stGetCanonical(stype st);
 
_meta_inline stype stCanonical(stype st)
{
    if (!st)
        return stType(none);
 
    if (!stHasFlag(st, Temporary))
        return st;
 
    return _stGetCanonical(st);
}
 
_meta_inline bool stEq(stype s1, stype s2)
{
    return stCanonical(s1) == stCanonical(s2);
}
 
#define stConvert(desttype, pdest, srctype, src, ...) \
    _stConvert(stType(desttype),                      \
               stArgPtr(desttype, pdest),             \
               stType(srctype),                       \
               stArg(srctype, src),                   \
               opt_flags(__VA_ARGS__))
_Success_(return) _Check_return_ _meta_inline bool
_stConvert(stype destst, _stCopyDest_Anno_(destst) stgeneric* dest, stype srcst, _In_ stgeneric src,
           flags_t flags)
{
    if (!srcst || !destst)
        return false;
 
    // The *source* stype is responsible for handling conversions to other types.
    // Compare with stEq rather than by pointer: generated compound descriptors are
    // Temporary, so the same logical type can arrive as two different pointers.
    if (stEq(srcst, destst))
        return _stCopy(destst, dest, src, flags), true;
    if (srcst->ops.convert)
        return srcst->ops.convert(destst, dest, srcst, src, flags);
 
    return false;   // can't convert it if we don't know how!
}
 
 
#define stDeclare(name) extern const STypeInfo _sti_##name
 
#define stDefine(name) const STypeInfo _sti_##name =
 
 
 
 
CX_C_END
 
#ifdef __cplusplus
#include <cx/stype/stype_cxx.hpp>
#endif