Skip to content

Instantly share code, notes, and snippets.

@AlexCeleste

AlexCeleste/test_typeid.c

Last active March 1, 2023 18:56
Show Gist options
  • Save AlexCeleste/146d8789b529bdb0911e610dd6a721e8 to your computer and use it in GitHub Desktop.
Save AlexCeleste/146d8789b529bdb0911e610dd6a721e8 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
test_typeid.c
#include "typeid.h"
_Static_assert (TYPEID (void) == 0, "");
_Static_assert (TYPEID (int) == 6, "");
// _Static_assert (TYPEID (int) == 13, ""); // fails
_Static_assert (TYPEID (double) == 13, "");
// _Static_assert (TYPEID (double) == 7, ""); // fails
struct Foo { int x; };
struct Bar { int x; };
#include TYPEID_COUNTER
ADD_TYPEID (struct Foo)
#include TYPEID_COUNTER
ADD_TYPEID (struct Bar)
_Static_assert (TYPEID (struct Foo) == 15, "");
_Static_assert (TYPEID (struct Bar) == 16, "");
Raw
type_counter.h
// type_counter.h
//
// increment the value of the counter
// every time this file is included
//
// this uses a value representation that can
// easily be converted to a single literal, for pasting
//
// value is handled by binary representation but
// stored in a record of single-bit fields rather than
// as a composite expression
// this can be used as the argument to a simple eval
// or a pretty-print, even supporting different fmts
// (0b, 0x, etc) - select with TYPE_COUNTER_PRINT
//
// 20-bit hex by default
//
// no whole-file guard, repeatable inclusion
#ifndef TYPE_COUNTER_RECORD
// starting value of zero
#define TYPE_COUNTER_RECORD (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
#else
#undef TYPE_COUNT_COPY_BIT_0
#undef TYPE_COUNT_COPY_BIT_1
#undef TYPE_COUNT_COPY_BIT_2
#undef TYPE_COUNT_COPY_BIT_3
#undef TYPE_COUNT_COPY_BIT_4
#undef TYPE_COUNT_COPY_BIT_5
#undef TYPE_COUNT_COPY_BIT_6
#undef TYPE_COUNT_COPY_BIT_7
#undef TYPE_COUNT_COPY_BIT_8
#undef TYPE_COUNT_COPY_BIT_9
#undef TYPE_COUNT_COPY_BIT_10
#undef TYPE_COUNT_COPY_BIT_11
#undef TYPE_COUNT_COPY_BIT_12
#undef TYPE_COUNT_COPY_BIT_13
#undef TYPE_COUNT_COPY_BIT_14
#undef TYPE_COUNT_COPY_BIT_15
#undef TYPE_COUNT_COPY_BIT_16
#undef TYPE_COUNT_COPY_BIT_17
#undef TYPE_COUNT_COPY_BIT_18
#undef TYPE_COUNT_COPY_BIT_19
#define TYPE_COUNT_COPY_BIT_0 0
#define TYPE_COUNT_COPY_BIT_1 0
#define TYPE_COUNT_COPY_BIT_2 0
#define TYPE_COUNT_COPY_BIT_3 0
#define TYPE_COUNT_COPY_BIT_4 0
#define TYPE_COUNT_COPY_BIT_5 0
#define TYPE_COUNT_COPY_BIT_6 0
#define TYPE_COUNT_COPY_BIT_7 0
#define TYPE_COUNT_COPY_BIT_8 0
#define TYPE_COUNT_COPY_BIT_9 0
#define TYPE_COUNT_COPY_BIT_10 0
#define TYPE_COUNT_COPY_BIT_11 0
#define TYPE_COUNT_COPY_BIT_12 0
#define TYPE_COUNT_COPY_BIT_13 0
#define TYPE_COUNT_COPY_BIT_14 0
#define TYPE_COUNT_COPY_BIT_15 0
#define TYPE_COUNT_COPY_BIT_16 0
#define TYPE_COUNT_COPY_BIT_17 0
#define TYPE_COUNT_COPY_BIT_18 0
#define TYPE_COUNT_COPY_BIT_19 0
#define TYPE_INCRVAL (TYPE_COUNTER + 1)
// update new values for bits
#if TYPE_INCRVAL & (1ul << 0ul)
#undef TYPE_COUNT_COPY_BIT_0
#define TYPE_COUNT_COPY_BIT_0 1
#endif
#if TYPE_INCRVAL & (1ul << 1ul)
#undef TYPE_COUNT_COPY_BIT_1
#define TYPE_COUNT_COPY_BIT_1 1
#endif
#if TYPE_INCRVAL & (1ul << 2ul)
#undef TYPE_COUNT_COPY_BIT_2
#define TYPE_COUNT_COPY_BIT_2 1
#endif
#if TYPE_INCRVAL & (1ul << 3ul)
#undef TYPE_COUNT_COPY_BIT_3
#define TYPE_COUNT_COPY_BIT_3 1
#endif
#if TYPE_INCRVAL & (1ul << 4ul)
#undef TYPE_COUNT_COPY_BIT_4
#define TYPE_COUNT_COPY_BIT_4 1
#endif
#if TYPE_INCRVAL & (1ul << 5ul)
#undef TYPE_COUNT_COPY_BIT_5
#define TYPE_COUNT_COPY_BIT_5 1
#endif
#if TYPE_INCRVAL & (1ul << 6ul)
#undef TYPE_COUNT_COPY_BIT_6
#define TYPE_COUNT_COPY_BIT_6 1
#endif
#if TYPE_INCRVAL & (1ul << 7ul)
#undef TYPE_COUNT_COPY_BIT_7
#define TYPE_COUNT_COPY_BIT_7 1
#endif
#if TYPE_INCRVAL & (1ul << 8ul)
#undef TYPE_COUNT_COPY_BIT_8
#define TYPE_COUNT_COPY_BIT_8 1
#endif
#if TYPE_INCRVAL & (1ul << 9ul)
#undef TYPE_COUNT_COPY_BIT_9
#define TYPE_COUNT_COPY_BIT_9 1
#endif
#if TYPE_INCRVAL & (1ul << 10ul)
#undef TYPE_COUNT_COPY_BIT_10
#define TYPE_COUNT_COPY_BIT_10 1
#endif
#if TYPE_INCRVAL & (1ul << 11ul)
#undef TYPE_COUNT_COPY_BIT_11
#define TYPE_COUNT_COPY_BIT_11 1
#endif
#if TYPE_INCRVAL & (1ul << 12ul)
#undef TYPE_COUNT_COPY_BIT_12
#define TYPE_COUNT_COPY_BIT_12 1
#endif
#if TYPE_INCRVAL & (1ul << 13ul)
#undef TYPE_COUNT_COPY_BIT_13
#define TYPE_COUNT_COPY_BIT_13 1
#endif
#if TYPE_INCRVAL & (1ul << 14ul)
#undef TYPE_COUNT_COPY_BIT_14
#define TYPE_COUNT_COPY_BIT_14 1
#endif
#if TYPE_INCRVAL & (1ul << 15ul)
#undef TYPE_COUNT_COPY_BIT_15
#define TYPE_COUNT_COPY_BIT_15 1
#endif
#if TYPE_INCRVAL & (1ul << 16ul)
#undef TYPE_COUNT_COPY_BIT_16
#define TYPE_COUNT_COPY_BIT_16 1
#endif
#if TYPE_INCRVAL & (1ul << 17ul)
#undef TYPE_COUNT_COPY_BIT_17
#define TYPE_COUNT_COPY_BIT_17 1
#endif
#if TYPE_INCRVAL & (1ul << 18ul)
#undef TYPE_COUNT_COPY_BIT_18
#define TYPE_COUNT_COPY_BIT_18 1
#endif
#if TYPE_INCRVAL & (1ul << 19ul)
#undef TYPE_COUNT_COPY_BIT_19
#define TYPE_COUNT_COPY_BIT_19 1
#endif
// update actual bits
#undef TYPE_COUNT_BIT_0
#undef TYPE_COUNT_BIT_1
#undef TYPE_COUNT_BIT_2
#undef TYPE_COUNT_BIT_3
#undef TYPE_COUNT_BIT_4
#undef TYPE_COUNT_BIT_5
#undef TYPE_COUNT_BIT_6
#undef TYPE_COUNT_BIT_7
#undef TYPE_COUNT_BIT_8
#undef TYPE_COUNT_BIT_9
#undef TYPE_COUNT_BIT_10
#undef TYPE_COUNT_BIT_11
#undef TYPE_COUNT_BIT_12
#undef TYPE_COUNT_BIT_13
#undef TYPE_COUNT_BIT_14
#undef TYPE_COUNT_BIT_15
#undef TYPE_COUNT_BIT_16
#undef TYPE_COUNT_BIT_17
#undef TYPE_COUNT_BIT_18
#undef TYPE_COUNT_BIT_19
#define TYPE_COUNT_BIT_0 0
#define TYPE_COUNT_BIT_1 0
#define TYPE_COUNT_BIT_2 0
#define TYPE_COUNT_BIT_3 0
#define TYPE_COUNT_BIT_4 0
#define TYPE_COUNT_BIT_5 0
#define TYPE_COUNT_BIT_6 0
#define TYPE_COUNT_BIT_7 0
#define TYPE_COUNT_BIT_8 0
#define TYPE_COUNT_BIT_9 0
#define TYPE_COUNT_BIT_10 0
#define TYPE_COUNT_BIT_11 0
#define TYPE_COUNT_BIT_12 0
#define TYPE_COUNT_BIT_13 0
#define TYPE_COUNT_BIT_14 0
#define TYPE_COUNT_BIT_15 0
#define TYPE_COUNT_BIT_16 0
#define TYPE_COUNT_BIT_17 0
#define TYPE_COUNT_BIT_18 0
#define TYPE_COUNT_BIT_19 0
#if TYPE_COUNT_COPY_BIT_0
#undef TYPE_COUNT_BIT_0
#define TYPE_COUNT_BIT_0 1
#endif
#if TYPE_COUNT_COPY_BIT_1
#undef TYPE_COUNT_BIT_1
#define TYPE_COUNT_BIT_1 1
#endif
#if TYPE_COUNT_COPY_BIT_2
#undef TYPE_COUNT_BIT_2
#define TYPE_COUNT_BIT_2 1
#endif
#if TYPE_COUNT_COPY_BIT_3
#undef TYPE_COUNT_BIT_3
#define TYPE_COUNT_BIT_3 1
#endif
#if TYPE_COUNT_COPY_BIT_4
#undef TYPE_COUNT_BIT_4
#define TYPE_COUNT_BIT_4 1
#endif
#if TYPE_COUNT_COPY_BIT_5
#undef TYPE_COUNT_BIT_5
#define TYPE_COUNT_BIT_5 1
#endif
#if TYPE_COUNT_COPY_BIT_6
#undef TYPE_COUNT_BIT_6
#define TYPE_COUNT_BIT_6 1
#endif
#if TYPE_COUNT_COPY_BIT_7
#undef TYPE_COUNT_BIT_7
#define TYPE_COUNT_BIT_7 1
#endif
#if TYPE_COUNT_COPY_BIT_8
#undef TYPE_COUNT_BIT_8
#define TYPE_COUNT_BIT_8 1
#endif
#if TYPE_COUNT_COPY_BIT_9
#undef TYPE_COUNT_BIT_9
#define TYPE_COUNT_BIT_9 1
#endif
#if TYPE_COUNT_COPY_BIT_10
#undef TYPE_COUNT_BIT_10
#define TYPE_COUNT_BIT_10 1
#endif
#if TYPE_COUNT_COPY_BIT_11
#undef TYPE_COUNT_BIT_11
#define TYPE_COUNT_BIT_11 1
#endif
#if TYPE_COUNT_COPY_BIT_12
#undef TYPE_COUNT_BIT_12
#define TYPE_COUNT_BIT_12 1
#endif
#if TYPE_COUNT_COPY_BIT_13
#undef TYPE_COUNT_BIT_13
#define TYPE_COUNT_BIT_13 1
#endif
#if TYPE_COUNT_COPY_BIT_14
#undef TYPE_COUNT_BIT_14
#define TYPE_COUNT_BIT_14 1
#endif
#if TYPE_COUNT_COPY_BIT_15
#undef TYPE_COUNT_BIT_15
#define TYPE_COUNT_BIT_15 1
#endif
#if TYPE_COUNT_COPY_BIT_16
#undef TYPE_COUNT_BIT_16
#define TYPE_COUNT_BIT_16 1
#endif
#if TYPE_COUNT_COPY_BIT_17
#undef TYPE_COUNT_BIT_17
#define TYPE_COUNT_BIT_17 1
#endif
#if TYPE_COUNT_COPY_BIT_18
#undef TYPE_COUNT_BIT_18
#define TYPE_COUNT_BIT_18 1
#endif
#if TYPE_COUNT_COPY_BIT_19
#undef TYPE_COUNT_BIT_19
#define TYPE_COUNT_BIT_19 1
#endif
#undef TYPE_INCRVAL
#undef TYPE_COUNTER_RECORD
#define TYPE_COUNTER_RECORD \
(TYPE_COUNT_BIT_0 \
,TYPE_COUNT_BIT_1 \
,TYPE_COUNT_BIT_2 \
,TYPE_COUNT_BIT_3 \
,TYPE_COUNT_BIT_4 \
,TYPE_COUNT_BIT_5 \
,TYPE_COUNT_BIT_6 \
,TYPE_COUNT_BIT_7 \
,TYPE_COUNT_BIT_8 \
,TYPE_COUNT_BIT_9 \
,TYPE_COUNT_BIT_10 \
,TYPE_COUNT_BIT_11 \
,TYPE_COUNT_BIT_12 \
,TYPE_COUNT_BIT_13 \
,TYPE_COUNT_BIT_14 \
,TYPE_COUNT_BIT_15 \
,TYPE_COUNT_BIT_16 \
,TYPE_COUNT_BIT_17 \
,TYPE_COUNT_BIT_18 \
,TYPE_COUNT_BIT_19)
#endif
// convert record to either expression or single literal
#ifndef TYPE_COUNTER_EVAL
#define TYPE_COUNTER_EVAL( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
( (B0 << 0ul ) | \
(B1 << 1ul ) | \
(B2 << 2ul ) | \
(B3 << 3ul ) | \
(B4 << 4ul ) | \
(B5 << 5ul ) | \
(B6 << 6ul ) | \
(B7 << 7ul ) | \
(B8 << 8ul ) | \
(B9 << 9ul ) | \
(B10 << 10ul) | \
(B11 << 11ul) | \
(B12 << 12ul) | \
(B13 << 13ul) | \
(B14 << 14ul) | \
(B15 << 15ul) | \
(B16 << 16ul) | \
(B17 << 17ul) | \
(B18 << 18ul) | \
(B19 << 19ul) )
// (two level paster)
#define TYPE_COUNTER_DOPB( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
0b ## B19##B18##B17##B16##B15##B14##B13##B12##B11##B10##B9##B8##B7##B6##B5##B4##B3##B2##B1##B0 ## ul
#define TYPE_COUNTER_PBIN( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
TYPE_COUNTER_DOPB(B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19)
#define TYPE_COUNTER_DOH2(Pfx, H0, H1, H2, H3, H4, Sfx) \
Pfx ## H0##H1##H2##H3##H4 ## Sfx
#define TYPE_COUNTER_DOPH(Pfx, H0, H1, H2, H3, H4, Sfx) \
TYPE_COUNTER_DOH2(Pfx, H0, H1, H2, H3, H4, Sfx)
#define TYPE_COUNTER_GHEX(Pfx, Sfx \
, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
TYPE_COUNTER_DOPH (Pfx \
, TYPE_COUNTER_HEXC(B19, B18, B17, B16) \
, TYPE_COUNTER_HEXC(B15, B14, B13, B12) \
, TYPE_COUNTER_HEXC(B11, B10, B9, B8 ) \
, TYPE_COUNTER_HEXC(B7, B6, B5, B4 ) \
, TYPE_COUNTER_HEXC(B3, B2, B1, B0 ) \
, Sfx)
#define TYPE_COUNTER_PHEX( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
TYPE_COUNTER_GHEX (0x, ul \
, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19)
#define TYPE_COUNTER_DHEX( B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19) \
TYPE_COUNTER_GHEX (/* empty */, /* empty */ \
, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 \
, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19)
// generate hex digits from bits
#define TYPE_COUNTER_HEXC(B0, B1, B2, B3) TYPE_COUNTER_HEXC_ ##B0##B1##B2##B3
#define TYPE_COUNTER_HEXC_0000 0
#define TYPE_COUNTER_HEXC_0001 1
#define TYPE_COUNTER_HEXC_0010 2
#define TYPE_COUNTER_HEXC_0011 3
#define TYPE_COUNTER_HEXC_0100 4
#define TYPE_COUNTER_HEXC_0101 5
#define TYPE_COUNTER_HEXC_0110 6
#define TYPE_COUNTER_HEXC_0111 7
#define TYPE_COUNTER_HEXC_1000 8
#define TYPE_COUNTER_HEXC_1001 9
#define TYPE_COUNTER_HEXC_1010 a
#define TYPE_COUNTER_HEXC_1011 b
#define TYPE_COUNTER_HEXC_1100 c
#define TYPE_COUNTER_HEXC_1101 d
#define TYPE_COUNTER_HEXC_1110 e
#define TYPE_COUNTER_HEXC_1111 f
// force expand pass
#define TYPE_COUNTER_EXPAND(V) V
#ifndef TYPE_COUNTER_PRINT
// default to hex printer: 0x12345ul
#define TYPE_COUNTER_PRINT TYPE_COUNTER_PHEX
#endif
// alt formats also accessible, good for name gen
#define TYPE_COUNTER_BIN \
TYPE_COUNTER_EXPAND (TYPE_COUNTER_PBIN TYPE_COUNTER_RECORD)
#define TYPE_COUNTER_HEX \
TYPE_COUNTER_EXPAND (TYPE_COUNTER_PHEX TYPE_COUNTER_RECORD)
#define TYPE_COUNTER_EXPR \
TYPE_COUNTER_EXPAND (TYPE_COUNTER_EVAL TYPE_COUNTER_RECORD)
#define TYPE_COUNTER_HEXDIG \
TYPE_COUNTER_EXPAND (TYPE_COUNTER_DHEX TYPE_COUNTER_RECORD)
#endif
// unconditional, this forces update even after manual reset
#undef TYPE_COUNTER
#define TYPE_COUNTER \
TYPE_COUNTER_EXPAND (TYPE_COUNTER_PRINT TYPE_COUNTER_RECORD)
Raw
typeid.h
// typeid.h
//
// provide typeid bodies that hook in at current state of type counter
//
// NOTE this depends on external inclusion of TYPE_COUNTER
//
#ifndef INCLUDED_TYPEID_BASE_H
#define INCLUDED_TYPEID_BASE_H
#define TYPEID_GLUE(A, B) TYPEID_GLUE2(A, B)
#define TYPEID_GLUE2(A, B) A ## B
#ifdef TYPEID
#undef TYPEID
#endif
#ifdef TYPEID_HAS_TYPEOF
// this allows specifying nuisance syntax like function pointers
// without intermediate typedefs to avoid the spiraling syntax
#define ADD_TYPEID(T) typedef typeof(T) TYPEID_GLUE(TYPEID_DEF_, TYPE_COUNTER_HEXDIG);
#define TYPEID(T) TYPEID_GLUE(TYPEID_BODY_, TYPE_COUNTER_HEXDIG)((typeof (T) *)0)
#else
// typeof isn't essential but you won't be able to register
// function or array types with this syntax, need an
// intermediary helper typedef
#define ADD_TYPEID(T) typedef T TYPEID_GLUE(TYPEID_DEF_, TYPE_COUNTER_HEXDIG);
#define TYPEID(T) TYPEID_GLUE(TYPEID_BODY_, TYPE_COUNTER_HEXDIG)((T *)0)
#endif
// add typeids for builtin types
#define TYPEID_COUNTER "type_counter.h"
#include TYPEID_COUNTER
ADD_TYPEID (void)
#include TYPEID_COUNTER
ADD_TYPEID (char)
#include TYPEID_COUNTER
ADD_TYPEID (signed char)
#include TYPEID_COUNTER
ADD_TYPEID (unsigned char)
#include TYPEID_COUNTER
ADD_TYPEID (signed short)
#include TYPEID_COUNTER
ADD_TYPEID (unsigned short)
#include TYPEID_COUNTER
ADD_TYPEID (signed int)
#include TYPEID_COUNTER
ADD_TYPEID (unsigned int)
#include TYPEID_COUNTER
ADD_TYPEID (signed long)
#include TYPEID_COUNTER
ADD_TYPEID (unsigned long)
#include TYPEID_COUNTER
ADD_TYPEID (signed long long)
#include TYPEID_COUNTER
ADD_TYPEID (unsigned long long)
#include TYPEID_COUNTER
ADD_TYPEID (float)
#include TYPEID_COUNTER
ADD_TYPEID (double)
#include TYPEID_COUNTER
ADD_TYPEID (long double)
// auto-generate this part with a script, go up to some high value
// final branch needs a default (because even if this isn't selected,
// it still needs to type check), but the value should be unusable if reached
#define TYPEID_BODY_00000(T) _Generic(T, TYPEID_DEF_00000 * : 0, default: (void)0)
#define TYPEID_BODY_00001(T) _Generic(T, TYPEID_DEF_00001 * : 0x00001ul, default: TYPEID_BODY_00000 (T))
#define TYPEID_BODY_00002(T) _Generic(T, TYPEID_DEF_00002 * : 0x00002ul, default: TYPEID_BODY_00001 (T))
#define TYPEID_BODY_00003(T) _Generic(T, TYPEID_DEF_00003 * : 0x00003ul, default: TYPEID_BODY_00002 (T))
#define TYPEID_BODY_00004(T) _Generic(T, TYPEID_DEF_00004 * : 0x00004ul, default: TYPEID_BODY_00003 (T))
#define TYPEID_BODY_00005(T) _Generic(T, TYPEID_DEF_00005 * : 0x00005ul, default: TYPEID_BODY_00004 (T))
#define TYPEID_BODY_00006(T) _Generic(T, TYPEID_DEF_00006 * : 0x00006ul, default: TYPEID_BODY_00005 (T))
#define TYPEID_BODY_00007(T) _Generic(T, TYPEID_DEF_00007 * : 0x00007ul, default: TYPEID_BODY_00006 (T))
#define TYPEID_BODY_00008(T) _Generic(T, TYPEID_DEF_00008 * : 0x00008ul, default: TYPEID_BODY_00007 (T))
#define TYPEID_BODY_00009(T) _Generic(T, TYPEID_DEF_00009 * : 0x00009ul, default: TYPEID_BODY_00008 (T))
#define TYPEID_BODY_0000a(T) _Generic(T, TYPEID_DEF_0000a * : 0x0000aul, default: TYPEID_BODY_00009 (T))
#define TYPEID_BODY_0000b(T) _Generic(T, TYPEID_DEF_0000b * : 0x0000bul, default: TYPEID_BODY_0000a (T))
#define TYPEID_BODY_0000c(T) _Generic(T, TYPEID_DEF_0000c * : 0x0000cul, default: TYPEID_BODY_0000b (T))
#define TYPEID_BODY_0000d(T) _Generic(T, TYPEID_DEF_0000d * : 0x0000dul, default: TYPEID_BODY_0000c (T))
#define TYPEID_BODY_0000e(T) _Generic(T, TYPEID_DEF_0000e * : 0x0000eul, default: TYPEID_BODY_0000d (T))
#define TYPEID_BODY_0000f(T) _Generic(T, TYPEID_DEF_0000f * : 0x0000ful, default: TYPEID_BODY_0000e (T))
#define TYPEID_BODY_00010(T) _Generic(T, TYPEID_DEF_00010 * : 0x00010ul, default: TYPEID_BODY_0000f (T))
#define TYPEID_BODY_00011(T) _Generic(T, TYPEID_DEF_00011 * : 0x00011ul, default: TYPEID_BODY_00010 (T))
#define TYPEID_BODY_00012(T) _Generic(T, TYPEID_DEF_00012 * : 0x00012ul, default: TYPEID_BODY_00011 (T))
#define TYPEID_BODY_00013(T) _Generic(T, TYPEID_DEF_00013 * : 0x00013ul, default: TYPEID_BODY_00012 (T))
#define TYPEID_BODY_00014(T) _Generic(T, TYPEID_DEF_00014 * : 0x00014ul, default: TYPEID_BODY_00013 (T))
#define TYPEID_BODY_00015(T) _Generic(T, TYPEID_DEF_00015 * : 0x00015ul, default: TYPEID_BODY_00014 (T))
#define TYPEID_BODY_00016(T) _Generic(T, TYPEID_DEF_00016 * : 0x00016ul, default: TYPEID_BODY_00015 (T))
#define TYPEID_BODY_00017(T) _Generic(T, TYPEID_DEF_00017 * : 0x00017ul, default: TYPEID_BODY_00016 (T))
#define TYPEID_BODY_00018(T) _Generic(T, TYPEID_DEF_00018 * : 0x00018ul, default: TYPEID_BODY_00017 (T))
#define TYPEID_BODY_00019(T) _Generic(T, TYPEID_DEF_00019 * : 0x00019ul, default: TYPEID_BODY_00018 (T))
#define TYPEID_BODY_0001a(T) _Generic(T, TYPEID_DEF_0001a * : 0x0001aul, default: TYPEID_BODY_00019 (T))
#define TYPEID_BODY_0001b(T) _Generic(T, TYPEID_DEF_0001b * : 0x0001bul, default: TYPEID_BODY_0001a (T))
#define TYPEID_BODY_0001c(T) _Generic(T, TYPEID_DEF_0001c * : 0x0001cul, default: TYPEID_BODY_0001b (T))
#define TYPEID_BODY_0001d(T) _Generic(T, TYPEID_DEF_0001d * : 0x0001dul, default: TYPEID_BODY_0001c (T))
#define TYPEID_BODY_0001e(T) _Generic(T, TYPEID_DEF_0001e * : 0x0001eul, default: TYPEID_BODY_0001d (T))
#define TYPEID_BODY_0001f(T) _Generic(T, TYPEID_DEF_0001f * : 0x0001ful, default: TYPEID_BODY_0001e (T))
#define TYPEID_BODY_00020(T) _Generic(T, TYPEID_DEF_00020 * : 0x00020ul, default: TYPEID_BODY_0001f (T))
#define TYPEID_BODY_00021(T) _Generic(T, TYPEID_DEF_00021 * : 0x00021ul, default: TYPEID_BODY_00020 (T))
#define TYPEID_BODY_00022(T) _Generic(T, TYPEID_DEF_00022 * : 0x00022ul, default: TYPEID_BODY_00021 (T))
#define TYPEID_BODY_00023(T) _Generic(T, TYPEID_DEF_00023 * : 0x00023ul, default: TYPEID_BODY_00022 (T))
#define TYPEID_BODY_00024(T) _Generic(T, TYPEID_DEF_00024 * : 0x00024ul, default: TYPEID_BODY_00023 (T))
// etc
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment