Compiler Explorer

Source code

#include <limits.h>
#include <stddef.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stdalign.h>

#if defined(__GNUC__) || defined(__llvm__)
#define dpa_u_unsequenced __attribute__((const))
#elif __STDC_VERSION__ >= 202311
#define dpa_u_unsequenced [[unsequenced, gnu::const]]
#else
#define dpa_u_unsequenced
#endif

#if !defined(DPA_U_DEBUG) && defined(__GNUC__)
#define dpa__u_really_inline __attribute__((always_inline))
#else
#define dpa__u_really_inline
#endif

#define DPA_U_EXPORT __attribute__((visibility("default")))
#define DPA_U_PACKED __attribute__((packed))

#define DPA_U_DECLARE_UNIQUE_CSTRING(name, ...) \
  dpa_u_unsequenced dpa__u_really_inline DPA_U_EXPORT inline dpa_u_bo_unique_t name (void){ \
    if((sizeof((const char[]){__VA_ARGS__})-1) <= DPA_U_BO_INLINE_MAX_SIZE){ \
      dpa_u_bo_unique_t ubo = { \
        .bo_inline = { \
          .type = DPA_U_BO_INLINE, \
          .size = (sizeof((const char[]){__VA_ARGS__})-1) & 0xF, \
        } \
      }; \
      memcpy(ubo.bo_inline.data, (const char[]){__VA_ARGS__}, sizeof((const char[]){__VA_ARGS__})-1); \
      return ubo; \
    }else{ \
      extern dpa_u_bo_unique_hashmap_t dpa__u_sucstrp__ ## name; \
      return (const dpa_u_bo_unique_t){ \
        .bo_unique_hashmap_meta.type = DPA_U_BO_UNIQUE_HASHMAP, \
        .bo_unique_hashmap = dpa__u_sucstrp__ ## name, \
      }; \
    } \
  }

#define DPA_U_DEFINE_UNIQUE_CSTRING(name, ...) \
  extern dpa_u_bo_unique_t name (void); \
  dpa_u_bo_unique_hashmap_t dpa__u_sucstrp__ ## name; \
  __attribute__((constructor,used)) \
  static void dpa__u_sucstri__ ## name(void){ \
    if((sizeof((const char[]){__VA_ARGS__})-1) > DPA_U_BO_INLINE_MAX_SIZE){ \
      static const char cstr[] = {__VA_ARGS__}; \
      static dpa__u_bo_unique_hashmap_entry_t uhe = { \
        .base.bo_simple = { \
          .type = DPA_U_BO_UNIQUE_HASHMAP, \
          .size = sizeof(cstr)-1, \
          .data = cstr, \
        }, \
        .refcount = 1234, \
      }; \
      extern dpa_u_bo_unique_hashmap_t dpa__u_bo_do_intern(dpa_u_any_bo_ro_t* bo); \
      dpa__u_sucstrp__ ## name = dpa__u_bo_do_intern((dpa_u_any_bo_ro_t*)&uhe); \
    } \
  }

typedef size_t dpa_u_hash_t;
typedef struct dpa_u_bo_inline dpa_u_bo_inline_t;
typedef struct dpa_u_bo_simple_ro dpa_u_bo_simple_ro_t;
typedef struct dpa_u_bo_simple dpa_u_bo_simple_t;
typedef struct dpa__u_bo_unique_hashmap_entry dpa__u_bo_unique_hashmap_entry_t;
typedef const struct dpa__u_bo_unique_hashmap_entry* dpa_u_bo_unique_hashmap_t;
typedef struct dpa_u_bo_unique dpa_u_bo_unique_t;
typedef struct dpa_u_bo_hashed_ro dpa_u_bo_hashed_ro_t;
typedef const struct dpa_u_any_bo_unique dpa_u_any_bo_unique_t;
typedef const struct dpa_u_any_bo_ro dpa_u_any_bo_ro_t;
typedef struct dpa__u_bo_a dpa__u_bo_a_t;

enum {
  DPA_U_BO_INLINE,
  DPA_U_BO_UNIQUE_HASHMAP,
  DPA_U_BO_SIMPLE,
  DPA_U_BO_HASHED,
  DPA_U_BO_REFCOUNTED,
  DPA_U_BO_REFCOUNTED_HASHED,
};

enum { DPA__U_BO_COMMON_SIZE = sizeof(size_t) + sizeof(void*) };
enum { DPA_U_BO_INLINE_MAX_SIZE = DPA__U_BO_COMMON_SIZE-1 };
#define DPA_U_BO_MAX_SIZE (((size_t)1)<<((sizeof(size_t)-1)*CHAR_BIT))
#define DPA__U_BO_ALIGN alignas(struct{size_t a; void* b;})

#define DPA__U_BO_META(X) \
  struct DPA_U_PACKED { \
    unsigned type : CHAR_BIT - 4; \
    unsigned X : 4; \
  }

struct dpa__u_bo_a { char all[DPA__U_BO_COMMON_SIZE]; };
typedef DPA__U_BO_META(extra) dpa__u_bo_meta_t;

