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);

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
 
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. */
    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_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);
}
 
RBIMPL_ATTR_ARTIFICIAL()
static inline void *
rbimpl_check_typeddata(VALUE obj, const rb_data_type_t *expected_type)
{
    if (RB_LIKELY(RB_TYPE_P(obj, T_DATA) && RTYPEDDATA_P(obj))) {
        const rb_data_type_t *actual_type = RTYPEDDATA_TYPE(obj);
        void *data = RTYPEDDATA_GET_DATA(obj);
        if (RB_LIKELY(actual_type == expected_type)) {
            return data;
        }
 
        while (actual_type) {
            actual_type = actual_type->parent;
            if (actual_type == expected_type) {
                return data;
            }
        }
    }
 
    return rb_check_typeddata(obj, expected_type);
}
 

#define TypedData_Get_Struct(obj,type,data_type,sval) \
    ((sval) = RBIMPL_CAST((type *)rbimpl_check_typeddata((obj), (data_type))))

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 */