rtypeddata.h

Go to the documentation of this file.

#ifndef RBIMPL_RTYPEDDATA_H                          /*-*-C++-*-vi:se ft=cpp:*/
#define RBIMPL_RTYPEDDATA_H
#include "ruby/internal/config.h"
 
#ifdef STDC_HEADERS
# include <stddef.h>
#endif
 
#include "ruby/internal/assume.h"
#include "ruby/internal/attr/artificial.h"
#include "ruby/internal/attr/flag_enum.h"
#include "ruby/internal/attr/nonnull.h"
#include "ruby/internal/attr/pure.h"
#include "ruby/internal/cast.h"
#include "ruby/internal/core/rbasic.h"
#include "ruby/internal/core/rdata.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/error.h"
#include "ruby/internal/fl_type.h"
#include "ruby/internal/static_assert.h"
#include "ruby/internal/stdbool.h"
#include "ruby/internal/value_type.h"
 
#define HAVE_TYPE_RB_DATA_TYPE_T     1
 
#define HAVE_RB_DATA_TYPE_T_FUNCTION 1
 
#define HAVE_RB_DATA_TYPE_T_PARENT   1
 
#define RUBY_TYPED_DEFAULT_FREE      RUBY_DEFAULT_FREE
 
#define RUBY_TYPED_NEVER_FREE        RUBY_NEVER_FREE
 
#define RTYPEDDATA(obj)              RBIMPL_CAST((struct RTypedData *)(obj))
 
#define RTYPEDDATA_DATA(v)           (RTYPEDDATA(v)->data)
 
#define Check_TypedStruct(v, t)      \
    rb_check_typeddata(RBIMPL_CAST((VALUE)(v)), (t))
 
#define RTYPEDDATA_P                 RTYPEDDATA_P
#define RTYPEDDATA_TYPE              RTYPEDDATA_TYPE
#define RUBY_TYPED_FREE_IMMEDIATELY  RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FROZEN_SHAREABLE  RUBY_TYPED_FROZEN_SHAREABLE
#define RUBY_TYPED_WB_PROTECTED      RUBY_TYPED_WB_PROTECTED
#define RUBY_TYPED_PROMOTED1         RUBY_TYPED_PROMOTED1
#define TYPED_DATA_EMBEDDED ((VALUE)1)
#define TYPED_DATA_PTR_MASK (~(TYPED_DATA_EMBEDDED))
 
enum
RBIMPL_ATTR_FLAG_ENUM()
rbimpl_typeddata_flags {
    RUBY_TYPED_FREE_IMMEDIATELY = 1,
 
    RUBY_TYPED_EMBEDDABLE = 2,
 
    RUBY_TYPED_FROZEN_SHAREABLE = RUBY_FL_SHAREABLE,
 
    // experimental flag
    // Similar to RUBY_TYPED_FROZEN_SHAREABLE, but doesn't make shareable
    // reachable objects from this T_DATA object on the Ractor.make_shareable.
    // If it refers to unshareable objects, simply raise an error.
    // RUBY_TYPED_FROZEN_SHAREABLE_NO_REC = RUBY_FL_FINALIZE,
 
    RUBY_TYPED_WB_PROTECTED     = RUBY_FL_WB_PROTECTED, /* THIS FLAG DEPENDS ON Ruby version */
 
    RUBY_TYPED_FL_IS_TYPED_DATA = RUBY_FL_USERPRIV0,
 
    RUBY_TYPED_DECL_MARKING     = RUBY_FL_USER2
};
 
typedef struct rb_data_type_struct rb_data_type_t;
 
struct rb_data_type_struct {
 
    const char *wrap_struct_name;
 
    struct {
 
        RUBY_DATA_FUNC dmark;
 
        RUBY_DATA_FUNC dfree;
 
        size_t (*dsize)(const void *);
 
        RUBY_DATA_FUNC dcompact;
 
        void *reserved[1]; /* For future extension.
                              This array *must* be filled with ZERO. */
    } function;
 
