~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

  $Author: nobu $

#if defined __GNUC__ && __GNUC__ >= 4

#pragma GCC visibility push(default)

#endif

 

# define PRI_VALUE_PREFIX PRI_LL_PREFIX

#ifndef PRI_INT_PREFIX

#define PRI_INT_PREFIX ""

#endif

#ifndef PRI_LONG_PREFIX

#define PRI_LONG_PREFIX "l"

#endif

 

#  define PRI_TIMET_PREFIX PRI_LL_PREFIX

#if defined PRI_PTRDIFF_PREFIX

# define PRI_PTRDIFF_PREFIX ""

# define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX

#if defined PRI_SIZE_PREFIX

# define PRI_SIZE_PREFIX ""

# define PRI_SIZE_PREFIX PRI_LL_PREFIX

    int (i) = (int)(n); \

    if ((long)(i) != (n)) rb_out_of_int(n)

#ifndef NUM2MODET

#define NUM2MODET(v) NUM2INT(v)

#endif

#ifndef MODET2NUM

#define MODET2NUM(v) INT2NUM(v)

#endif

#define FIX2LONG(x) (long)RSHIFT((SIGNED_VALUE)(x),1)

#define Check_Type(v,t) rb_check_type((VALUE)(v),(t))

#define NUM2LONG_internal(x) ((long)(FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)))

#define NUM2ULONG(x) rb_num2ulong((VALUE)(x))

#define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))

# define NUM2ULL(x) rb_num2ull((VALUE)(x))

#define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()

    if (rb_safe_level() >= 3) FL_SET((obj), FL_TAINT | FL_UNTRUSTED);\

    OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\

    rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\

    if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\

    OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \

    if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\

typedef struct rb_classext_struct rb_classext_t;

#define RCLASS_SUPER(c) rb_class_get_superclass(c)

#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)

#define RSTRING_EMBED_LEN(str) \

     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \

            (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))

     RSTRING_EMBED_LEN(str) : \

     (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \

#define RSTRING_GETMEM(str, ptrvar, lenvar) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \

     ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \

     ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))

typedef struct rb_data_type_struct rb_data_type_t;

 

struct rb_data_type_struct {

    struct {

        void (*dmark)(void*);

        void (*dfree)(void*);

        size_t (*dsize)(const void *);

        void *reserved[2]; /* For future extension.

                              This array *must* be filled with ZERO. */

    } function;

    const rb_data_type_t *parent;

};

 

#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_DATA_FUNC(func) ((void (*)(void*))(func))

int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);

#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))

    rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))

    (sval) = ALLOC(type),\

    memset((sval), 0, sizeof(type)),\

    Data_Wrap_Struct((klass),(mark),(free),(sval))\

  rb_data_typed_object_alloc((klass),(sval),(data_type))

    (sval) = ALLOC(type),\

    memset((sval), 0, sizeof(type)),\

    TypedData_Wrap_Struct((klass),(data_type),(sval))\

    Check_Type((obj), T_DATA); \

    (sval) = (type*)DATA_PTR(obj);\

    (sval) = (type*)rb_check_typeddata((obj), (data_type)); \

#define FL_ANY(x,f) FL_TEST((x),(f))

#define FL_ALL(x,f) (FL_TEST((x),(f)) == (f))

#define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))

#define ALLOC(type) ((type*)xmalloc(sizeof(type)))

#define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))

 

#define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))

 

void *rb_alloc_tmp_buffer(volatile VALUE *store, long len);

void rb_free_tmp_buffer(volatile VALUE *store);

/* allocates _n_ bytes temporary buffer and stores VALUE including it

 * in _v_.  _n_ may be evaluated twice. */

#ifdef C_ALLOCA

# define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))

#else

# define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))

#endif

#define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))

#define ALLOCV_END(v) rb_free_tmp_buffer(&(v))

#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))

            rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \

    do CONST_ID_CACHE((var) =, (str)) while (0)

        __extension__ (CONST_ID_CACHE((ID), (str))) : \

     __extension__ (rb_intern2((str), (long)strlen(str))) : \

#define rb_intern_const(str) rb_intern2((str), (long)strlen(str))

VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*);

VALUE rb_syserr_new(int, const char *);

NORETURN(void rb_syserr_fail(int, const char*));

NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));

#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())

int ruby_executable_node(void *n, int *status);