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,
 
    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);
 
VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type);
 
int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
 
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type);
 
void *rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type);
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) = (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
 
#define TypedData_Get_Struct(obj,type,data_type,sval) \
    ((sval) = RBIMPL_CAST((type *)rb_check_typeddata((obj), (data_type))))
 
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(false);
    }
#endif
 
    /* We reuse the data pointer in embedded TypedData. We can't use offsetof
     * since RTypedData a non-POD type in C++. */
    const size_t embedded_typed_data_size = sizeof(struct RTypedData) - sizeof(void *);
 
    return RTYPEDDATA_EMBEDDED_P(obj) ? (char *)obj + embedded_typed_data_size : 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_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()
/* :TODO: can this function be __attribute__((returns_nonnull)) or not? */
static inline const struct rb_data_type_struct *
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
 
    return (const struct rb_data_type_struct *)(RTYPEDDATA(obj)->type & TYPED_DATA_PTR_MASK);
}
 
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;
}
 
RBIMPL_ATTR_DEPRECATED(("by: rb_data_typed_object_wrap"))
static inline VALUE
rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *type)
{
    return rb_data_typed_object_wrap(klass, datap, type);
}
 
#endif /* RBIMPL_RTYPEDDATA_H */