    const rb_data_type_t *parent;
 
    void *data;        /* This area can be used for any purpose
                          by a programmer who define the type. */
 
    VALUE flags;       /* RUBY_FL_WB_PROTECTED */
};
 
struct RTypedData {
 
    struct RBasic basic;
 
    VALUE fields_obj;
 
    const VALUE type;
 
    void *data;
};
 
#if !defined(__cplusplus) || __cplusplus >= 201103L
RBIMPL_STATIC_ASSERT(data_in_rtypeddata, offsetof(struct RData, data) == offsetof(struct RTypedData, data));
#endif
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
RBIMPL_ATTR_NONNULL((3))
VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type);
 
RBIMPL_ATTR_NONNULL((3))
VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type);
 
RBIMPL_ATTR_NONNULL(())
int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
 
RBIMPL_ATTR_NONNULL((2))
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type);
 
RBIMPL_ATTR_NONNULL((2))
void *rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type);
 
RBIMPL_ATTR_NORETURN()
RBIMPL_ATTR_NONNULL((2))
void rb_unexpected_object_type(VALUE obj, const char *expected);
 
RBIMPL_ATTR_NORETURN()
RBIMPL_ATTR_NONNULL(())
void rb_unexpected_typeddata(const rb_data_type_t *actual, const rb_data_type_t *expected);
RBIMPL_SYMBOL_EXPORT_END()
 
#define TypedData_Wrap_Struct(klass,data_type,sval)\
  rb_data_typed_object_wrap((klass),(sval),(data_type))
 
#define TypedData_Make_Struct0(result, klass, type, size, data_type, sval) \
    VALUE result = rb_data_typed_object_zalloc(klass, size, data_type);    \
    (sval) = RBIMPL_CAST((type *)RTYPEDDATA_GET_DATA(result)); \
    RBIMPL_CAST(/*suppress unused variable warnings*/(void)(sval))
 
#ifdef HAVE_STMT_AND_DECL_IN_EXPR
#define TypedData_Make_Struct(klass, type, data_type, sval) \
    RB_GNUC_EXTENSION({         \
        TypedData_Make_Struct0( \
            data_struct_obj,    \
            klass,              \
            type,               \
            sizeof(type),       \
            data_type,          \
            sval);              \
        data_struct_obj;        \
    })
#else
#define TypedData_Make_Struct(klass, type, data_type, sval) \
    rb_data_typed_object_make(        \
        (klass),                      \
        (data_type),                  \
        RBIMPL_CAST((void **)&(sval)), \
        sizeof(type))
#endif
 
static inline bool
RTYPEDDATA_EMBEDDED_P(VALUE obj)
{
#if RUBY_DEBUG
    if (RB_UNLIKELY(!RB_TYPE_P(obj, RUBY_T_DATA))) {
        Check_Type(obj, RUBY_T_DATA);
        RBIMPL_UNREACHABLE_RETURN(false);
    }
#endif
 
    return (RTYPEDDATA(obj)->type) & TYPED_DATA_EMBEDDED;
}
 
static inline void *
RTYPEDDATA_GET_DATA(VALUE obj)
{
#if RUBY_DEBUG
    if (RB_UNLIKELY(!RB_TYPE_P(obj, RUBY_T_DATA))) {
        Check_Type(obj, RUBY_T_DATA);
        RBIMPL_UNREACHABLE_RETURN(NULL);
    }
#endif
 
    /* We reuse the data pointer in embedded TypedData. */
    return RTYPEDDATA_EMBEDDED_P(obj) ?
        RBIMPL_CAST((void *)&(RTYPEDDATA(obj)->data)) :
        RTYPEDDATA(obj)->data;
}
 
RBIMPL_ATTR_PURE()
RBIMPL_ATTR_ARTIFICIAL()
static inline bool
rbimpl_rtypeddata_p(VALUE obj)
{
    return FL_TEST_RAW(obj, RUBY_TYPED_FL_IS_TYPED_DATA);
}
 