struct dpa_u_bo_inline {
  union {
    struct {
      DPA__U_BO_META(size);
      char data[DPA__U_BO_COMMON_SIZE-1];
    };
    DPA__U_BO_ALIGN dpa__u_bo_a_t all;
  };
};
static_assert(sizeof(dpa_u_bo_inline_t) == DPA__U_BO_COMMON_SIZE, "dpa_u_bo_inline_t has an unexpected size");
static_assert(offsetof(dpa_u_bo_inline_t,data) == 1, "Expected data to be at byte 1");

struct dpa_u_bo_unique {
  union {
    struct { DPA__U_BO_META(extra); char _[DPA__U_BO_COMMON_SIZE-1]; };
    dpa_u_bo_inline_t bo_inline;
    struct { DPA__U_BO_META(extra) bo_unique_hashmap_meta; dpa_u_bo_unique_hashmap_t bo_unique_hashmap; };
    DPA__U_BO_ALIGN dpa__u_bo_a_t all;
  };
};
static_assert(sizeof(dpa_u_bo_unique_t) == DPA__U_BO_COMMON_SIZE, "dpa_u_bo_unique_t has an unexpected size");

#define DPA__U_BO_SIMPLE_MEMBERS(...) \
  union { \
    struct { \
      DPA__U_BO_META(extra); \
      struct DPA_U_PACKED { \
        size_t size : (sizeof(size_t)-1) * CHAR_BIT; \
      }; \
      __VA_ARGS__ void* data; \
    }; \
    DPA__U_BO_ALIGN dpa__u_bo_a_t all; \
  }

struct dpa_u_bo_simple_ro {
  DPA__U_BO_SIMPLE_MEMBERS(const);
};
static_assert(sizeof(dpa_u_bo_simple_ro_t) == DPA__U_BO_COMMON_SIZE, "dpa_u_bo_simple_ro_t has an unexpected size");
static_assert(offsetof(dpa_u_bo_simple_ro_t,data) == sizeof(size_t), "Expected data to be at a different offset");

struct dpa_u_bo_simple {
  union {
    dpa_u_bo_simple_ro_t ro;
    DPA__U_BO_SIMPLE_MEMBERS();
  };
};
static_assert(sizeof(dpa_u_bo_simple_t) == DPA__U_BO_COMMON_SIZE, "dpa_u_bo_simple_t has an unexpected size");
static_assert(offsetof(dpa_u_bo_simple_t,data) == sizeof(size_t), "Expected data to be at a different offset");

struct dpa_u_bo_hashed_ro {
  union {
    DPA__U_BO_META(extra);
    dpa_u_bo_simple_ro_t bo_simple;
  };
  dpa_u_hash_t hash;
};

struct dpa__u_bo_unique_hashmap_entry {
  dpa_u_bo_hashed_ro_t base;
  size_t refcount;
  struct dpa__u_bo_unique_hashmap_entry* next;
};

#define dpa__u_v_bo_unique__data(X)   dpa__u_cp_bo_unique__data(&(X))
#define dpa__u_p_bo_unique__data(X)   dpa__u_cp_bo_unique__data((X))
DPA_U_EXPORT inline dpa__u_really_inline const void* dpa__u_cp_bo_unique__data(const dpa_u_bo_unique_t*restrict const bo){
  switch(bo->type){
    case DPA_U_BO_INLINE: return bo->bo_inline.data;
    case DPA_U_BO_UNIQUE_HASHMAP: return bo->bo_unique_hashmap->base.bo_simple.data;
  }
  __builtin_unreachable();
}

DPA_U_EXPORT inline dpa__u_really_inline size_t dpa__u_v_bo_unique__get_size(const dpa_u_bo_unique_t bo){
  switch(bo.type){
    case DPA_U_BO_INLINE: return bo.bo_inline.size;
    case DPA_U_BO_UNIQUE_HASHMAP: return bo.bo_unique_hashmap->base.bo_simple.size;
  }
  __builtin_unreachable();
}
#define dpa__u_p_bo_unique__get_size(X) dpa__u_v_bo_unique__get_size(*(X))
#define dpa__u_cp_bo_unique__get_size(X) dpa__u_v_bo_unique__get_size(*(X))

////

DPA_U_DECLARE_UNIQUE_CSTRING(get_hello, "Hello World!")
DPA_U_DEFINE_UNIQUE_CSTRING(get_hello, "Hello World!")

DPA_U_DECLARE_UNIQUE_CSTRING(get_fox, "The quick brown fox jumps over the lazy dog")
DPA_U_DEFINE_UNIQUE_CSTRING(get_fox, "The quick brown fox jumps over the lazy dog")

DPA_U_EXPORT dpa_u_bo_unique_hashmap_t dpa__u_bo_do_intern(dpa_u_any_bo_ro_t* bo){
  return (dpa_u_bo_unique_hashmap_t)bo;
}

#define dpa_u_fwrite(bo, io) fwrite(dpa__u_v_bo_unique__data((bo)), dpa__u_v_bo_unique__get_size((bo)), 1, (io))
#define dpa_u_fputs(bo, io) dpa_u_fwrite((bo),(io))
#define dpa_u_puts(bo) (dpa_u_fputs((bo),stdout),puts(""))

int main(void){
  const dpa_u_bo_unique_t hello = get_hello();
  dpa_u_puts(hello);
  const dpa_u_bo_unique_t fox = get_fox();
  dpa_u_puts(fox);
}