[svn.haxx.se] · SVN Dev · SVN Users · SVN Org · TSVN Dev · TSVN Users · Subclipse Dev · Subclipse Users · this month's index

annoying: message bodies turned into attachments (was: Re: What's left TODO for 1.6.x?)

From: Stefan Sperling <stsp_at_elego.de>
Date: Tue, 9 Dec 2008 10:45:30 -0800 (PST)

For efficiency reasons, the system has converted the large body of this message into an attachment.

------------------------------------------------------
http://subversion.tigris.org/ds/viewMessage.do?dsForumId=462&dsMessageId=981810

attached mail follows:


On Tue, Dec 09, 2008 at 10:24:06AM -0800, Stefan Sperling wrote:
> For efficiency reasons, the system has converted the large body of this message into an attachment.

Hello,

can someone please reconfigure the dev_at_subversion.tigris.org
list so that it doesn't turn message bodies into attachments?
It is very inconvenient to read these messages in the archives.

Thanks,
Stefan

>
> ------------------------------------------------------
> http://subversion.tigris.org/ds/viewMessage.do?dsForumId=462&dsMessageId=981795
> Message-ID: <20081209182357.GB10642_at_jack.stsp.name>
> Date: Tue, 9 Dec 2008 18:23:57 +0000
> From: Stefan Sperling <stsp_at_elego.de>
> To: Joe Swatosh <joe.swatosh_at_gmail.com>
> Cc: dev_at_subversion.tigris.org
> Subject: Re: What's left TODO for 1.6.x?
> Content-Type: text/plain; charset=us-ascii
> User-Agent: Mutt/1.5.18 (2008-05-17)
>
> On Mon, Dec 08, 2008 at 10:36:35PM -0800, Joe Swatosh wrote:
> > Hi
> >
> > On Mon, Dec 8, 2008 at 11:10 AM, Mark Phippard <markphip_at_gmail.com> wrote:
> > > On Sun, Dec 7, 2008 at 6:43 PM, Neels J Hofmeyr <neels_at_elego.de> wrote:
> > >
> > >> We have removed our TODO items for 1.6 because we resolved them. So, yes,
> > >> we're ready.
> > >
> > > That is good to hear!
> > >
> > > So if we can get these Serf tests fixed as well as any lingering
> > > issues in the bindings are we ready to proceed to RC? Perhaps we can
> > > branch when all the tests, including bindings, are passing and then
> > > issue the RC when things like CHANGES are ready?
> > >
> >
> > The Ruby bindings may be okay, but I can't run the tests at all on trunk.
>
> They don't build for me:
> http://subversion.tigris.org/ds/viewMessage.do?dsMessageId=979063&dsForumId=462
>
> You have to click on the attachment to see the message body, so I've
> quoted it again below for convenience.
>
> Oh, and I forgot to mention the swig version I'm using in that message.
> It's 1.3.16
>
> Stefan
>
>
> Message-ID: <20081203194535.GE14562_at_jack.stsp.name>
> Date: Wed, 3 Dec 2008 19:45:35 +0000
> From: Stefan Sperling <stsp_at_elego.de>
> To: dev_at_subversion.tigris.org
> Subject: cannot build ruby bindings in trunk
>
> Hi,
>
> the ruby bindings fail to build for in trunk (1.5.4 works fine).
>
> See below.
>
> Thanks,
> Stefan
>
>
> $ uname -a
> OpenBSD jack.stsp.name 4.4 GENERIC.MP#14 i386
> $ pkg_info | grep ruby
> ruby-1.8.6.287 object oriented script language with threads
>
> Build failure:
>
> In file included from /home/stsp/svn/svn-trunk/subversion/bindings/swig/proxy/swig_ruby_external_runtime.swg:720,
> from /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:5:
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:506: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:506: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:507: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:507: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:515: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:516: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:517: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:572: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:573: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:573: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:574: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:574: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:575: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:575: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:576: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:672: error: syntax error before "VALUE"
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:679: warning: no previous prototype for `rb_class_of'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:689: error: syntax error before "int"
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:696: warning: no previous prototype for `rb_type'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:706: error: syntax error before "int"
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:713: warning: no previous prototype for `rb_special_const_p'
> In file included from /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:719,
> from /home/stsp/svn/svn-trunk/subversion/bindings/swig/proxy/swig_ruby_external_runtime.swg:720,
> from /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:5:
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:56: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:66: warning: redundant redeclaration of `rb_uint2inum' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:146: warning: previous declaration of `rb_uint2inum'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:67: warning: redundant redeclaration of `rb_int2inum' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:142: warning: previous declaration of `rb_int2inum'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:79: warning: redundant redeclaration of `rb_ll2inum' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:152: warning: previous declaration of `rb_ll2inum'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:80: warning: redundant redeclaration of `rb_ull2inum' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:154: warning: previous declaration of `rb_ull2inum'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:120: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:123: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:124: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:125: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:188: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:214: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:258: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:259: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:480: warning: redundant redeclaration of `rb_iv_set' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:548: warning: previous declaration of `rb_iv_set'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:481: warning: redundant redeclaration of `rb_iv_get' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:547: warning: previous declaration of `rb_iv_get'
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:497: warning: redundant redeclaration of `rb_mod_constants' in same scope
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:488: warning: previous declaration of `rb_mod_constants'
> In file included from /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:7:
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/st.h:22: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/st.h:23: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/st.h:58: warning: function declaration isn't a prototype
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/st.h:70: warning: function declaration isn't a prototype
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c: In function `svn_swig_rb_initialize':
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:462: warning: unused variable `pool'
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c: In function `c2r_client_proplist_item_dup':
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:1152: warning: `svn_client_proplist_item_dup' is deprecated (declared at /home/stsp/svn/svn-trunk/subversion/include/svn_client.h:371)
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c: At top level:
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:1278: warning: no previous prototype for `c2r_merge_range_array'
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:1407: warning: no previous prototype for `c2r_hash'
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:1457: warning: no previous prototype for `c2r_revnum'
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:2045: warning: no previous prototype for `svn_swig_rb_from_baton'
> /home/stsp/svn/svn-trunk/subversion/bindings/swig/ruby/libsvn_swig_ruby/swigutil_rb.c:310: warning: `resolve_constant' defined but not used
> *** Error code 1
>
> Stop in /home/stsp/svn/svn-trunk (line 1751 of ./build-outputs.mk).
>
>
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/ruby.h:
>
> /**********************************************************************
>
> ruby.h -
>
> $Author: shyouhei $
> created at: Thu Jun 10 14:26:32 JST 1993
>
> Copyright (C) 1993-2003 Yukihiro Matsumoto
> Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
> Copyright (C) 2000 Information-technology Promotion Agency, Japan
>
> **********************************************************************/
>
> #ifndef RUBY_H
> #define RUBY_H
>
> #if defined(__cplusplus)
> extern "C" {
> #if 0
> } /* satisfy cc-mode */
> #endif
> #endif
>
> #include "config.h"
> #ifdef RUBY_EXTCONF_H
> #include RUBY_EXTCONF_H
> #endif
>
> #define NORETURN_STYLE_NEW 1
> #ifndef NORETURN
> # define NORETURN(x) x
> #endif
> #ifndef NOINLINE
> # define NOINLINE(x) x
> #endif
>
> #include "defines.h"
>
> #ifdef HAVE_STDLIB_H
> # include <stdlib.h>
> #endif
>
> #ifdef HAVE_STRING_H
> # include <string.h>
> #else
> # include <strings.h>
> #endif
>
> #ifdef HAVE_INTRINSICS_H
> # include <intrinsics.h>
> #endif
>
> #include <stddef.h>
> #include <stdio.h>
>
> /* need to include <ctype.h> to use these macros */
> #ifndef ISPRINT
> #define ISASCII(c) isascii((int)(unsigned char)(c))
> #undef ISPRINT
> #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c)))
> #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c)))
> #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c)))
> #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c)))
> #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c)))
> #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c)))
> #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c)))
> #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
> #endif
>
> #if defined(HAVE_ALLOCA_H)
> #include <alloca.h>
> #else
> # ifdef _AIX
> #pragma alloca
> # endif
> #endif
>
> #if defined(__VMS)
> # pragma builtins
> # define alloca __alloca
> #endif
>
> #if SIZEOF_LONG != SIZEOF_VOIDP
> # error ---->> ruby requires sizeof(void*) == sizeof(long) to be compiled. <<----
> #else
> typedef unsigned long VALUE;
> typedef unsigned long ID;
> #endif
>
> #ifdef __STDC__
> # include <limits.h>
> #else
> # ifndef LONG_MAX
> # ifdef HAVE_LIMITS_H
> # include <limits.h>
> # else
> /* assuming 32bit(2's compliment) long */
> # define LONG_MAX 2147483647
> # endif
> # endif
> # ifndef LONG_MIN
> # define LONG_MIN (-LONG_MAX-1)
> # endif
> # ifndef CHAR_BIT
> # define CHAR_BIT 8
> # endif
> #endif
>
> #ifdef HAVE_LONG_LONG
> # ifndef LLONG_MAX
> # ifdef LONG_LONG_MAX
> # define LLONG_MAX LONG_LONG_MAX
> # else
> # ifdef _I64_MAX
> # define LLONG_MAX _I64_MAX
> # else
> /* assuming 64bit(2's complement) long long */
> # define LLONG_MAX 9223372036854775807LL
> # endif
> # endif
> # endif
> # ifndef LLONG_MIN
> # ifdef LONG_LONG_MIN
> # define LLONG_MIN LONG_LONG_MIN
> # else
> # ifdef _I64_MIN
> # define LLONG_MIN _I64_MIN
> # else
> # define LLONG_MIN (-LLONG_MAX-1)
> # endif
> # endif
> # endif
> #endif
>
> #define FIXNUM_MAX (LONG_MAX>>1)
> #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
>
> #define FIXNUM_FLAG 0x01
> #define INT2FIX(i) ((VALUE)(((long)(i))<<1 | FIXNUM_FLAG))
> #define LONG2FIX(i) INT2FIX(i)
> #define rb_fix_new(v) INT2FIX(v)
> VALUE rb_int2inum _((long));
> #define INT2NUM(v) rb_int2inum(v)
> #define LONG2NUM(v) INT2NUM(v)
> #define rb_int_new(v) rb_int2inum(v)
> VALUE rb_uint2inum _((unsigned long));
> #define UINT2NUM(v) rb_uint2inum(v)
> #define ULONG2NUM(v) UINT2NUM(v)
> #define rb_uint_new(v) rb_uint2inum(v)
>
> #ifdef HAVE_LONG_LONG
> VALUE rb_ll2inum _((LONG_LONG));
> #define LL2NUM(v) rb_ll2inum(v)
> VALUE rb_ull2inum _((unsigned LONG_LONG));
> #define ULL2NUM(v) rb_ull2inum(v)
> #endif
>
> #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
> # define OFFT2NUM(v) LL2NUM(v)
> #elif SIZEOF_OFF_T == SIZEOF_LONG
> # define OFFT2NUM(v) LONG2NUM(v)
> #else
> # define OFFT2NUM(v) INT2NUM(v)
> #endif
>
> #define FIX2LONG(x) RSHIFT((long)x,1)
> #define FIX2ULONG(x) (((unsigned long)(x))>>1)
> #define FIXNUM_P(f) (((long)(f))&FIXNUM_FLAG)
> #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
> #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
> #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
>
> #define IMMEDIATE_MASK 0x03
> #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
>
> #define SYMBOL_FLAG 0x0e
> #define SYMBOL_P(x) (((VALUE)(x)&0xff)==SYMBOL_FLAG)
> #define ID2SYM(x) ((VALUE)(((long)(x))<<8|SYMBOL_FLAG))
> #define SYM2ID(x) RSHIFT((unsigned long)x,8)
>
> /* special contants - i.e. non-zero and non-fixnum constants */
> #define Qfalse ((VALUE)0)
> #define Qtrue ((VALUE)2)
> #define Qnil ((VALUE)4)
> #define Qundef ((VALUE)6) /* undefined value for placeholder */
>
> #define RTEST(v) (((VALUE)(v) & ~Qnil) != 0)
> #define NIL_P(v) ((VALUE)(v) == Qnil)
>
> #define CLASS_OF(v) rb_class_of((VALUE)(v))
>
> #define T_NONE 0x00
>
> #define T_NIL 0x01
> #define T_OBJECT 0x02
> #define T_CLASS 0x03
> #define T_ICLASS 0x04
> #define T_MODULE 0x05
> #define T_FLOAT 0x06
> #define T_STRING 0x07
> #define T_REGEXP 0x08
> #define T_ARRAY 0x09
> #define T_FIXNUM 0x0a
> #define T_HASH 0x0b
> #define T_STRUCT 0x0c
> #define T_BIGNUM 0x0d
> #define T_FILE 0x0e
>
> #define T_TRUE 0x20
> #define T_FALSE 0x21
> #define T_DATA 0x22
> #define T_MATCH 0x23
> #define T_SYMBOL 0x24
>
> #define T_BLKTAG 0x3b
> #define T_UNDEF 0x3c
> #define T_VARMAP 0x3d
> #define T_SCOPE 0x3e
> #define T_NODE 0x3f
>
> #define T_MASK 0x3f
>
> #define BUILTIN_TYPE(x) (((struct RBasic*)(x))->flags & T_MASK)
>
> #define TYPE(x) rb_type((VALUE)(x))
>
> void rb_check_type _((VALUE,int));
> #define Check_Type(v,t) rb_check_type((VALUE)(v),t)
>
> VALUE rb_str_to_str _((VALUE));
> VALUE rb_string_value _((volatile VALUE*));
> char *rb_string_value_ptr _((volatile VALUE*));
> char *rb_string_value_cstr _((volatile VALUE*));
>
> #define StringValue(v) rb_string_value(&(v))
> #define StringValuePtr(v) rb_string_value_ptr(&(v))
> #define StringValueCStr(v) rb_string_value_cstr(&(v))
>
> void rb_check_safe_obj _((VALUE));
> void rb_check_safe_str _((VALUE));
> #define SafeStringValue(v) do {\
> StringValue(v);\
> rb_check_safe_obj(v);\
> } while (0)
> /* obsolete macro - use SafeStringValue(v) */
> #define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
>
> void rb_secure _((int));
> RUBY_EXTERN int ruby_safe_level;
> #define rb_safe_level() (ruby_safe_level)
> void rb_set_safe_level _((int));
> void rb_secure_update _((VALUE));
>
> long rb_num2long _((VALUE));
> unsigned long rb_num2ulong _((VALUE));
> #define NUM2LONG(x) (FIXNUM_P(x)?FIX2LONG(x):rb_num2long((VALUE)x))
> #define NUM2ULONG(x) rb_num2ulong((VALUE)x)
> #if SIZEOF_INT < SIZEOF_LONG
> long rb_num2int _((VALUE));
> #define NUM2INT(x) (FIXNUM_P(x)?FIX2INT(x):rb_num2int((VALUE)x))
> long rb_fix2int _((VALUE));
> #define FIX2INT(x) rb_fix2int((VALUE)x)
> unsigned long rb_num2uint _((VALUE));
> #define NUM2UINT(x) rb_num2uint(x)
> unsigned long rb_fix2uint _((VALUE));
> #define FIX2UINT(x) rb_fix2uint(x)
> #else
> #define NUM2INT(x) ((int)NUM2LONG(x))
> #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
> #define FIX2INT(x) ((int)FIX2LONG(x))
> #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
> #endif
>
> #ifdef HAVE_LONG_LONG
> LONG_LONG rb_num2ll _((VALUE));
> unsigned LONG_LONG rb_num2ull _((VALUE));
> # define NUM2LL(x) (FIXNUM_P(x)?FIX2LONG(x):rb_num2ll((VALUE)x))
> # define NUM2ULL(x) rb_num2ull((VALUE)x)
> #endif
>
> #if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
> # define NUM2OFFT(x) ((off_t)NUM2LL(x))
> #else
> # define NUM2OFFT(x) NUM2LONG(x)
> #endif
>
> double rb_num2dbl _((VALUE));
> #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
>
> /* obsolete API - use StringValue() */
> char *rb_str2cstr _((VALUE,long*));
> /* obsolete API - use StringValuePtr() */
> #define STR2CSTR(x) rb_str2cstr((VALUE)(x),0)
>
> #define NUM2CHR(x) (((TYPE(x) == T_STRING)&&(RSTRING(x)->len>=1))?\
> RSTRING(x)->ptr[0]:(char)(NUM2INT(x)&0xff))
> #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
>
> VALUE rb_newobj _((void));
> #define NEWOBJ(obj,type) type *obj = (type*)rb_newobj()
> #define OBJSETUP(obj,c,t) do {\
> RBASIC(obj)->flags = (t);\
> RBASIC(obj)->klass = (c);\
> if (rb_safe_level() >= 3) FL_SET(obj, FL_TAINT);\
> } while (0)
> #define CLONESETUP(clone,obj) do {\
> 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);\
> } while (0)
> #define DUPSETUP(dup,obj) do {\
> OBJSETUP(dup,rb_obj_class(obj),(RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT));\
> if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)dup,(VALUE)obj);\
> } while (0)
>
> struct RBasic {
> unsigned long flags;
> VALUE klass;
> };
>
> struct RObject {
> struct RBasic basic;
> struct st_table *iv_tbl;
> };
>
> struct RClass {
> struct RBasic basic;
> struct st_table *iv_tbl;
> struct st_table *m_tbl;
> VALUE super;
> };
>
> struct RFloat {
> struct RBasic basic;
> double value;
> };
>
> #define ELTS_SHARED FL_USER2
>
> struct RString {
> struct RBasic basic;
> long len;
> char *ptr;
> union {
> long capa;
> VALUE shared;
> } aux;
> };
> #define RSTRING_PTR(s) (RSTRING(s)->ptr)
> #define RSTRING_LEN(s) (RSTRING(s)->len)
>
> struct RArray {
> struct RBasic basic;
> long len;
> union {
> long capa;
> VALUE shared;
> } aux;
> VALUE *ptr;
> };
> #define RARRAY_PTR(s) (RARRAY(s)->ptr)
> #define RARRAY_LEN(s) (RARRAY(s)->len)
>
> struct RRegexp {
> struct RBasic basic;
> struct re_pattern_buffer *ptr;
> long len;
> char *str;
> };
>
> struct RHash {
> struct RBasic basic;
> struct st_table *tbl;
> int iter_lev;
> VALUE ifnone;
> };
>
> struct RFile {
> struct RBasic basic;
> struct OpenFile *fptr;
> };
>
> struct RData {
> struct RBasic basic;
> void (*dmark) _((void*));
> void (*dfree) _((void*));
> void *data;
> };
>
> #define DATA_PTR(dta) (RDATA(dta)->data)
>
> /*
> #define RUBY_DATA_FUNC(func) ((void (*)_((void*)))func)
> */
> typedef void (*RUBY_DATA_FUNC) _((void*));
>
> VALUE rb_data_object_alloc _((VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC));
>
> #define Data_Wrap_Struct(klass,mark,free,sval)\
> rb_data_object_alloc(klass,sval,(RUBY_DATA_FUNC)mark,(RUBY_DATA_FUNC)free)
>
> #define Data_Make_Struct(klass,type,mark,free,sval) (\
> sval = ALLOC(type),\
> memset(sval, 0, sizeof(type)),\
> Data_Wrap_Struct(klass,mark,free,sval)\
> )
>
> #define Data_Get_Struct(obj,type,sval) do {\
> Check_Type(obj, T_DATA); \
> sval = (type*)DATA_PTR(obj);\
> } while (0)
>
> struct RStruct {
> struct RBasic basic;
> long len;
> VALUE *ptr;
> };
> #define RSTRUCT_LEN(st) (RSTRUCT(st)->len)
> #define RSTRUCT_PTR(st) (RSTRUCT(st)->ptr)
>
> struct RBignum {
> struct RBasic basic;
> char sign;
> long len;
> void *digits;
> };
>
> #define R_CAST(st) (struct st*)
> #define RBASIC(obj) (R_CAST(RBasic)(obj))
> #define ROBJECT(obj) (R_CAST(RObject)(obj))
> #define RCLASS(obj) (R_CAST(RClass)(obj))
> #define RMODULE(obj) RCLASS(obj)
> #define RFLOAT(obj) (R_CAST(RFloat)(obj))
> #define RSTRING(obj) (R_CAST(RString)(obj))
> #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
> #define RARRAY(obj) (R_CAST(RArray)(obj))
> #define RHASH(obj) (R_CAST(RHash)(obj))
> #define RDATA(obj) (R_CAST(RData)(obj))
> #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
> #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
> #define RFILE(obj) (R_CAST(RFile)(obj))
>
> #define FL_SINGLETON FL_USER0
> #define FL_MARK (1<<6)
> #define FL_FINALIZE (1<<7)
> #define FL_TAINT (1<<8)
> #define FL_EXIVAR (1<<9)
> #define FL_FREEZE (1<<10)
>
> #define FL_USHIFT 11
>
> #define FL_USER0 (1<<(FL_USHIFT+0))
> #define FL_USER1 (1<<(FL_USHIFT+1))
> #define FL_USER2 (1<<(FL_USHIFT+2))
> #define FL_USER3 (1<<(FL_USHIFT+3))
> #define FL_USER4 (1<<(FL_USHIFT+4))
> #define FL_USER5 (1<<(FL_USHIFT+5))
> #define FL_USER6 (1<<(FL_USHIFT+6))
> #define FL_USER7 (1<<(FL_USHIFT+7))
>
> #define FL_UMASK (0xff<<FL_USHIFT)
>
> #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
>
> #define FL_ABLE(x) (!SPECIAL_CONST_P(x))
> #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
> #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
> #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
> #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
>
> #define OBJ_TAINTED(x) FL_TEST((x), FL_TAINT)
> #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
> #define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT;} while (0)
>
> #define OBJ_FROZEN(x) FL_TEST((x), FL_FREEZE)
> #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
>
> #define ALLOC_N(type,n) (type*)xmalloc(sizeof(type)*(n))
> #define ALLOC(type) (type*)xmalloc(sizeof(type))
> #define REALLOC_N(var,type,n) (var)=(type*)xrealloc((char*)(var),sizeof(type)*(n))
>
> #define ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n))
>
> #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
> #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
> #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
> #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
>
> void rb_obj_infect _((VALUE,VALUE));
>
> typedef int ruby_glob_func(const char*,VALUE);
> void rb_glob _((const char*,void(*)(const char*,VALUE),VALUE));
> void rb_globi _((const char*,void(*)(const char*,VALUE),VALUE));
> int ruby_brace_expand _((const char*,int,ruby_glob_func*,VALUE));
> int ruby_brace_glob _((const char*,int,ruby_glob_func*,VALUE));
>
> VALUE rb_define_class _((const char*,VALUE));
> VALUE rb_define_module _((const char*));
> VALUE rb_define_class_under _((VALUE, const char*, VALUE));
> VALUE rb_define_module_under _((VALUE, const char*));
>
> void rb_include_module _((VALUE,VALUE));
> void rb_extend_object _((VALUE,VALUE));
>
> void rb_define_variable _((const char*,VALUE*));
> void rb_define_virtual_variable _((const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS)));
> void rb_define_hooked_variable _((const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS)));
> int ruby_glob _((const char*,int,int(*)(const char*,VALUE),VALUE));
> int ruby_globi _((const char*,int,int(*)(const char*,VALUE),VALUE));
> void rb_define_readonly_variable _((const char*,VALUE*));
> void rb_define_const _((VALUE,const char*,VALUE));
> void rb_define_global_const _((const char*,VALUE));
>
> #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))func)
> void rb_define_method _((VALUE,const char*,VALUE(*)(ANYARGS),int));
> void rb_define_module_function _((VALUE,const char*,VALUE(*)(ANYARGS),int));
> void rb_define_global_function _((const char*,VALUE(*)(ANYARGS),int));
>
> void rb_undef_method _((VALUE,const char*));
> void rb_define_alias _((VALUE,const char*,const char*));
> void rb_define_attr _((VALUE,const char*,int,int));
>
> void rb_global_variable _((VALUE*));
> void rb_gc_register_address _((VALUE*));
> void rb_gc_unregister_address _((VALUE*));
>
> ID rb_intern _((const char*));
> char *rb_id2name _((ID));
> ID rb_to_id _((VALUE));
>
> char *rb_class2name _((VALUE));
> char *rb_obj_classname _((VALUE));
>
> void rb_p _((VALUE));
>
> VALUE rb_eval_string _((const char*));
> VALUE rb_eval_string_protect _((const char*, int*));
> VALUE rb_eval_string_wrap _((const char*, int*));
> VALUE rb_funcall __((VALUE, ID, int, ...));
> VALUE rb_funcall2 _((VALUE, ID, int, const VALUE*));
> VALUE rb_funcall3 _((VALUE, ID, int, const VALUE*));
> int rb_scan_args __((int, const VALUE*, const char*, ...));
> VALUE rb_call_super _((int, const VALUE*));
>
> VALUE rb_gv_set _((const char*, VALUE));
> VALUE rb_gv_get _((const char*));
> VALUE rb_iv_get _((VALUE, const char*));
> VALUE rb_iv_set _((VALUE, const char*, VALUE));
>
> VALUE rb_equal _((VALUE,VALUE));
>
> RUBY_EXTERN VALUE ruby_verbose, ruby_debug;
>
> NORETURN(void rb_raise __((VALUE, const char*, ...)));
> NORETURN(void rb_fatal __((const char*, ...)));
> NORETURN(void rb_bug __((const char*, ...)));
> NORETURN(void rb_sys_fail _((const char*)));
> NORETURN(void rb_iter_break _((void)));
> NORETURN(void rb_exit _((int)));
> NORETURN(void rb_notimplement _((void)));
>
> void rb_warning __((const char*, ...)); /* reports if `-w' specified */
> void rb_sys_warning __((const char*, ...)); /* reports if `-w' specified */
> void rb_warn __((const char*, ...)); /* reports always */
>
> VALUE rb_each _((VALUE));
> VALUE rb_yield _((VALUE));
> VALUE rb_yield_values __((int n, ...));
> VALUE rb_yield_splat _((VALUE));
> int rb_block_given_p _((void));
> void rb_need_block _((void));
> VALUE rb_iterate _((VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE));
> VALUE rb_rescue _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));
> VALUE rb_rescue2 __((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...));
> VALUE rb_ensure _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));
> VALUE rb_catch _((const char*,VALUE(*)(ANYARGS),VALUE));
> NORETURN(void rb_throw _((const char*,VALUE)));
>
> VALUE rb_require _((const char*));
>
> #ifdef __ia64
> void ruby_init_stack(VALUE*, void*);
> #define RUBY_INIT_STACK \
> VALUE variable_in_this_stack_frame; \
> ruby_init_stack(&variable_in_this_stack_frame, rb_ia64_bsp());
> #else
> void ruby_init_stack(VALUE*);
> #define RUBY_INIT_STACK \
> VALUE variable_in_this_stack_frame; \
> ruby_init_stack(&variable_in_this_stack_frame);
> #endif
> void ruby_init _((void));
> void ruby_options _((int, char**));
> NORETURN(void ruby_run _((void)));
>
> RUBY_EXTERN VALUE rb_mKernel;
> RUBY_EXTERN VALUE rb_mComparable;
> RUBY_EXTERN VALUE rb_mEnumerable;
> RUBY_EXTERN VALUE rb_mPrecision;
> RUBY_EXTERN VALUE rb_mErrno;
> RUBY_EXTERN VALUE rb_mFileTest;
> RUBY_EXTERN VALUE rb_mGC;
> RUBY_EXTERN VALUE rb_mMath;
> RUBY_EXTERN VALUE rb_mProcess;
>
> RUBY_EXTERN VALUE rb_cObject;
> RUBY_EXTERN VALUE rb_cArray;
> RUBY_EXTERN VALUE rb_cBignum;
> RUBY_EXTERN VALUE rb_cBinding;
> RUBY_EXTERN VALUE rb_cClass;
> RUBY_EXTERN VALUE rb_cCont;
> RUBY_EXTERN VALUE rb_cDir;
> RUBY_EXTERN VALUE rb_cData;
> RUBY_EXTERN VALUE rb_cFalseClass;
> RUBY_EXTERN VALUE rb_cFile;
> RUBY_EXTERN VALUE rb_cFixnum;
> RUBY_EXTERN VALUE rb_cFloat;
> RUBY_EXTERN VALUE rb_cHash;
> RUBY_EXTERN VALUE rb_cInteger;
> RUBY_EXTERN VALUE rb_cIO;
> RUBY_EXTERN VALUE rb_cMatch;
> RUBY_EXTERN VALUE rb_cMethod;
> RUBY_EXTERN VALUE rb_cModule;
> RUBY_EXTERN VALUE rb_cNameErrorMesg;
> RUBY_EXTERN VALUE rb_cNilClass;
> RUBY_EXTERN VALUE rb_cNumeric;
> RUBY_EXTERN VALUE rb_cProc;
> RUBY_EXTERN VALUE rb_cRange;
> RUBY_EXTERN VALUE rb_cRegexp;
> RUBY_EXTERN VALUE rb_cStat;
> RUBY_EXTERN VALUE rb_cString;
> RUBY_EXTERN VALUE rb_cStruct;
> RUBY_EXTERN VALUE rb_cSymbol;
> RUBY_EXTERN VALUE rb_cThread;
> RUBY_EXTERN VALUE rb_cTime;
> RUBY_EXTERN VALUE rb_cTrueClass;
> RUBY_EXTERN VALUE rb_cUnboundMethod;
>
> RUBY_EXTERN VALUE rb_eException;
> RUBY_EXTERN VALUE rb_eStandardError;
> RUBY_EXTERN VALUE rb_eSystemExit;
> RUBY_EXTERN VALUE rb_eInterrupt;
> RUBY_EXTERN VALUE rb_eSignal;
> RUBY_EXTERN VALUE rb_eFatal;
> RUBY_EXTERN VALUE rb_eArgError;
> RUBY_EXTERN VALUE rb_eEOFError;
> RUBY_EXTERN VALUE rb_eIndexError;
> RUBY_EXTERN VALUE rb_eRangeError;
> RUBY_EXTERN VALUE rb_eIOError;
> RUBY_EXTERN VALUE rb_eRuntimeError;
> RUBY_EXTERN VALUE rb_eSecurityError;
> RUBY_EXTERN VALUE rb_eSystemCallError;
> RUBY_EXTERN VALUE rb_eThreadError;
> RUBY_EXTERN VALUE rb_eTypeError;
> RUBY_EXTERN VALUE rb_eZeroDivError;
> RUBY_EXTERN VALUE rb_eNotImpError;
> RUBY_EXTERN VALUE rb_eNoMemError;
> RUBY_EXTERN VALUE rb_eNoMethodError;
> RUBY_EXTERN VALUE rb_eFloatDomainError;
> RUBY_EXTERN VALUE rb_eLocalJumpError;
> RUBY_EXTERN VALUE rb_eSysStackError;
> RUBY_EXTERN VALUE rb_eRegexpError;
>
> RUBY_EXTERN VALUE rb_eScriptError;
> RUBY_EXTERN VALUE rb_eNameError;
> RUBY_EXTERN VALUE rb_eSyntaxError;
> RUBY_EXTERN VALUE rb_eLoadError;
>
> RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr;
> RUBY_EXTERN VALUE ruby_errinfo;
>
> static inline VALUE
> #if defined(HAVE_PROTOTYPES)
> rb_class_of(VALUE obj)
> #else
> rb_class_of(obj)
> VALUE obj;
> #endif
> {
> if (FIXNUM_P(obj)) return rb_cFixnum;
> if (obj == Qnil) return rb_cNilClass;
> if (obj == Qfalse) return rb_cFalseClass;
> if (obj == Qtrue) return rb_cTrueClass;
> if (SYMBOL_P(obj)) return rb_cSymbol;
>
> return RBASIC(obj)->klass;
> }
>
> static inline int
> #if defined(HAVE_PROTOTYPES)
> rb_type(VALUE obj)
> #else
> rb_type(obj)
> VALUE obj;
> #endif
> {
> if (FIXNUM_P(obj)) return T_FIXNUM;
> if (obj == Qnil) return T_NIL;
> if (obj == Qfalse) return T_FALSE;
> if (obj == Qtrue) return T_TRUE;
> if (obj == Qundef) return T_UNDEF;
> if (SYMBOL_P(obj)) return T_SYMBOL;
> return BUILTIN_TYPE(obj);
> }
>
> static inline int
> #if defined(HAVE_PROTOTYPES)
> rb_special_const_p(VALUE obj)
> #else
> rb_special_const_p(obj)
> VALUE obj;
> #endif
> {
> if (SPECIAL_CONST_P(obj)) return Qtrue;
> return Qfalse;
> }
>
> #include "missing.h"
> #include "intern.h"
>
> #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
> /* hook for external modules */
> static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
> #endif
>
> #if defined(HAVE_LIBPTHREAD)
> #ifdef HAVE_PTHREAD_H
> #include <pthread.h>
> #endif
> typedef pthread_t rb_nativethread_t;
> # define NATIVETHREAD_CURRENT() pthread_self()
> # define NATIVETHREAD_EQUAL(t1,t2) pthread_equal((t1),(t2))
> # define HAVE_NATIVETHREAD
>
> # define NATIVETHREAD_KILL(th,sig) pthread_kill((th),(sig))
> # define HAVE_NATIVETHREAD_KILL
> #elif defined(_WIN32) || defined(_WIN32_WCE)
> typedef DWORD rb_nativethread_t;
> # define NATIVETHREAD_CURRENT() GetCurrentThreadId()
> # define NATIVETHREAD_EQUAL(t1,t2) ((t1) == (t2))
> # define HAVE_NATIVETHREAD
> #endif
> #ifdef HAVE_NATIVETHREAD
> int is_ruby_native_thread _((void));
> #else
> #define is_ruby_native_thread() (1)
> #endif
> #ifdef HAVE_NATIVETHREAD_KILL
> void ruby_native_thread_kill _((int));
> #endif
>
> #if defined(__cplusplus)
> #if 0
> { /* satisfy cc-mode */
> #endif
> } /* extern "C" { */
> #endif
>
> #endif /* ifndef RUBY_H */
>
>
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/intern.h:
>
> /**********************************************************************
>
> intern.h -
>
> $Author: shyouhei $
> $Date: 2008-07-07 12:10:04 +0900 (Mon, 07 Jul 2008) $
> created at: Thu Jun 10 14:22:17 JST 1993
>
> Copyright (C) 1993-2003 Yukihiro Matsumoto
> Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
> Copyright (C) 2000 Information-technology Promotion Agency, Japan
>
> **********************************************************************/
>
> /*
> * Functions and variables that are used by more than one source file of
> * the kernel.
> */
>
> #define ID_ALLOCATOR 1
>
> /* array.c */
> void rb_mem_clear _((register VALUE*, register long));
> VALUE rb_assoc_new _((VALUE, VALUE));
> VALUE rb_check_array_type _((VALUE));
> VALUE rb_ary_new _((void));
> VALUE rb_ary_new2 _((long));
> VALUE rb_ary_new3 __((long,...));
> VALUE rb_ary_new4 _((long, const VALUE *));
> VALUE rb_ary_freeze _((VALUE));
> VALUE rb_ary_aref _((int, VALUE*, VALUE));
> void rb_ary_store _((VALUE, long, VALUE));
> VALUE rb_ary_dup _((VALUE));
> VALUE rb_ary_to_ary _((VALUE));
> VALUE rb_ary_to_s _((VALUE));
> VALUE rb_ary_push _((VALUE, VALUE));
> VALUE rb_ary_pop _((VALUE));
> VALUE rb_ary_shift _((VALUE));
> VALUE rb_ary_unshift _((VALUE, VALUE));
> VALUE rb_ary_entry _((VALUE, long));
> VALUE rb_ary_each _((VALUE));
> VALUE rb_ary_join _((VALUE, VALUE));
> VALUE rb_ary_print_on _((VALUE, VALUE));
> VALUE rb_ary_reverse _((VALUE));
> VALUE rb_ary_sort _((VALUE));
> VALUE rb_ary_sort_bang _((VALUE));
> VALUE rb_ary_delete _((VALUE, VALUE));
> VALUE rb_ary_delete_at _((VALUE, long));
> VALUE rb_ary_clear _((VALUE));
> VALUE rb_ary_plus _((VALUE, VALUE));
> VALUE rb_ary_concat _((VALUE, VALUE));
> VALUE rb_ary_assoc _((VALUE, VALUE));
> VALUE rb_ary_rassoc _((VALUE, VALUE));
> VALUE rb_ary_includes _((VALUE, VALUE));
> VALUE rb_ary_cmp _((VALUE, VALUE));
> VALUE rb_protect_inspect _((VALUE(*)(ANYARGS),VALUE,VALUE));
> VALUE rb_inspecting_p _((VALUE));
> VALUE rb_check_array_value _((VALUE));
> VALUE rb_values_at _((VALUE, long, int, VALUE*, VALUE(*) _((VALUE,long))));
> /* bignum.c */
> VALUE rb_big_clone _((VALUE));
> void rb_big_2comp _((VALUE));
> VALUE rb_big_norm _((VALUE));
> VALUE rb_uint2big _((unsigned long));
> VALUE rb_int2big _((long));
> VALUE rb_uint2inum _((unsigned long));
> VALUE rb_int2inum _((long));
> VALUE rb_cstr_to_inum _((const char*, int, int));
> VALUE rb_str_to_inum _((VALUE, int, int));
> VALUE rb_cstr2inum _((const char*, int));
> VALUE rb_str2inum _((VALUE, int));
> VALUE rb_big2str _((VALUE, int));
> VALUE rb_big2str0 _((VALUE, int, int));
> long rb_big2long _((VALUE));
> #define rb_big2int(x) rb_big2long(x)
> unsigned long rb_big2ulong _((VALUE));
> #define rb_big2uint(x) rb_big2ulong(x)
> #if HAVE_LONG_LONG
> VALUE rb_ll2inum _((LONG_LONG));
> VALUE rb_ull2inum _((unsigned LONG_LONG));
> LONG_LONG rb_big2ll _((VALUE));
> unsigned LONG_LONG rb_big2ull _((VALUE));
> #endif /* HAVE_LONG_LONG */
> void rb_quad_pack _((char*,VALUE));
> VALUE rb_quad_unpack _((const char*,int));
> VALUE rb_dbl2big _((double));
> double rb_big2dbl _((VALUE));
> VALUE rb_big_plus _((VALUE, VALUE));
> VALUE rb_big_minus _((VALUE, VALUE));
> VALUE rb_big_mul _((VALUE, VALUE));
> VALUE rb_big_divmod _((VALUE, VALUE));
> VALUE rb_big_pow _((VALUE, VALUE));
> VALUE rb_big_and _((VALUE, VALUE));
> VALUE rb_big_or _((VALUE, VALUE));
> VALUE rb_big_xor _((VALUE, VALUE));
> VALUE rb_big_lshift _((VALUE, VALUE));
> VALUE rb_big_rand _((VALUE, double*));
> /* class.c */
> VALUE rb_class_boot _((VALUE));
> VALUE rb_class_new _((VALUE));
> VALUE rb_mod_init_copy _((VALUE, VALUE));
> VALUE rb_class_init_copy _((VALUE, VALUE));
> VALUE rb_singleton_class_clone _((VALUE));
> void rb_singleton_class_attached _((VALUE,VALUE));
> VALUE rb_make_metaclass _((VALUE, VALUE));
> void rb_check_inheritable _((VALUE));
> VALUE rb_class_inherited _((VALUE, VALUE));
> VALUE rb_define_class_id _((ID, VALUE));
> VALUE rb_module_new _((void));
> VALUE rb_define_module_id _((ID));
> VALUE rb_mod_included_modules _((VALUE));
> VALUE rb_mod_include_p _((VALUE, VALUE));
> VALUE rb_mod_ancestors _((VALUE));
> VALUE rb_class_instance_methods _((int, VALUE*, VALUE));
> VALUE rb_class_public_instance_methods _((int, VALUE*, VALUE));
> VALUE rb_class_protected_instance_methods _((int, VALUE*, VALUE));
> VALUE rb_big_rshift(VALUE, VALUE);
> VALUE rb_class_private_instance_methods _((int, VALUE*, VALUE));
> VALUE rb_obj_singleton_methods _((int, VALUE*, VALUE));
> void rb_define_method_id _((VALUE, ID, VALUE (*)(ANYARGS), int));
> void rb_frozen_class_p _((VALUE));
> void rb_undef _((VALUE, ID));
> void rb_define_protected_method _((VALUE, const char*, VALUE (*)(ANYARGS), int));
> void rb_define_private_method _((VALUE, const char*, VALUE (*)(ANYARGS), int));
> void rb_define_singleton_method _((VALUE, const char*, VALUE(*)(ANYARGS), int));
> VALUE rb_singleton_class _((VALUE));
> /* compar.c */
> int rb_cmpint _((VALUE, VALUE, VALUE));
> NORETURN(void rb_cmperr _((VALUE, VALUE)));
> /* enum.c */
> /* error.c */
> RUBY_EXTERN int ruby_nerrs;
> VALUE rb_exc_new _((VALUE, const char*, long));
> VALUE rb_exc_new2 _((VALUE, const char*));
> VALUE rb_exc_new3 _((VALUE, VALUE));
> NORETURN(void rb_loaderror __((const char*, ...)));
> NORETURN(void rb_name_error __((ID, const char*, ...)));
> NORETURN(void rb_invalid_str _((const char*, const char*)));
> void rb_compile_error __((const char*, ...));
> void rb_compile_error_append __((const char*, ...));
> NORETURN(void rb_load_fail _((const char*)));
> NORETURN(void rb_error_frozen _((const char*)));
> void rb_check_frozen _((VALUE));
> /* eval.c */
> RUBY_EXTERN struct RNode *ruby_current_node;
> void ruby_set_current_source _((void));
> NORETURN(void rb_exc_raise _((VALUE)));
> NORETURN(void rb_exc_fatal _((VALUE)));
> VALUE rb_f_exit _((int,VALUE*));
> VALUE rb_f_abort _((int,VALUE*));
> void rb_remove_method _((VALUE, const char*));
> #define rb_disable_super(klass, name) ((void)0)
> #define rb_enable_super(klass, name) ((void)0)
> #define HAVE_RB_DEFINE_ALLOC_FUNC 1
> void rb_define_alloc_func _((VALUE, VALUE (*)(VALUE)));
> void rb_undef_alloc_func _((VALUE));
> void rb_clear_cache _((void));
> void rb_clear_cache_by_class _((VALUE));
> void rb_alias _((VALUE, ID, ID));
> void rb_attr _((VALUE,ID,int,int,int));
> int rb_method_boundp _((VALUE, ID, int));
> VALUE rb_dvar_defined _((ID));
> VALUE rb_dvar_curr _((ID));
> VALUE rb_dvar_ref _((ID));
> void rb_dvar_asgn _((ID, VALUE));
> void rb_dvar_push _((ID, VALUE));
> VALUE *rb_svar _((int));
> VALUE rb_eval_cmd _((VALUE, VALUE, int));
> int rb_obj_respond_to _((VALUE, ID, int));
> int rb_respond_to _((VALUE, ID));
> void rb_interrupt _((void));
> VALUE rb_apply _((VALUE, ID, VALUE));
> void rb_backtrace _((void));
> ID rb_frame_last_func _((void));
> VALUE rb_obj_instance_eval _((int, VALUE*, VALUE));
> VALUE rb_mod_module_eval _((int, VALUE*, VALUE));
> void rb_load _((VALUE, int));
> void rb_load_protect _((VALUE, int, int*));
> NORETURN(void rb_jump_tag _((int)));
> int rb_provided _((const char*));
> void rb_provide _((const char*));
> VALUE rb_f_require _((VALUE, VALUE));
> VALUE rb_require_safe _((VALUE, int));
> void rb_obj_call_init _((VALUE, int, VALUE*));
> VALUE rb_class_new_instance _((int, VALUE*, VALUE));
> VALUE rb_block_proc _((void));
> VALUE rb_f_lambda _((void));
> VALUE rb_proc_new _((VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE));
> VALUE rb_protect _((VALUE (*)(VALUE), VALUE, int*));
> void rb_set_end_proc _((void (*)(VALUE), VALUE));
> void rb_mark_end_proc _((void));
> void rb_exec_end_proc _((void));
> void ruby_finalize _((void));
> NORETURN(void ruby_stop _((int)));
> int ruby_cleanup _((int));
> int ruby_exec _((void));
> void rb_gc_mark_threads _((void));
> void rb_thread_start_timer _((void));
> void rb_thread_stop_timer _((void));
> void rb_thread_schedule _((void));
> void rb_thread_wait_fd _((int));
> int rb_thread_fd_writable _((int));
> void rb_thread_fd_close _((int));
> int rb_thread_alone _((void));
> void rb_thread_polling _((void));
> void rb_thread_sleep _((int));
> void rb_thread_sleep_forever _((void));
> VALUE rb_thread_stop _((void));
> VALUE rb_thread_wakeup _((VALUE));
> VALUE rb_thread_wakeup_alive _((VALUE));
> VALUE rb_thread_run _((VALUE));
> VALUE rb_thread_kill _((VALUE));
> VALUE rb_thread_alive_p _((VALUE));
> VALUE rb_thread_create _((VALUE (*)(ANYARGS), void*));
> void rb_thread_interrupt _((void));
> void rb_thread_trap_eval _((VALUE, int, int));
> void rb_thread_signal_raise _((int));
> void rb_thread_signal_exit _((void));
> int rb_thread_select _((int, fd_set *, fd_set *, fd_set *, struct timeval *));
> void rb_thread_wait_for _((struct timeval));
> VALUE rb_thread_current _((void));
> VALUE rb_thread_main _((void));
> VALUE rb_thread_local_aref _((VALUE, ID));
> VALUE rb_thread_local_aset _((VALUE, ID, VALUE));
> void rb_thread_atfork _((void));
> VALUE rb_funcall_rescue __((VALUE, ID, int, ...));
> /* file.c */
> VALUE rb_file_s_expand_path _((int, VALUE *));
> VALUE rb_file_expand_path _((VALUE, VALUE));
> void rb_file_const _((const char*, VALUE));
> int rb_find_file_ext _((VALUE*, const char* const*));
> VALUE rb_find_file _((VALUE));
> char *rb_path_next _((const char *));
> char *rb_path_skip_prefix _((const char *));
> char *rb_path_last_separator _((const char *));
> char *rb_path_end _((const char *));
> VALUE rb_file_directory_p _((VALUE,VALUE));
> /* gc.c */
> NORETURN(void rb_memerror __((void)));
> int ruby_stack_check _((void));
> int ruby_stack_length _((VALUE**));
> int rb_during_gc _((void));
> char *rb_source_filename _((const char*));
> void rb_gc_mark_locations _((VALUE*, VALUE*));
> void rb_mark_tbl _((struct st_table*));
> void rb_mark_hash _((struct st_table*));
> void rb_gc_mark_maybe _((VALUE));
> void rb_gc_mark _((VALUE));
> void rb_gc_force_recycle _((VALUE));
> void rb_gc _((void));
> void rb_gc_copy_finalizer _((VALUE,VALUE));
> void rb_gc_finalize_deferred _((void));
> void rb_gc_call_finalizer_at_exit _((void));
> VALUE rb_gc_enable _((void));
> VALUE rb_gc_disable _((void));
> VALUE rb_gc_start _((void));
> /* hash.c */
> void st_foreach_safe _((struct st_table *, int (*)(ANYARGS), unsigned long));
> void rb_hash_foreach _((VALUE, int (*)(ANYARGS), VALUE));
> VALUE rb_hash _((VALUE));
> VALUE rb_hash_new _((void));
> VALUE rb_hash_freeze _((VALUE));
> VALUE rb_hash_aref _((VALUE, VALUE));
> VALUE rb_hash_aset _((VALUE, VALUE, VALUE));
> VALUE rb_hash_delete_if _((VALUE));
> VALUE rb_hash_delete _((VALUE,VALUE));
> int rb_path_check _((char*));
> int rb_env_path_tainted _((void));
> /* io.c */
> #define rb_defout rb_stdout
> RUBY_EXTERN VALUE rb_fs;
> RUBY_EXTERN VALUE rb_output_fs;
> RUBY_EXTERN VALUE rb_rs;
> RUBY_EXTERN VALUE rb_default_rs;
> RUBY_EXTERN VALUE rb_output_rs;
> VALUE rb_io_write _((VALUE, VALUE));
> VALUE rb_io_gets _((VALUE));
> VALUE rb_io_getc _((VALUE));
> VALUE rb_io_ungetc _((VALUE, VALUE));
> VALUE rb_io_close _((VALUE));
> VALUE rb_io_eof _((VALUE));
> VALUE rb_io_binmode _((VALUE));
> VALUE rb_io_addstr _((VALUE, VALUE));
> VALUE rb_io_printf _((int, VALUE*, VALUE));
> VALUE rb_io_print _((int, VALUE*, VALUE));
> VALUE rb_io_puts _((int, VALUE*, VALUE));
> VALUE rb_file_open _((const char*, const char*));
> VALUE rb_gets _((void));
> void rb_write_error _((const char*));
> void rb_write_error2 _((const char*, long));
> /* marshal.c */
> VALUE rb_marshal_dump _((VALUE, VALUE));
> VALUE rb_marshal_load _((VALUE));
> /* numeric.c */
> void rb_num_zerodiv _((void));
> VALUE rb_num_coerce_bin _((VALUE, VALUE));
> VALUE rb_num_coerce_cmp _((VALUE, VALUE));
> VALUE rb_num_coerce_relop _((VALUE, VALUE));
> VALUE rb_float_new _((double));
> VALUE rb_num2fix _((VALUE));
> VALUE rb_fix2str _((VALUE, int));
> VALUE rb_dbl_cmp _((double, double));
> /* object.c */
> int rb_eql _((VALUE, VALUE));
> VALUE rb_any_to_s _((VALUE));
> VALUE rb_inspect _((VALUE));
> VALUE rb_obj_is_instance_of _((VALUE, VALUE));
> VALUE rb_obj_is_kind_of _((VALUE, VALUE));
> VALUE rb_obj_alloc _((VALUE));
> VALUE rb_obj_clone _((VALUE));
> VALUE rb_obj_dup _((VALUE));
> VALUE rb_obj_init_copy _((VALUE,VALUE));
> VALUE rb_obj_taint _((VALUE));
> VALUE rb_obj_tainted _((VALUE));
> VALUE rb_obj_untaint _((VALUE));
> VALUE rb_obj_freeze _((VALUE));
> VALUE rb_obj_id _((VALUE));
> VALUE rb_obj_class _((VALUE));
> VALUE rb_class_real _((VALUE));
> VALUE rb_class_inherited_p _((VALUE, VALUE));
> VALUE rb_convert_type _((VALUE,int,const char*,const char*));
> VALUE rb_check_convert_type _((VALUE,int,const char*,const char*));
> VALUE rb_to_int _((VALUE));
> VALUE rb_Integer _((VALUE));
> VALUE rb_Float _((VALUE));
> VALUE rb_String _((VALUE));
> VALUE rb_Array _((VALUE));
> double rb_cstr_to_dbl _((const char*, int));
> double rb_str_to_dbl _((VALUE, int));
> /* parse.y */
> RUBY_EXTERN int ruby_sourceline;
> RUBY_EXTERN char *ruby_sourcefile;
> int ruby_yyparse _((void));
> ID rb_id_attrset _((ID));
> void rb_parser_append_print _((void));
> void rb_parser_while_loop _((int, int));
> int ruby_parser_stack_on_heap _((void));
> void rb_gc_mark_parser _((void));
> int rb_is_const_id _((ID));
> int rb_is_instance_id _((ID));
> int rb_is_class_id _((ID));
> int rb_is_local_id _((ID));
> int rb_is_junk_id _((ID));
> int rb_symname_p _((const char*));
> int rb_sym_interned_p _((VALUE));
> VALUE rb_backref_get _((void));
> void rb_backref_set _((VALUE));
> VALUE rb_lastline_get _((void));
> void rb_lastline_set _((VALUE));
> VALUE rb_sym_all_symbols _((void));
> /* process.c */
> int rb_proc_exec _((const char*));
> VALUE rb_f_exec _((int,VALUE*));
> int rb_waitpid _((int,int*,int));
> void rb_syswait _((int));
> VALUE rb_proc_times _((VALUE));
> VALUE rb_detach_process _((int));
> /* range.c */
> VALUE rb_range_new _((VALUE, VALUE, int));
> VALUE rb_range_beg_len _((VALUE, long*, long*, long, int));
> VALUE rb_length_by_each _((VALUE));
> /* re.c */
> int rb_memcmp _((const void*,const void*,long));
> int rb_memcicmp _((const void*,const void*,long));
> long rb_memsearch _((const void*,long,const void*,long));
> VALUE rb_reg_nth_defined _((int, VALUE));
> VALUE rb_reg_nth_match _((int, VALUE));
> VALUE rb_reg_last_match _((VALUE));
> VALUE rb_reg_match_pre _((VALUE));
> VALUE rb_reg_match_post _((VALUE));
> VALUE rb_reg_match_last _((VALUE));
> VALUE rb_reg_new _((const char*, long, int));
> VALUE rb_reg_match _((VALUE, VALUE));
> VALUE rb_reg_match2 _((VALUE));
> int rb_reg_options _((VALUE));
> void rb_set_kcode _((const char*));
> const char* rb_get_kcode _((void));
> void rb_kcode_set_option _((VALUE));
> void rb_kcode_reset_option _((void));
> /* ruby.c */
> RUBY_EXTERN VALUE rb_argv;
> RUBY_EXTERN VALUE rb_argv0;
> void rb_load_file _((const char*));
> void ruby_script _((const char*));
> void ruby_prog_init _((void));
> void ruby_set_argv _((int, char**));
> void ruby_process_options _((int, char**));
> void ruby_load_script _((void));
> void ruby_init_loadpath _((void));
> void ruby_incpush _((const char*));
> /* signal.c */
> VALUE rb_f_kill _((int, VALUE*));
> void rb_gc_mark_trap_list _((void));
> #ifdef POSIX_SIGNAL
> #define posix_signal ruby_posix_signal
> void posix_signal _((int, RETSIGTYPE (*)(int)));
> #endif
> void rb_trap_exit _((void));
> void rb_trap_exec _((void));
> const char *ruby_signal_name _((int));
> void ruby_default_signal _((int));
> /* sprintf.c */
> VALUE rb_f_sprintf _((int, VALUE*));
> VALUE rb_str_format _((int, VALUE*, VALUE));
> /* string.c */
> VALUE rb_str_new _((const char*, long));
> VALUE rb_str_new2 _((const char*));
> VALUE rb_str_new3 _((VALUE));
> VALUE rb_str_new4 _((VALUE));
> VALUE rb_str_new5 _((VALUE, const char*, long));
> VALUE rb_tainted_str_new _((const char*, long));
> VALUE rb_tainted_str_new2 _((const char*));
> VALUE rb_str_buf_new _((long));
> VALUE rb_str_buf_new2 _((const char*));
> VALUE rb_str_buf_append _((VALUE, VALUE));
> VALUE rb_str_buf_cat _((VALUE, const char*, long));
> VALUE rb_str_buf_cat2 _((VALUE, const char*));
> VALUE rb_obj_as_string _((VALUE));
> VALUE rb_check_string_type _((VALUE));
> VALUE rb_str_dup _((VALUE));
> VALUE rb_str_locktmp _((VALUE));
> VALUE rb_str_unlocktmp _((VALUE));
> VALUE rb_str_dup_frozen _((VALUE));
> VALUE rb_str_plus _((VALUE, VALUE));
> VALUE rb_str_times _((VALUE, VALUE));
> VALUE rb_str_substr _((VALUE, long, long));
> void rb_str_modify _((VALUE));
> VALUE rb_str_freeze _((VALUE));
> VALUE rb_str_resize _((VALUE, long));
> VALUE rb_str_cat _((VALUE, const char*, long));
> VALUE rb_str_cat2 _((VALUE, const char*));
> VALUE rb_str_append _((VALUE, VALUE));
> VALUE rb_str_concat _((VALUE, VALUE));
> int rb_str_hash _((VALUE));
> int rb_str_cmp _((VALUE, VALUE));
> VALUE rb_str_upto _((VALUE, VALUE, int));
> void rb_str_update _((VALUE, long, long, VALUE));
> VALUE rb_str_inspect _((VALUE));
> VALUE rb_str_dump _((VALUE));
> VALUE rb_str_split _((VALUE, const char*));
> void rb_str_associate _((VALUE, VALUE));
> VALUE rb_str_associated _((VALUE));
> void rb_str_setter _((VALUE, ID, VALUE*));
> VALUE rb_str_intern _((VALUE));
> /* struct.c */
> VALUE rb_struct_new __((VALUE, ...));
> VALUE rb_struct_define __((const char*, ...));
> VALUE rb_struct_alloc _((VALUE, VALUE));
> VALUE rb_struct_aref _((VALUE, VALUE));
> VALUE rb_struct_aset _((VALUE, VALUE, VALUE));
> VALUE rb_struct_getmember _((VALUE, ID));
> VALUE rb_struct_iv_get _((VALUE, char*));
> VALUE rb_struct_s_members _((VALUE));
> VALUE rb_struct_members _((VALUE));
> /* time.c */
> VALUE rb_time_new _((time_t, time_t));
> /* variable.c */
> VALUE rb_mod_name _((VALUE));
> VALUE rb_class_path _((VALUE));
> void rb_set_class_path _((VALUE, VALUE, const char*));
> VALUE rb_path2class _((const char*));
> void rb_name_class _((VALUE, ID));
> VALUE rb_class_name _((VALUE));
> void rb_autoload _((VALUE, ID, const char*));
> VALUE rb_autoload_load _((VALUE, ID));
> VALUE rb_autoload_p _((VALUE, ID));
> void rb_gc_mark_global_tbl _((void));
> VALUE rb_f_trace_var _((int, VALUE*));
> VALUE rb_f_untrace_var _((int, VALUE*));
> VALUE rb_f_global_variables _((void));
> void rb_alias_variable _((ID, ID));
> struct st_table* rb_generic_ivar_table _((VALUE));
> void rb_copy_generic_ivar _((VALUE,VALUE));
> void rb_mark_generic_ivar _((VALUE));
> void rb_mark_generic_ivar_tbl _((void));
> void rb_free_generic_ivar _((VALUE));
> VALUE rb_ivar_get _((VALUE, ID));
> VALUE rb_ivar_set _((VALUE, ID, VALUE));
> VALUE rb_ivar_defined _((VALUE, ID));
> VALUE rb_iv_set _((VALUE, const char*, VALUE));
> VALUE rb_iv_get _((VALUE, const char*));
> VALUE rb_attr_get _((VALUE, ID));
> VALUE rb_obj_instance_variables _((VALUE));
> VALUE rb_obj_remove_instance_variable _((VALUE, VALUE));
> void *rb_mod_const_at _((VALUE, void*));
> void *rb_mod_const_of _((VALUE, void*));
> VALUE rb_const_list _((void*));
> VALUE rb_mod_constants _((VALUE));
> VALUE rb_mod_remove_const _((VALUE, VALUE));
> int rb_const_defined _((VALUE, ID));
> int rb_const_defined_at _((VALUE, ID));
> int rb_const_defined_from _((VALUE, ID));
> VALUE rb_const_get _((VALUE, ID));
> VALUE rb_const_get_at _((VALUE, ID));
> VALUE rb_const_get_from _((VALUE, ID));
> void rb_const_set _((VALUE, ID, VALUE));
> VALUE rb_mod_constants _((VALUE));
> VALUE rb_mod_const_missing _((VALUE,VALUE));
> VALUE rb_cvar_defined _((VALUE, ID));
> #define RB_CVAR_SET_4ARGS 1
> void rb_cvar_set _((VALUE, ID, VALUE, int));
> VALUE rb_cvar_get _((VALUE, ID));
> void rb_cv_set _((VALUE, const char*, VALUE));
> VALUE rb_cv_get _((VALUE, const char*));
> void rb_define_class_variable _((VALUE, const char*, VALUE));
> VALUE rb_mod_class_variables _((VALUE));
> VALUE rb_mod_remove_cvar _((VALUE, VALUE));
> /* version.c */
> void ruby_show_version _((void));
> void ruby_show_copyright _((void));
>
> /usr/local/lib/ruby/1.8/i386-openbsd4.4/st.h:
>
> /* This is a public domain general purpose hash table package written by Peter Moore @ UCB. */
>
> /* @(#) st.h 5.1 89/12/14 */
>
> #ifndef ST_INCLUDED
>
> #define ST_INCLUDED
>
> #if SIZEOF_LONG == SIZEOF_VOIDP
> typedef unsigned long st_data_t;
> #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
> typedef unsigned LONG_LONG st_data_t;
> #else
> # error ---->> st.c requires sizeof(void*) == sizeof(long) to be compiled. <<---
> -
> #endif
> #define ST_DATA_T_DEFINED
>
> typedef struct st_table st_table;
>
> struct st_hash_type {
> int (*compare)();
> int (*hash)();
> };
>
> struct st_table {
> struct st_hash_type *type;
> int num_bins;
> int num_entries;
> struct st_table_entry **bins;
> };
>
> #define st_is_member(table,key) st_lookup(table,key,(st_data_t *)0)
>
> enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK};
>
> #ifndef _
> # define _(args) args
> #endif
> #ifndef ANYARGS
> # ifdef __cplusplus
> # define ANYARGS ...
> # else
> # define ANYARGS
> # endif
> #endif
>
> st_table *st_init_table _((struct st_hash_type *));
> st_table *st_init_table_with_size _((struct st_hash_type *, int));
> st_table *st_init_numtable _((void));
> st_table *st_init_numtable_with_size _((int));
> st_table *st_init_strtable _((void));
> st_table *st_init_strtable_with_size _((int));
> int st_delete _((st_table *, st_data_t *, st_data_t *));
> int st_delete_safe _((st_table *, st_data_t *, st_data_t *, st_data_t));
> int st_insert _((st_table *, st_data_t, st_data_t));
> int st_lookup _((st_table *, st_data_t, st_data_t *));
> int st_foreach _((st_table *, int (*)(ANYARGS), st_data_t));
> void st_add_direct _((st_table *, st_data_t, st_data_t));
> void st_free_table _((st_table *));
> void st_cleanup_safe _((st_table *, st_data_t));
> st_table *st_copy _((st_table *));
>
> #define ST_NUMCMP ((int (*)()) 0)
> #define ST_NUMHASH ((int (*)()) -2)
>
> #define st_numcmp ST_NUMCMP
> #define st_numhash ST_NUMHASH
>
> int st_strhash();
>
> #endif /* ST_INCLUDED */
Received on 2008-12-09 19:45:46 CET

This is an archived mail posted to the Subversion Dev mailing list.