RBIMPL_ATTR_PURE()
RBIMPL_ATTR_ARTIFICIAL()
static inline bool
rbimpl_obj_typeddata_p(VALUE obj)
{
    return RB_TYPE_P(obj, RUBY_T_DATA) && rbimpl_rtypeddata_p(obj);
}
 
RBIMPL_ATTR_PURE_UNLESS_DEBUG()
RBIMPL_ATTR_ARTIFICIAL()
static inline bool
RTYPEDDATA_P(VALUE obj)
{
#if RUBY_DEBUG
    if (RB_UNLIKELY(! RB_TYPE_P(obj, RUBY_T_DATA))) {
        Check_Type(obj, RUBY_T_DATA);
        RBIMPL_UNREACHABLE_RETURN(false);
    }
#endif
 
    return rbimpl_rtypeddata_p(obj);
}
 
RBIMPL_ATTR_PURE_UNLESS_DEBUG()
RBIMPL_ATTR_ARTIFICIAL()
RBIMPL_ATTR_RETURNS_NONNULL()
static inline const rb_data_type_t *
RTYPEDDATA_TYPE(VALUE obj)
{
#if RUBY_DEBUG
    if (RB_UNLIKELY(! RTYPEDDATA_P(obj))) {
        rb_unexpected_type(obj, RUBY_T_DATA);
        RBIMPL_UNREACHABLE_RETURN(NULL);
    }
#endif
 
    VALUE type = RTYPEDDATA(obj)->type & TYPED_DATA_PTR_MASK;
    const rb_data_type_t *ptr = RBIMPL_CAST((const rb_data_type_t *)type);
    RBIMPL_ASSERT_OR_ASSUME(ptr);
    return ptr;
}
 
RBIMPL_ATTR_ARTIFICIAL()
RBIMPL_ATTR_NONNULL(())
static inline bool
rb_typeddata_inherited_p_inline(const rb_data_type_t *child, const rb_data_type_t *parent)
{
    do {
        if (RB_LIKELY(child == parent)) return true;
    } while ((child = child->parent) != NULL);
    return false;
}
#define rb_typeddata_inherited_p rb_typeddata_inherited_p_inline
 
RBIMPL_ATTR_ARTIFICIAL()
RBIMPL_ATTR_NONNULL((2))
static inline bool
rb_typeddata_is_kind_of_inline(VALUE obj, const rb_data_type_t *data_type)
{
    if (RB_UNLIKELY(!rbimpl_obj_typeddata_p(obj))) return false;
    return rb_typeddata_inherited_p(RTYPEDDATA_TYPE(obj), data_type);
}
#define rb_typeddata_is_kind_of rb_typeddata_is_kind_of_inline
 
RBIMPL_ATTR_ARTIFICIAL()
RBIMPL_ATTR_NONNULL((2))
static inline void *
rbimpl_check_typeddata(VALUE obj, const rb_data_type_t *expected_type)
{
    if (RB_UNLIKELY(!rbimpl_obj_typeddata_p(obj))) {
        rb_unexpected_object_type(obj, expected_type->wrap_struct_name);
    }
 
    const rb_data_type_t *actual_type = RTYPEDDATA_TYPE(obj);
    if (RB_UNLIKELY(!rb_typeddata_inherited_p(actual_type, expected_type))){
        rb_unexpected_typeddata(actual_type, expected_type);
    }
 
    return RTYPEDDATA_GET_DATA(obj);
}
 
 
#define TypedData_Get_Struct(obj,type,data_type,sval) \
    ((sval) = RBIMPL_CAST((type *)rbimpl_check_typeddata((obj), (data_type))))
 
RBIMPL_ATTR_NONNULL((2))
static inline VALUE
rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size)
{
    TypedData_Make_Struct0(result, klass, void, size, type, *datap);
    return result;
}
 
#endif /* RBIMPL_RTYPEDDATA_H */