.\" README.EXT.ja -  -*- Text -*- created at: Mon Aug  7 16:45:54 JST 1995

Ruby�γ�ĥ�饤�֥��κ�������������ޤ���

1�������μ�

C���ѿ��ˤϷ������ꡤ�ǡ����ˤϷ�������ޤ��󡥤Ǥ����顤��
�Ȥ��Хݥ��󥿤�int���ѿ�����������ȡ������ͤ������Ȥ��Ƽ�
�갷���ޤ����դ�Ruby���ѿ��ˤϷ����ʤ����ǡ����˷��������
�������ΰ㤤�Τ��ᡤC��Ruby����ߤ��Ѵ����ʤ���С����ߤ���
�ǡ����򥢥������Ǥ��ޤ���

Ruby�Υǡ�����VALUE�Ȥ���C�η���ɽ������ޤ���VALUE���Υǡ�
���Ϥ��Υǡ��������פ�ʬ���ΤäƤ��ޤ������Υǡ��������פ�
�����Τϥǡ���(���֥�������)�μºݤι�¤���̣���Ƥ��ơ�Ruby
�Υ��饹�ȤϤޤ���ä���ΤǤ���

VALUE����C�ˤȤäư�̣�Τ���ǡ�������Ф�����ˤ�

 (1) VALUE�Υǡ��������פ��Τ�
 (2) VALUE��C�Υǡ������Ѵ�����

��ξ����ɬ�פǤ���(1)��˺���ȴְ�ä��ǡ������Ѵ����Ԥ��
�ơ��ǰ��ץ�����बcore dump���ޤ���

1.1 �ǡ���������

Ruby�ˤϥ桼�����Ȥ���ǽ���Τ���ʲ��Υ����פ�����ޤ���

	T_NIL		nil
	T_OBJECT	�̾�Υ��֥�������
	T_CLASS		���饹
	T_MODULE	�⥸�塼��
	T_FLOAT		��ư��������
	T_STRING	ʸ����
	T_REGEXP	����ɽ��
	T_ARRAY		����
	T_FIXNUM	Fixnum(31bit�ޤ���63bitĹ����)
	T_HASH		Ϣ������
	T_STRUCT	(Ruby��)��¤��
	T_BIGNUM	¿��Ĺ����
	T_FILE		������
	T_TRUE		��
	T_FALSE		��
	T_DATA		�ǡ���
	T_SYMBOL	����ܥ�

����¾�����������Ѥ���Ƥ���ʲ��Υ����פ�����ޤ���

	T_ICLASS
	T_MATCH
	T_UNDEF
	T_VARMAP
	T_SCOPE
	T_NODE

�ۤȤ�ɤΥ����פ�C�ι�¤�ΤǼ�������Ƥ��ޤ���

1.2 VALUE�Υǡ��������פ�����å�����

ruby.h�Ǥ�TYPE()�Ȥ����ޥ������������Ƥ��ơ�VALUE�Υǡ���
�����פ��Τ뤳�Ȥ�����ޤ���TYPE()�ޥ����Ͼ�ǾҲ𤷤�T_XXXX
�η�����������֤��ޤ���VALUE�Υǡ��������פ˱����ƽ�������
���ˤϡ�TYPE()���ͤ�ʬ�����뤳�Ȥˤʤ�ޤ���

  switch (TYPE(obj)) {
    case T_FIXNUM:
      /* FIXNUM��� */
      break;
    case T_STRING:
      /* ʸ����ν��� */
      break;
    case T_ARRAY:
      /* ������ */
      break;
    default:
      /* �㳰��ȯ�������� */
      rb_raise(rb_eTypeError, "not valid value");
      break;
  }

����ȥǡ��������פ�����å����ơ��������ʤ�����㳰��ȯ����
��ؿ����Ѱդ���Ƥ��ޤ���

  void Check_Type(VALUE value, int type)

���δؿ���value��type��̵����С��㳰��ȯ�������ޤ���������
����Ϳ����줿VALUE�Υǡ��������פ����������ɤ��������å���
�뤿��ˤϡ����δؿ���Ȥ��ޤ���

FIXNUM��NIL�˴ؤ��ƤϤ���®��Ƚ�̥ޥ������Ѱդ���Ƥ��ޤ���

  FIXNUM_P(obj)
  NIL_P(obj)

1.3 VALUE��C�Υǡ������Ѵ�����

�ǡ��������פ�T_NIL��T_FALSE��T_TRUE�Ǥ�������ǡ����Ϥ��줾
��nil��false��true�Ǥ������Υǡ��������פΥ��֥������ȤϤҤ�
�Ĥ��Ĥ���¸�ߤ��ޤ���

�ǡ��������פ�T_FIXNUM�λ��������31bit�ޤ���63bit�Υ�������
���������Ǥ���long�Υ�������32bit�Υץ�åȥե�����Ǥ����
31bit�ˡ�long�Υ�������64bit�Υץ�åȥե�����Ǥ����63bit
�ˤʤ�ޤ�. FIXNUM �� C ���������Ѵ����뤿��ˤϥޥ���
��FIX2INT()�פޤ��ϡ�FIX2LONG()�פ�Ȥ��ޤ��������Υޥ���
����Ѥ���ݤˤϻ����˥ǡ��������פ�FIXNUM�Ǥ��뤳�Ȥ��ǧ��
��ɬ�פ�����ޤ��������Ū��®���Ѵ���Ԥ����Ȥ��Ǥ��ޤ�����
������FIX2LONG()�פ��㳰��ȯ�����ޤ��󤬡���FIX2INT()�פ���
����̤�int�Υ������˼��ޤ�ʤ����ˤ��㳰��ȯ�����ޤ���
���줫�顤FIXNUM�˸¤餺Ruby�Υǡ������������Ѵ�����
��NUM2INT()�פ���ӡ�NUM2LONG()�פȤ����ޥ���������ޤ�����
���Υޥ����ϥޥ����ϥǡ��������פΥ����å�̵���ǻȤ��ޤ�
(�������Ѵ��Ǥ��ʤ����ˤ��㳰��ȯ������)��Ʊ�ͤ˥����å�̵
�ǻȤ����Ѵ��ޥ�����double����Ф���NUM2DBL()�פ�����ޤ���

char* ����Ф���硤version 1.6 �����Ǥϡ�STR2CSTR()�פȤ�
���ޥ�����ȤäƤ��ޤ������������ to_str() �ˤ����ۤη���
����̤� GC ������ǽ�������뤿�ᡤversion 1.7 �ʹߤǤ�
obsolete �Ȥʤꡤ����� StringValue() �� StringValuePtr() 
��Ȥ�����侩���Ƥ��ޤ���StringValue(var) �� var �� String 
�Ǥ���в��⤻���������Ǥʤ���� var �� var.to_str() �η��
���֤�������ޥ�����StringValuePtr(var) ��Ʊ�ͤ� var ��
String ���֤������Ƥ��� var �ΥХ�����ɽ�����Ф��� char* ��
�֤��ޥ����Ǥ���var �����Ƥ�ľ���֤����������������Τǡ�
var �� lvalue �Ǥ���ɬ�פ�����ޤ���
�ޤ���StringValuePtr() ��������� StringValueCStr() �Ȥ�����
�����⤢��ޤ���StringValueCStr(var) �� var �� String ���֤�
�����Ƥ��� var ��ʸ����ɽ�����Ф��� char* ���֤��ޤ����֤���
��ʸ����������ˤ� nul ʸ�����ղä���ޤ����ʤ�������� nul
ʸ�����ޤޤ����� ArgumentError ��ȯ�����ޤ���
������StringValuePtr() �Ǥϡ������� nul ʸ���������ݾڤϤʤ���
����� nul ʸ�����ޤޤ�Ƥ����ǽ���⤢��ޤ���

����ʳ��Υǡ��������פ��б�����C�ι�¤�Τ�����ޤ����б���
�빽¤�ΤΤ���VALUE�Ϥ��Τޤޥ��㥹��(���Ѵ�)����й�¤�Τ�
�ݥ��󥿤��Ѵ��Ǥ��ޤ���

��¤�Τϡ�struct RXxxxx�פȤ���̾����ruby.h���������Ƥ���
�����㤨��ʸ����ϡ�struct RString�פǤ����ºݤ˻Ȥ���ǽ����
����Τ�ʸ��������󤯤餤���Ȼפ��ޤ���

ruby.h�ǤϹ�¤�Τإ��㥹�Ȥ���ޥ������RXXXXX()��(������ʸ
���ˤ������)�Ȥ���̾�����󶡤���Ƥ��ޤ�(��: RSTRING())��

��¤�Τ���ǡ�������Ф��ޥ������󶡤���Ƥ��ޤ���ʸ����
str��Ĺ�������뤿��ˤϡ�RSTRING_LEN(str)�פȤ���ʸ����str��
char*�Ȥ������뤿��ˤϡ�RSTRING_PTR(str)�פȤ��ޤ��������
���ˤϡ����줾���RARRAY_LEN(ary)�ס���RARRAY_PTR(ary)�פ�
�ʤ�ޤ���

Ruby�ι�¤�Τ�ľ�ܥ�������������˵���Ĥ��ʤ���Фʤ�ʤ���
�Ȥϡ������ʸ����ι�¤�Τ���Ȥϻ��Ȥ�������ǡ�ľ���ѹ���
�ʤ����ȤǤ���ľ���ѹ�������硤���֥������Ȥ����Ƥ���������
�Ȥ�ʤ��ʤäơ��פ�̥Х��θ����ˤʤ�ޤ���

1.4 C�Υǡ�����VALUE���Ѵ�����

VALUE�μºݤι�¤��

  * FIXNUM��

    1bit�����եȤ��ơ�LSB��Ω�Ƥ롥

  * ����¾�Υݥ��󥿤ξ��

    ���Τޤ�VALUE�˥��㥹�Ȥ��롥

�ȤʤäƤ��ޤ�����äơ�LSB������å������VALUE��FIXNUM����
�����狼��櫓�Ǥ�(�ݥ��󥿤�LSB��Ω�äƤ��ʤ����Ȥ��ꤷ��
����)��

�Ǥ����顤FIXNUM�ʳ���Ruby�Υ��֥������Ȥι�¤�Τ�ñ��VALUE
�˥��㥹�Ȥ��������VALUE���Ѵ�����ޤ�����������Ǥ�դι�¤
�Τ�VALUE�˥��㥹�Ƚ����櫓�ǤϤ���ޤ��󡥥��㥹�Ȥ����
��Ruby���ΤäƤ��빽¤��(ruby.h���������Ƥ���struct RXxxx
�Τ��)�����Ǥ���

FIXNUM�˴ؤ��Ƥ��Ѵ��ޥ������ͳ����ɬ�פ�����ޤ���C������
����VALUE���Ѵ�����ޥ����ϰʲ��Τ�Τ�����ޤ���ɬ�פ˱���
�ƻȤ�ʬ���Ƥ���������

  INT2FIX()	��Ȥ�������31bit�ޤ���63bit����˼��ޤ뼫��
		�������
  INT2NUM()	Ǥ�դ���������VALUE��

INT2NUM()��������FIXNUM���ϰϤ˼��ޤ�ʤ���硤Bignum���Ѵ�
���Ƥ���ޤ�(���������٤�)��

1.5 Ruby�Υǡ���������

������Ҥ٤��̤ꡤRuby�ι�¤�Τ򥢥���������������Ƥι�����
�Ԥ����Ȥϴ�����ޤ��󡥤ǡ�Ruby�Υǡ�����������ˤ�
Ruby���Ѱդ��Ƥ���ؿ����Ѥ��Ƥ���������

�����ǤϤ�äȤ�Ȥ���Ǥ�����ʸ��������������/�����
���ؿ��򤢤��ޤ�(�����ǤϤʤ��Ǥ�)��

 ʸ������Ф���ؿ�

  rb_str_new(const char *ptr, long len)

    ������Ruby��ʸ������������롥

  rb_str_new2(const char *ptr)

    C��ʸ���󤫤�Ruby��ʸ������������롥���δؿ��ε�ǽ��
    rb_str_new(ptr, strlen(ptr))��Ʊ���Ǥ��롥

  rb_tainted_str_new(const char *ptr, long len)

    �����ޡ������ղä��줿������Ruby��ʸ������������롥����
    ����Υǡ����˴�Ť�ʸ����ˤϱ����ޡ������ղä����٤�
    �Ǥ��롥

  rb_tainted_str_new2(const char *ptr)

    C��ʸ���󤫤�����ޡ������ղä��줿Ruby��ʸ������������롥

  rb_sprintf(const char *format, ...)
  rb_vsprintf(const char *format, va_list ap)

    C��ʸ����format��³��������printf(3)�Υե����ޥåȤˤ������ä�
    ��������Ruby��ʸ������������롥

  rb_str_cat(VALUE str, const char *ptr, long len)

    Ruby��ʸ����str��len�Х��Ȥ�ʸ����ptr���ɲä��롥

  rb_str_cat2(VALUE str, const char* ptr)

    Ruby��ʸ����str��C��ʸ����ptr���ɲä��롥���δؿ��ε�ǽ��
    rb_str_cat(str, ptr, strlen(ptr))��Ʊ���Ǥ��롥

  rb_str_catf(VALUE str, const char* format, ...)
  rb_str_vcatf(VALUE str, const char* format, va_list ap)

    C��ʸ����format��³��������printf(3)�Υե����ޥåȤˤ������ä�
    ��������Ruby��ʸ����str���ɲä��롥���δؿ��ε�ǽ�ϡ����줾��
    rb_str_cat2(str, rb_sprintf(format, ...)) ��
    rb_str_cat2(str, rb_vsprintf(format, ap)) ��Ʊ���Ǥ��롥

 ������Ф���ؿ�

  rb_ary_new()

    ���Ǥ�0��������������롥

  rb_ary_new2(long len)

    ���Ǥ�0��������������롥len����ʬ���ΰ�򤢤餫������
    ���ƤƤ�����

  rb_ary_new3(long n, ...)

    �����ǻ��ꤷ��n���Ǥ�ޤ�������������롥

  rb_ary_new4(long n, VALUE *elts)

    �����Ϳ����n���Ǥ�������������롥

  rb_ary_push(VALUE ary, VALUE val)
  rb_ary_pop(VALUE ary)
  rb_ary_shift(VALUE ary)
  rb_ary_unshift(VALUE ary, VALUE val)

    Array��Ʊ̾�Υ᥽�åɤ�Ʊ��Ư���򤹤�ؿ�����1������ɬ��
    ����Ǥʤ���Фʤ�ʤ���

2��Ruby�ε�ǽ��Ȥ�

����Ū��Ruby�ǽ񤱤뤳�Ȥ�C�Ǥ�񤱤ޤ���Ruby���Τ�Τ�C�ǵ�
�Ҥ���Ƥ����Ǥ����顤�����Ȥ����������ʤ�Ǥ����ɡ�������
��Ruby�γ�ĥ�˻Ȥ����Ȥ�¿����������ͽ¬����뵡ǽ���濴�˾�
�𤷤ޤ���

2.1 Ruby�˵�ǽ���ɲä���

Ruby���󶡤���Ƥ���ؿ���Ȥ���Ruby���󥿥ץ꥿�˿�������ǽ
���ɲä��뤳�Ȥ��Ǥ��ޤ���Ruby�Ǥϰʲ��ε�ǽ���ɲä���ؿ���
�󶡤���Ƥ��ޤ���

 * ���饹���⥸�塼��
 * �᥽�åɡ��ðۥ᥽�åɤʤ�
 * ���

�ǤϽ�˾Ҳ𤷤ޤ���

2.1.1 ���饹/�⥸�塼�����

���饹��⥸�塼���������뤿��ˤϡ��ʲ��δؿ���Ȥ��ޤ���

  VALUE rb_define_class(const char *name, VALUE super)
  VALUE rb_define_module(const char *name)

�����δؿ��Ͽ�����������줿���饹��⥸�塼����֤��ޤ���
�᥽�åɤ����������ˤ������ͤ�ɬ�פʤΤǡ��ۤȤ�ɤξ��
������ͤ��ѿ��˳�Ǽ���Ƥ���ɬ�פ�����Ǥ��礦��

���饹��⥸�塼���¾�Υ��饹�������˥ͥ��Ȥ�������������
�ϰʲ��δؿ���Ȥ��ޤ���

  VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
  VALUE rb_define_module_under(VALUE outer, const char *name)

2.1.2 �᥽�å�/�ðۥ᥽�å����

�᥽�åɤ��ðۥ᥽�åɤ��������ˤϰʲ��δؿ���Ȥ��ޤ���

  void rb_define_method(VALUE klass, const char *name, 
		        VALUE (*func)(), int argc)

  void rb_define_singleton_method(VALUE object, const char *name, 
			          VALUE (*func)(), int argc)


ǰ�Τ�����������ȡ��ðۥ᥽�åɡפȤϡ���������Υ��֥�����
�Ȥ��Ф��Ƥ���ͭ���ʥ᥽�åɤǤ���Ruby�ǤϤ褯Smalltalk�ˤ�
���륯�饹�᥽�åɤȤ��ơ����饹���Ф����ðۥ᥽�åɤ��Ȥ��
�ޤ���

�����δؿ��� argc�Ȥ���������C�δؿ����Ϥ��������ο�(��
����)����ޤ���argc��0�ʾ�λ��ϴؿ��˰����Ϥ������ο����
̣���ޤ���16�İʾ�ΰ����ϻȤ��ޤ���(�����פ�ޤ����͡���
��ʤ�)���ºݤδؿ��ˤ���Ƭ�ΰ����Ȥ���self��Ϳ�����ޤ���
�ǡ����ꤷ�������1¿����������Ĥ��Ȥˤʤ�ޤ���

argc����λ��ϰ����ο��ǤϤʤ�����������ꤷ�����Ȥˤʤ�ޤ���
argc��-1�λ��ϰ����������������Ϥ���ޤ���argc��-2�λ��ϰ�
����Ruby������Ȥ����Ϥ���ޤ���

�᥽�åɤ��������ؿ��Ϥ⤦��Ĥ���ޤ����ҤȤĤ�private��
���åɤ��������ؿ��ǡ�������rb_define_method()��Ʊ���Ǥ���

  void rb_define_private_method(VALUE klass, const char *name, 
				VALUE (*func)(), int argc)

private�᥽�åɤȤϴؿ������Ǥ����ƤӽФ����Ȥν���ʤ��᥽��
�ɤǤ���

�⤦�ҤȤĤϥ⥸�塼��ؿ�����������ΤǤ����⥸�塼��ؿ�
�Ȥϥ⥸�塼����ðۥ᥽�åɤǤ��ꡤƱ����private�᥽�åɤ�
�⤢���ΤǤ�����򤢤����Math�⥸�塼���sqrt()�ʤɤ�����
���ޤ������Υ᥽�åɤ�

  Math.sqrt(4)

�Ȥ��������Ǥ�

  include Math
  sqrt(4)

�Ȥ��������Ǥ�Ȥ��ޤ����⥸�塼��ؿ����������ؿ��ϰʲ���
�̤�Ǥ���

  void rb_define_module_function(VALUE module, const char *name, 
		                 VALUE (*func)(), int argc)

�ؿ�Ū�᥽�å�(Kernel�⥸�塼���private method)��������뤿
��δؿ��ϰʲ����̤�Ǥ���

  void rb_define_global_function(const char *name, VALUE (*func)(), int argc)


�᥽�åɤ���̾��������뤿��δؿ��ϰʲ����̤�Ǥ���

  void rb_define_alias(VALUE module, const char* new, const char* old);

���饹�᥽�å�allocate������������������ꤹ�뤿��δؿ���
�ʲ����̤�Ǥ���

  void rb_define_alloc_func(VALUE klass, VALUE (*func)(VALUE klass));
  void rb_undef_alloc_func(VALUE klass);

func�ϥ��饹������Ȥ��Ƽ�����äơ�������������Ƥ�줿����
�����󥹤��֤��ʤ��ƤϤʤ�ޤ��󡥤��Υ��󥹥��󥹤ϡ�������
�������ʤɤ�ޤޤʤ����Ǥ�������ֶ��פΤޤޤˤ��Ƥ������ۤ�
���褤�Ǥ��礦��

2.1.3 ������

��ĥ�饤�֥�꤬ɬ�פ�����Ϥ��餫����������Ƥ����������ɤ�
�Ǥ��礦��������������ؿ�����Ĥ���ޤ���

  void rb_define_const(VALUE klass, const char *name, VALUE val)
  void rb_define_global_const(const char *name, VALUE val)

���Ԥ�����Υ��饹/�⥸�塼���°�����������������Ρ���
�Ԥϥ������Х���������������ΤǤ���

2.2 Ruby�ε�ǽ��C����ƤӽФ�

���ˡ�1.5 Ruby�Υǡ���������٤ǰ����Ҳ𤷤��褦�ʴؿ���
�Ȥ��С�Ruby�ε�ǽ��¸����Ƥ���ؿ���ľ�ܸƤӽФ����Ȥ�����
�ޤ���

# ���Τ褦�ʴؿ��ΰ���ɽ�Ϥ��ޤΤȤ�������ޤ��󡥥�������
# �뤷���ʤ��Ǥ��͡�

����ʳ��ˤ�Ruby�ε�ǽ��ƤӽФ���ˡ�Ϥ����Ĥ�����ޤ���

2.2.1 Ruby�Υץ�������eval����

C����Ruby�ε�ǽ��ƤӽФ���äȤ��ñ����ˡ�Ȥ��ơ�ʸ�����
Ϳ����줿Ruby�Υץ�������ɾ������ʲ��δؿ�������ޤ���

  VALUE rb_eval_string(const char *str)

����ɾ���ϸ��ߤδĶ��ǹԤ��ޤ����Ĥޤꡤ���ߤΥ��������ѿ�
�ʤɤ�����Ѥ��ޤ���

2.2.2 ID�ޤ��ϥ���ܥ�

C����ʸ������ͳ������Ruby�Υ᥽�åɤ�ƤӽФ����Ȥ�Ǥ���
�����������ˡ�Ruby���󥿥ץ꥿��ǥ᥽�åɤ��ѿ�̾����ꤹ��
���˻Ȥ��Ƥ���ID�ˤĤ����������Ƥ����ޤ��礦��

ID�Ȥ��ѿ�̾���᥽�å�̾��ɽ�������Ǥ���Ruby����Ǥ�

 :���̻�

�ǥ��������Ǥ��ޤ���C���餳�����������뤿��ˤϴؿ�

  rb_intern(const char *name)

��Ȥ��ޤ���Ruby��������Ȥ���Ϳ����줿����ܥ�(�ޤ���ʸ��
��)��ID���Ѵ�����ˤϰʲ��δؿ���Ȥ��ޤ���

  rb_to_id(VALUE symbol)

2.2.3 C����Ruby�Υ᥽�åɤ�ƤӽФ�

C����ʸ������ͳ������Ruby�Υ᥽�åɤ�ƤӽФ�����ˤϰʲ�
�δؿ���Ȥ��ޤ���

  VALUE rb_funcall(VALUE recv, ID mid, int argc, ...)

���δؿ��ϥ��֥�������recv��mid�ǻ��ꤵ���᥽�åɤ�Ƥӽ�
���ޤ�������¾�˰����λ���λ������㤦�ʲ��δؿ��⤢��ޤ���

  VALUE rb_funcall2(VALUE recv, ID mid, int argc, VALUE *argv)
  VALUE rb_apply(VALUE recv, ID mid, VALUE args)

apply�ˤϰ����Ȥ���Ruby�������Ϳ���ޤ���

2.2.4 �ѿ�/����򻲾�/��������

C����ؿ���Ȥäƻ��ȡ������Ǥ���Τϡ���������󥹥�����
���Ǥ�������ѿ��ϰ����Τ�Τ�C������ѿ��Ȥ��ƥ��������Ǥ�
�ޤ������������ѿ��򻲾Ȥ�����ˡ�ϸ������Ƥ��ޤ���

���֥������ȤΥ��󥹥����ѿ��򻲾ȡ���������ؿ��ϰʲ�����
��Ǥ���

  VALUE rb_ivar_get(VALUE obj, ID id)
  VALUE rb_ivar_set(VALUE obj, ID id, VALUE val)

id��rb_intern()���������Τ�ȤäƤ���������

����򻲾Ȥ���ˤϰʲ��δؿ���ȤäƤ���������

  VALUE rb_const_get(VALUE obj, ID id)

����򿷤���������뤿��ˤϡ�2.1.3 �������٤ǾҲ�
��Ƥ���ؿ���ȤäƤ���������

3��Ruby��C�Ȥξ���ͭ

C�����Ruby�δ֤Ǿ����ͭ������ˡ�ˤĤ��Ʋ��⤷�ޤ���

3.1 C���黲�ȤǤ���Ruby�����

�ʲ���Ruby�������C�Υ�٥뤫�黲�ȤǤ��ޤ���

  Qtrue
  Qfalse

    �����͡�Qfalse��C����Ǥ⵶�Ȥߤʤ���ޤ�(�Ĥޤ�0)��

  Qnil

    C���줫�鸫����nil�ס�

3.2 C��Ruby�Ƕ�ͭ���������ѿ�

C��Ruby������ѿ���Ȥäƾ����ͭ�Ǥ��ޤ�����ͭ�Ǥ������
�ѿ��ˤϤ����Ĥ��μ��ब����ޤ������Τʤ��Ǥ�äȤ��ɤ��Ȥ�
���Ȼפ���Τ�rb_define_variable()�Ǥ���

  void rb_define_variable(const char *name, VALUE *var)

���δؿ���Ruby��C�ȤǶ�ͭ��������ѿ���������ޤ����ѿ�̾��
`$'�ǻϤޤ�ʤ����ˤϼ�ưŪ���ɲä���ޤ��������ѿ����ͤ���
������ȼ�ưŪ��Ruby���б������ѿ����ͤ��Ѥ��ޤ���

�ޤ�Ruby¦����Ϲ����Ǥ��ʤ��ѿ��⤢��ޤ�������read only��
�ѿ��ϰʲ��δؿ���������ޤ���

  void rb_define_readonly_variable(const char *name, VALUE *var)

������ѿ���¾��hook��Ĥ�������ѿ�������Ǥ��ޤ���hook�դ�
������ѿ��ϰʲ��δؿ����Ѥ���������ޤ���hook�դ�����ѿ���
�ͤλ��Ȥ������hook�ǹԤ�ɬ�פ�����ޤ���

  void rb_define_hooked_variable(const char *name, VALUE *var,
				 VALUE (*getter)(), void (*setter)())

���δؿ���C�δؿ��ˤ�ä�hook�ΤĤ���줿����ѿ����������
�����ѿ������Ȥ��줿���ˤϴؿ�getter�����ѿ����ͤ����åȤ���
�����ˤϴؿ�setter���ƤФ�롥hook����ꤷ�ʤ�����getter��
setter��0����ꤷ�ޤ���

# getter��setter��0�ʤ��rb_define_variable()��Ʊ���ˤʤ롥

���줫�顤C�δؿ��ˤ�äƼ¸������Ruby������ѿ����������
�ؿ�������ޤ���

  void rb_define_virtual_variable(const char *name,
				  VALUE (*getter)(), void (*setter)())

���δؿ��ˤ�ä�������줿Ruby������ѿ������Ȥ��줿���ˤ�
getter�����ѿ����ͤ����åȤ��줿���ˤ�setter���ƤФ�ޤ���

getter��setter�λ��ͤϰʲ����̤�Ǥ���

  (*getter)(ID id, void *data, struct global_entry* entry);
  (*setter)(VALUE val, ID id, void *data, struct global_entry* entry);

3.3 C�Υǡ�����Ruby���֥������Ȥˤ���

C��������������줿�ǡ���(��¤��)��Ruby�Υ��֥������ȤȤ���
��갷��������礬���ꤨ�ޤ������Τ褦�ʾ��ˤϡ�Data�Ȥ���
Ruby���֥������Ȥ�C�ι�¤��(�ؤΥݥ���)�򤯤�ळ�Ȥ�Ruby
���֥������ȤȤ��Ƽ�갷����褦�ˤʤ�ޤ���

Data���֥������Ȥ��������ƹ�¤�Τ�Ruby���֥������Ȥ˥��ץ���
�����뤿��ˤϡ��ʲ��Υޥ�����Ȥ��ޤ���

  Data_Wrap_Struct(klass, mark, free, ptr)

���Υޥ���������ͤ��������줿Data���֥������ȤǤ���

klass�Ϥ���Data���֥������ȤΥ��饹�Ǥ���ptr�ϥ��ץ��벽����
C�ι�¤�ΤؤΥݥ��󥿤Ǥ���mark�Ϥ��ι�¤�Τ�Ruby�Υ��֥���
���Ȥؤλ��Ȥ�������˻Ȥ��ؿ��Ǥ������Τ褦�ʻ��Ȥ�ޤޤʤ�
���ˤ�0����ꤷ�ޤ���

# ���Τ褦�ʻ��Ȥϴ�����ޤ���

free�Ϥ��ι�¤�Τ��⤦���פˤʤä����˸ƤФ��ؿ��Ǥ�������
�ؿ��������١������쥯������ƤФ�ޤ������줬-1�ξ��ϡ�ñ
��˳�������ޤ���

mark�����free�ؿ���GC�¹���˸ƤӽФ���ޤ�.
�ʤ�, GC�¹����Ruby���֥������ȤΥ������������϶ػߤ����
��. ��ä�, mark�����free�ؿ���Ruby���֥������ȤΥ���������
���ϹԤ�ʤ��Ǥ�������.

C�ι�¤�Τγ�����Data���֥������Ȥ�������Ʊ���˹Ԥ��ޥ�����
���ưʲ��Τ�Τ��󶡤���Ƥ��ޤ���

  Data_Make_Struct(klass, type, mark, free, sval)

���Υޥ���������ͤ��������줿Data���֥������ȤǤ���

klass, mark, free��Data_Wrap_Struct��Ʊ��Ư���򤷤ޤ���type
�ϳ�����Ƥ�C��¤�Τη��Ǥ���������Ƥ�줿��¤�Τ��ѿ�sval
����������ޤ��������ѿ��η��� (type*) �Ǥ���ɬ�פ�����ޤ���

Data���֥������Ȥ���ݥ��󥿤���Ф��Τϰʲ��Υޥ������Ѥ�
�ޤ���

  Data_Get_Struct(obj, type, sval)

C�ι�¤�ΤؤΥݥ��󥿤��ѿ�sval����������ޤ���

������Data�λȤ����Ϥ���ä�ʬ����ˤ����Τǡ������������
����򻲾Ȥ��Ƥ���������

4������ - dbm�ѥå���������

�����ޤǤ������ǤȤꤢ������ĥ�饤�֥��Ϻ���Ϥ��Ǥ���
Ruby��ext�ǥ��쥯�ȥ�ˤ��Ǥ˴ޤޤ�Ƥ���dbm�饤�֥������
�����ʳ�Ū���������ޤ���

(1) �ǥ��쥯�ȥ����

  % mkdir ext/dbm

Ruby 1.1�����Ǥ�դΥǥ��쥯�ȥ�ǥ����ʥߥå��饤�֥����
�뤳�Ȥ��Ǥ���褦�ˤʤ�ޤ�����Ruby����Ū�˥�󥯤������
��Ruby��Ÿ�������ǥ��쥯�ȥ�β���ext�ǥ��쥯�ȥ����˳�ĥ
�饤�֥���ѤΥǥ��쥯�ȥ����ɬ�פ�����ޤ���̾����Ŭ����
����ǹ����ޤ���

(2) �߷פ���

�ޤ��������ʤ�Ǥ����ɡ��ɤ�������ǽ��¸����뤫�ɤ����ޤ���
�פ���ɬ�פ�����ޤ����ɤ�ʥ��饹��Ĥ��뤫�����Υ��饹�ˤ�
�ɤ�ʥ᥽�åɤ����뤫�����饹���󶡤�������ʤɤˤĤ����߷�
���ޤ���

(3) C�����ɤ��

��ĥ�饤�֥�����ΤȤʤ�C����Υ�������񤭤ޤ���C����Υ���
�����ҤȤĤλ��ˤϡ֥饤�֥��̾.c�פ����֤��ɤ��Ǥ��礦��C
����Υ�������ʣ���ξ��ˤϵդˡ֥饤�֥��̾.c�פȤ����ե�
����̾���򤱤�ɬ�פ�����ޤ������֥������ȥե�����ȥ⥸�塼
�������������Ū�����������֥饤�֥��̾.o�פȤ����ե�����
�Ȥ����ͤ��뤫��Ǥ���

Ruby�ϳ�ĥ�饤�֥�������ɤ�����ˡ�Init_�饤�֥��̾�פ�
�����ؿ���ưŪ�˼¹Ԥ��ޤ���dbm�饤�֥��ξ���Init_dbm��
�Ǥ������δؿ�����ǥ��饹���⥸�塼�롤�᥽�åɡ�����ʤɤ�
�����Ԥ��ޤ���dbm.c����������Ѥ��ޤ���

--
void
Init_dbm(void)
{
    /* DBM���饹��������� */
    cDBM = rb_define_class("DBM", rb_cObject);
    /* DBM��Enumerate�⥸�塼��򥤥󥯥롼�ɤ��� */
    rb_include_module(cDBM, rb_mEnumerable);

    /* DBM���饹�Υ��饹�᥽�å�open(): ������C������Ǽ����� */
    rb_define_singleton_method(cDBM, "open", fdbm_s_open, -1);

    /* DBM���饹�Υ᥽�å�close(): �����Ϥʤ� */
    rb_define_method(cDBM, "close", fdbm_close, 0);
    /* DBM���饹�Υ᥽�å�[]: ������1�� */
    rb_define_method(cDBM, "[]", fdbm_fetch, 1);
		:

    /* DBM�ǡ������Ǽ���륤�󥹥����ѿ�̾�Τ����ID */
    id_dbm = rb_intern("dbm");
}
--

DBM�饤�֥���dbm�Υǡ������б����륪�֥������Ȥˤʤ�Ϥ���
�����顤C��������dbm��Ruby�������˼�����ɬ�פ�����ޤ���


dbm.c�Ǥ�Data_Make_Struct��ʲ��Τ褦�˻ȤäƤ��ޤ���

--
struct dbmdata {
    int  di_size;
    DBM *di_dbm;
};


obj = Data_Make_Struct(klass, struct dbmdata, 0, free_dbm, dbmp);
--

�����Ǥ�dbmstruct��¤�ΤؤΥݥ��󥿤�Data�˥��ץ��벽���Ƥ�
�ޤ���DBM*��ľ�ܥ��ץ��벽���ʤ��Τ�close()�������ν������
���ƤΤ��ȤǤ���

Data���֥������Ȥ���dbmstruct��¤�ΤΥݥ��󥿤���Ф�����
�˰ʲ��Υޥ�����ȤäƤ��ޤ���

--
#define GetDBM(obj, dbmp) {\
    Data_Get_Struct(obj, struct dbmdata, dbmp);\
    if (dbmp->di_dbm == 0) closed_dbm();\
}
--

����ä�ʣ���ʥޥ����Ǥ������פ����dbmdata��¤�ΤΥݥ���
�μ��Ф��ȡ�close����Ƥ��뤫�ɤ����Υ����å���ޤȤ�Ƥ�
������Ǥ���

DBM���饹�ˤϤ�������᥽�åɤ�����ޤ�����ʬ�ह���3�����
�����μ�����������ޤ����ҤȤĤϰ����ο�������Τ�Τǡ����
���Ƥ�delete�᥽�åɤ�����ޤ���delete�᥽�åɤ�������Ƥ���
fdbm_delete()�Ϥ��Τ褦�ˤʤäƤ��ޤ���

--
static VALUE
fdbm_delete(VALUE obj, VALUE keystr)
{
	:
}
--

�����ο�������Υ����פ���1������self����2�����ʹߤ��᥽�å�
�ΰ����Ȥʤ�ޤ���

�����ο�������Τ�Τ�C������Ǽ������Τ�Ruby������Ǽ���
���ΤȤ�����ޤ���dbm�饤�֥�����ǡ�C������Ǽ�������
��DBM�Υ��饹�᥽�åɤǤ���open()�Ǥ��������������Ƥ����
��fdbm_s_open()�Ϥ����ʤäƤ��ޤ���

--
static VALUE
fdbm_s_open(int argc, VALUE *argv, VALUE klass)
{
	:
    if (rb_scan_args(argc, argv, "11", &file, &vmode) == 1) {
	mode = 0666;		/* default value */
    }
	:
}
--

���Υ����פδؿ�����1������Ϳ����줿�����ο�����2������Ϳ��
��줿���������äƤ�������ˤʤ�ޤ���self����3�����Ȥ���Ϳ
�����ޤ���

���������Ϳ����줿��������Ϥ��뤿��δؿ���open()�Ǥ�Ȥ�
��Ƥ���rb_scan_args()�Ǥ�����3�����˻��ꤷ���ե����ޥåȤ�
��������4�ѿ��ʹߤ˻��ꤷ���ѿ����ͤ��������Ƥ���ޤ�������
�ե����ޥåȤϡ���1ʸ���ܤ���ά�Ǥ��ʤ������ο�����2ʸ���ܤ�
��ά�Ǥ�������ο�����3ʸ���ܤ��б�������̵꤬�����ޤ�ΰ�
�������뤫�ɤ����򼨤�"*"�Ǥ���2ʸ���ܤ�3ʸ���ܤϾ�ά�Ǥ���
����dbm.c����Ǥϡ��ե����ޥåȤ�"11"�Ǥ����顤�����Ϻ���1��
�ǡ�2�Ĥޤǵ������Ȥ�����̣�ˤʤ�ޤ�����ά����Ƥ������
�ѿ����ͤ�nil(C����Υ�٥�Ǥ�Qnil)�ˤʤ�ޤ���

Ruby������ǰ������������Τ�indexes������ޤ��������Ϥ�
���Ǥ���

--
static VALUE
fdbm_indexes(VALUE obj, VALUE args)
{
	:
}
--

��1������self����2������Ruby������Ǥ���

** ���ջ���

Ruby�ȶ�ͭ�Ϥ��ʤ���Ruby�Υ��֥������Ȥ��Ǽ�����ǽ���Τ���
C������ѿ��ϰʲ��δؿ���Ȥä�Ruby���󥿥ץ꥿���ѿ���¸��
�򶵤��Ƥ����Ƥ����������Ǥʤ���GC�ǥȥ�֥�򵯤����ޤ���

  void rb_global_variable(VALUE *var)

(4) extconf.rb���Ѱդ���

Makefile������ο����ˤʤ�extconf.rb�Ȥ����ե��������
�ޤ���extconf.rb�ϥ饤�֥��Υ���ѥ����ɬ�פʾ��Υ�����
���ʤɤ�Ԥ����Ȥ���Ū�Ǥ����ޤ���

  require 'mkmf'

��extconf.rb����Ƭ���֤��ޤ���extconf.rb����Ǥϰʲ���Ruby��
����Ȥ����Ȥ�����ޤ���

  have_library(lib, func): �饤�֥���¸�ߥ����å�
  have_func(func, header): �ؿ���¸�ߥ����å�
  have_header(header): �إå��ե������¸�ߥ����å�
  create_makefile(target): Makefile������

�ʲ����ѿ���Ȥ����Ȥ��Ǥ��ޤ���

  $CFLAGS: ����ѥ�������ɲ�Ū�˻��ꤹ��ե饰(-O�ʤ�)
  $CPPFLAGS: �ץ�ץ����å����ɲ�Ū�˻��ꤹ��ե饰(-I��-D�ʤ�)
  $LDFLAGS: ��󥯻����ɲ�Ū�˻��ꤹ��ե饰(-L�ʤ�)
  $objs: ��󥯤���륪�֥������ȥե�����̾�Υꥹ��

���֥������ȥե�����Υꥹ�Ȥϡ��̾�ϥ������ե�����򸡺���
�Ƽ�ưŪ����������ޤ�����make������ǥ���������������褦��
��������Ū�˻��ꤹ��ɬ�פ�����ޤ���

�饤�֥��򥳥�ѥ��뤹���郎·�鷺�����Υ饤�֥��򥳥�
�ѥ��뤷�ʤ����ˤ�create_makefile��ƤФʤ����Makefile����
�����줺������ѥ����Ԥ��ޤ���

(5) depend���Ѱդ���

�⤷���ǥ��쥯�ȥ��depend�Ȥ����ե����뤬¸�ߤ���С�
Makefile����¸�ط�������å����Ƥ���ޤ���

  % gcc -MM *.c > depend

�ʤɤǺ�뤳�Ȥ�����ޤ������ä�»��̵���Ǥ��礦��

(6) Makefile����������

Makefile��ºݤ��������뤿��ˤ�

  ruby extconf.rb

�Ȥ��ޤ���extconf.rb�� require 'mkmf' �ιԤ��ʤ����ˤϥ��顼
�ˤʤ�ޤ��Τǡ��������ɲä���

  ruby -r mkmf extconf.rb

�Ȥ��Ƥ���������

site_ruby �ǥ��쥯�ȥ�Ǥʤ���
vendor_ruby �ǥ��쥯�ȥ�˥��󥹥ȡ��뤹����ˤ�
�ʲ��Τ褦�� --vendor ���ץ�����ä��Ƥ���������

  ruby extconf.rb --vendor

�ǥ��쥯�ȥ��ext�ʲ����Ѱդ������ˤ�Ruby���Τ�make�λ���
��ưŪ��Makefile����������ޤ��Τǡ����Υ��ƥåפ����פǤ���

(7) make����

ưŪ��󥯥饤�֥�������������ˤϤ��ξ��make���Ƥ�����
����ɬ�פǤ���� make install �ǥ��󥹥ȡ��뤵��ޤ���

ext�ʲ��˥ǥ��쥯�ȥ���Ѱդ������ϡ�Ruby�Υǥ��쥯�ȥ��
make��¹Ԥ����Makefile����������make��ɬ�פˤ�äƤϤ��Υ�
���塼���Ruby�ؤΥ�󥯤ޤǼ�ưŪ�˼¹Ԥ��Ƥ���ޤ���
extconf.rb��񤭴�����ʤɤ���Makefile�κ�������ɬ�פʻ��Ϥ�
��Ruby�ǥ��쥯�ȥ��make���Ƥ���������

��ĥ�饤�֥���make install��Ruby�饤�֥��Υǥ��쥯�ȥ��
���˥��ԡ�����ޤ����⤷��ĥ�饤�֥��ȶ�Ĵ���ƻȤ�Ruby�ǵ�
�Ҥ��줿�ץ�����ब���ꡤRuby�饤�֥����֤��������ˤϡ�
��ĥ�饤�֥���ѤΥǥ��쥯�ȥ�β��� lib �Ȥ����ǥ��쥯�ȥ�
���ꡤ������ ��ĥ�� .rb �Υե�������֤��Ƥ�����Ʊ���˥���
���ȡ��뤵��ޤ���

(8) �ǥХå�

�ޤ����ǥХå����ʤ���ư���ʤ��Ǥ��礦�͡�ext/Setup�˥ǥ���
���ȥ�̾��񤯤���Ū�˥�󥯤���ΤǥǥХå����Ȥ���褦�ˤ�
��ޤ�������ʬ����ѥ��뤬�٤��ʤ�ޤ����ɡ�

(9) �Ǥ�������

��Ϥ��ä���Ȥ��ʤꡤ������������ʤꡤ���ʤꡤ����ͳ�ˤ�
�Ȥ�����������Ruby�κ�Ԥϳ�ĥ�饤�֥��˴ؤ��ư��ڤθ�����
��ĥ���ޤ���

Appendix A. Ruby�Υ����������ɤ�ʬ��

Ruby�Υ������Ϥ����Ĥ���ʬ�ह�뤳�Ȥ�����ޤ������Τ�������
���饤�֥�����ʬ�ϴ���Ū�˳�ĥ�饤�֥���Ʊ��������ˤʤ�
�Ƥ��ޤ��������Υ������Ϻ��ޤǤ������ǤۤȤ������Ǥ����
�פ��ޤ���

Ruby�������

  class.c
  error.c
  eval.c
  gc.c
  object.c
  parse.y
  variable.c

�桼�ƥ���ƥ��ؿ�

  dln.c
  regex.c
  st.c
  util.c

Ruby���ޥ�ɤμ���

  dmyext.c
  inits.c
  main.c
  ruby.c
  version.c

���饹�饤�֥��

  array.c
  bignum.c
  compar.c
  dir.c
  enum.c
  file.c
  hash.c
  io.c
  marshal.c
  math.c
  numeric.c
  pack.c
  prec.c
  process.c
  random.c
  range.c
  re.c
  signal.c
  sprintf.c
  string.c
  struct.c
  time.c

Appendix B. ��ĥ�Ѵؿ���ե����

C���줫��Ruby�ε�ǽ�����Ѥ���API�ϰʲ����̤�Ǥ��롥

** ��

VALUE

  Ruby���֥������Ȥ�ɽ�����뷿��ɬ�פ˱����ƥ��㥹�Ȥ����Ѥ��롥
  �Ȥ߹��߷���ɽ������C�η���ruby.h�˵��Ҥ��Ƥ���R�ǻϤޤ빽¤
  �ΤǤ��롥VALUE���򤳤��˥��㥹�Ȥ��뤿���R�ǻϤޤ빽¤��
  ̾��������ʸ���ˤ���̾���Υޥ������Ѱդ���Ƥ��롥

** �ѿ������

Qnil

  ���: nil���֥�������

Qtrue

  ���: true���֥�������(���Υǥե������)

Qfalse

  ���: false���֥�������

** C�ǡ����Υ��ץ��벽

Data_Wrap_Struct(VALUE klass, void (*mark)(), void (*free)(), void *sval)

  C��Ǥ�դΥݥ��󥿤򥫥ץ��벽����Ruby���֥������Ȥ��֤�����
  �Υݥ��󥿤�Ruby���饢����������ʤ��ʤä�����free�ǻ��ꤷ��
  �ؿ����ƤФ�롥�ޤ������Υݥ��󥿤λؤ��ǡ�����¾��Ruby����
  �������Ȥ�ؤ��Ƥ����硤mark�˻��ꤹ��ؿ��ǥޡ�������ɬ��
  �����롥

Data_Make_Struct(klass, type, mark, free, sval)

  type���Υ����malloc�����ѿ�sval�����������塤����򥫥ץ�
  �벽�����ǡ������֤��ޥ�����

Data_Get_Struct(data, type, sval)

  data����type���Υݥ��󥿤���Ф��ѿ�sval����������ޥ�����

** �������å�

TYPE(value)
FIXNUM_P(value)
NIL_P(value)
void Check_Type(VALUE value, int type)
void Check_SafeStr(VALUE value)

** ���Ѵ�

FIX2INT(value)
FIX2LONG(value)
INT2FIX(i)
NUM2INT(value)
NUM2LONG(value)
INT2NUM(i)
NUM2DBL(value)
rb_float_new(f)
StringValue(value)
StringValuePtr(value)
StringValueCStr(value)
rb_str_new2(s)

** ���饹/�⥸�塼�����

VALUE rb_define_class(const char *name, VALUE super)

  super�Υ��֥��饹�Ȥ��ƿ�����Ruby���饹��������롥

VALUE rb_define_class_under(VALUE module, const char *name, VALUE super)

  super�Υ��֥��饹�Ȥ��ƿ�����Ruby���饹���������module��
  ����Ȥ���������롥

VALUE rb_define_module(const char *name)

  ������Ruby�⥸�塼���������롥

VALUE rb_define_module_under(VALUE module, const char *name)

  ������Ruby�⥸�塼����������module������Ȥ���������롥

void rb_include_module(VALUE klass, VALUE module)

  �⥸�塼��򥤥󥯥롼�ɤ��롥class�����Ǥ�module�򥤥�
  �롼�ɤ��Ƥ�����ˤϲ��⤷�ʤ�(¿�ť��󥯥롼�ɤζػ�)��

void rb_extend_object(VALUE object, VALUE module)

  ���֥������Ȥ�⥸�塼��(���������Ƥ���᥽�å�)�dz�ĥ���롥

** ����ѿ����

void rb_define_variable(const char *name, VALUE *var)

  Ruby��C�ȤǶ�ͭ���륰�����Х��ѿ���������롥�ѿ�̾��`$'��
  �Ϥޤ�ʤ����ˤϼ�ưŪ���ɲä���롥name�Ȥ���Ruby�μ��̻�
  �Ȥ��Ƶ�����ʤ�ʸ��(�㤨��` ')��ޤ���ˤ�Ruby�ץ�����
  �फ��ϸ����ʤ��ʤ롥

void rb_define_readonly_variable(const char *name, VALUE *var)

  Ruby��C�ȤǶ�ͭ����read only�Υ������Х��ѿ���������롥
  read only�Ǥ��뤳�Ȱʳ���rb_define_variable()��Ʊ����

void rb_define_virtual_variable(const char *name,
				VALUE (*getter)(), void (*setter)())

  �ؿ��ˤ�äƼ¸������Ruby�ѿ���������롥�ѿ������Ȥ��줿
  ���ˤ�getter�����ѿ����ͤ����åȤ��줿���ˤ�setter���ƤФ�
  �롥

void rb_define_hooked_variable(const char *name, VALUE *var,
			       VALUE (*getter)(), void (*setter)())

  �ؿ��ˤ�ä�hook�ΤĤ���줿�������Х��ѿ���������롥�ѿ�
  �����Ȥ��줿���ˤ�getter�����ؿ����ͤ����åȤ��줿���ˤ�
  setter���ƤФ�롥getter��setter��0����ꤷ�����ˤ�hook��
  ���ꤷ�ʤ��Τ�Ʊ�����ˤʤ롥

void rb_global_variable(VALUE *var)

  GC�Τ��ᡤRuby�ץ�����फ��ϥ�����������ʤ���, Ruby����
  �������Ȥ�ޤ�����ѿ���ޡ������롥

** ���

void rb_define_const(VALUE klass, const char *name, VALUE val)

  �����������롥

void rb_define_global_const(const char *name, VALUE val)

  ��������������롥

     rb_define_const(rb_cObject, name, val)

  ��Ʊ����̣��

** �᥽�å����

rb_define_method(VALUE klass, const char *name, VALUE (*func)(), int argc)

  �᥽�åɤ�������롥argc��self����������ο���argc��-1�λ�, 
  �ؿ��ˤϰ����ο�(self��ޤޤʤ�)����1����, �������������2
  �����Ȥ��������Ϳ������(��3������self)��argc��-2�λ�, 
  ��1������self, ��2������args(args�ϰ�����ޤ�Ruby������)��
  ����������Ϳ�����롥
 
rb_define_private_method(VALUE klass, const char *name, VALUE (*func)(), int argc)

  private�᥽�åɤ�������롥������rb_define_method()��Ʊ����

rb_define_singleton_method(VALUE klass, const char *name, VALUE (*func)(), int argc)

  �ðۥ᥽�åɤ�������롥������rb_define_method()��Ʊ����

rb_scan_args(int argc, VALUE *argv, const char *fmt, ...)

  argc, argv������Ϳ����줿������ʬ�򤹤롥fmt��ɬ�ܰ����ο�, 
  �ղð����ο�, �Ĥ�ΰ��������뤫����ꤹ��ʸ�����, "����
  ����*"�Ȥ��������Ǥ��롥 2 ���ܤο�����"*"�Ϥ��줾���ά��
  ǽ�Ǥ��롥ɬ�ܰ�������Ĥ�ʤ�����0����ꤹ�롥��3������
  �ߤ��ѿ��ؤΥݥ��󥿤�, �����������Ǥ������ѿ��˳�Ǽ����롥
  �ղð������б����������Ϳ�����Ƥ��ʤ������ѿ���Qnil��
  ��������롥

** Ruby�᥽�åɸƤӽФ�

VALUE rb_funcall(VALUE recv, ID mid, int narg, ...)

  �᥽�åɸƤӽФ���ʸ���󤫤�mid�����뤿��ˤ�rb_intern()��
  �Ȥ���

VALUE rb_funcall2(VALUE recv, ID mid, int argc, VALUE *argv)

  �᥽�åɸƤӽФ���������argc, argv�������Ϥ���

VALUE rb_eval_string(const char *str)

  ʸ�����Ruby������ץȤȤ��ƥ���ѥ��롦�¹Ԥ��롥

ID rb_intern(const char *name)

  ʸ������б�����ID���֤���

char *rb_id2name(ID id)

  ID���б�����ʸ������֤�(�ǥХå���)��

char *rb_class2name(VALUE klass)

  ���饹��̾�����֤�(�ǥХå���)�����饹��̾��������ʤ�����
  ��, ������̤ä�̾������ĥ��饹��̾�����֤���

int rb_respond_to(VALUE obj, ID id)

  obj��id�Ǽ������᥽�åɤ���Ĥ��ɤ������֤���

** ���󥹥����ѿ�

VALUE rb_iv_get(VALUE obj, const char *name)

  obj�Υ��󥹥����ѿ����ͤ����롥`@'�ǻϤޤ�ʤ����󥹥���
  ���ѿ��� Ruby�ץ�����फ�饢�������Ǥ��ʤ��ֱ��줿�ץ���
  �������ѿ��ˤʤ롥�������ʸ����̾������ĥ��饹(�ޤ���
  �⥸�塼��)�Υ��󥹥����ѿ��Ȥ��Ƽ�������Ƥ��롥

VALUE rb_iv_set(VALUE obj, const char *name, VALUE val)

  obj�Υ��󥹥����ѿ���val�˥��åȤ��롥

** ���湽¤

VALUE rb_iterate(VALUE (*func1)(), VALUE arg1, VALUE (*func2)(), VALUE arg2)

  func2��֥��å��Ȥ������ꤷ, func1�򥤥ƥ졼���Ȥ��ƸƤ֡� 
  func1�ˤ� arg1�������Ȥ����Ϥ���, func2�ˤ���1�����˥��ƥ졼
  ������Ϳ����줿��, ��2������arg2���Ϥ���롥
 
VALUE rb_yield(VALUE val)

  val���ͤȤ��ƥ��ƥ졼���֥��å���ƤӽФ���

VALUE rb_rescue(VALUE (*func1)(), VALUE arg1, VALUE (*func2)(), VALUE arg2)

  �ؿ�func1��arg1������˸ƤӽФ���func1�μ¹�����㳰��ȯ��
  �������ˤ� func2��arg2������Ȥ��ƸƤ֡�����ͤ��㳰��ȯ��
  ���ʤ��ä�����func1�������, �㳰��ȯ���������ˤ�func2����
  ���ͤǤ��롥

VALUE rb_ensure(VALUE (*func1)(), VALUE arg1, void (*func2)(), VALUE arg2)

  �ؿ�func1��arg1������Ȥ��Ƽ¹Ԥ�, �¹Խ�λ��(���Ȥ��㳰��
  ȯ�����Ƥ�) func2��arg2������Ȥ��Ƽ¹Ԥ��롥����ͤ�func1
  ������ͤǤ���(�㳰��ȯ�������������ʤ�)��

** �㳰�����顼

void rb_warning(const char *fmt, ...)

  rb_verbose����ɸ�२�顼���Ϥ˷ٹ�����ɽ�����롥������
  printf()��Ʊ����

void rb_raise(rb_eRuntimeError, const char *fmt, ...)

  RuntimeError�㳰��ȯ�������롥������printf()��Ʊ����

void rb_raise(VALUE exception, const char *fmt, ...)

  exception�ǻ��ꤷ���㳰��ȯ�������롥fmt�ʲ��ΰ�����
  printf()��Ʊ����

void rb_fatal(const char *fmt, ...)

  ��̿Ū�㳰��ȯ�������롥�̾���㳰�����ϹԤʤ�줺, ���󥿡�
  �ץ꥿����λ����(������ensure�ǻ��ꤵ�줿�����ɤϽ�λ����
  �¹Ԥ����)��

void rb_bug(const char *fmt, ...)

  ���󥿡��ץ꥿�ʤɥץ������ΥХ��Ǥ���ȯ������Ϥ��Τʤ�
  �����λ��Ƥ֡����󥿡��ץ꥿�ϥ�������פ�ľ���˽�λ���롥
  �㳰�����ϰ��ڹԤʤ��ʤ���

** Ruby�ν�������¹�

Ruby�򥢥ץꥱ����������������ˤϰʲ��Υ��󥿥ե�����
��Ȥ����̾�γ�ĥ�饤�֥��ˤ�ɬ�פʤ���

void ruby_init()

  Ruby���󥿥ץ꥿�ν������Ԥʤ���

void ruby_options(int argc, char **argv)

  Ruby���󥿥ץ꥿�Υ��ޥ�ɥ饤������ν�����Ԥʤ���

void ruby_run()

  Ruby���󥿥ץ꥿��¹Ԥ��롥

void ruby_script(char *name)

  Ruby�Υ�����ץ�̾($0)�����ꤹ�롥

** ���󥿥ץ꥿�Υ��٥�ȤΥեå�

 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_t events)

���ꤵ�줿���󥿥ץ꥿�Υ��٥�Ȥ��Ф���եå��ؿ����ɲä��ޤ���
events�ϰʲ����ͤ�or�Ǥʤ���Фʤ�ޤ���:

	RUBY_EVENT_LINE
	RUBY_EVENT_CLASS
	RUBY_EVENT_END
	RUBY_EVENT_CALL
	RUBY_EVENT_RETURN
	RUBY_EVENT_C_CALL
	RUBY_EVENT_C_RETURN
	RUBY_EVENT_RAISE
	RUBY_EVENT_ALL

rb_event_hook_func_t������ϰʲ����̤�Ǥ�:

 typedef void (*rb_event_hook_func_t)(rb_event_t event, NODE *node,
 				      VALUE self, ID id, VALUE klass)

 int rb_remove_event_hook(rb_event_hook_func_t func)

���ꤵ�줿�եå��ؿ��������ޤ���


Appendix C. extconf.rb�ǻȤ���ؿ�����

extconf.rb����Ǥ����Ѳ�ǽ�ʥ���ѥ���������å��δؿ��ϰ�
�����̤�Ǥ��롥

have_macro(macro, headers)

  �إå��ե�����header�򥤥󥯥롼�ɤ��ƥޥ���macro�������
  ��Ƥ��뤫�ɤ��������å����롥�ޥ������������Ƥ����true
  ���֤���

have_library(lib, func)

  �ؿ�func��������Ƥ���饤�֥��lib��¸�ߤ�����å����롥
  �饤�֥�꤬¸�ߤ������true���֤���

find_library(lib, func, path...)

  �ؿ�func��������Ƥ���饤�֥��lib��¸�ߤ� -Lpath ���ɲ�
  ���ʤ�������å����롥�饤�֥�꤬���դ��ä�����true���֤���

have_func(func, header)

  �إå��ե�����header�򥤥󥯥롼�ɤ��ƴؿ�func��¸�ߤ����
  �å����롥func��ɸ��Ǥϥ�󥯤���ʤ��饤�֥����Τ�Τ�
  ������ˤ����have_library�Ǥ��Υ饤�֥�������å����Ƥ�
  �������ؿ���¸�ߤ����true���֤���

have_var(var, header)

  �إå��ե�����header�򥤥󥯥롼�ɤ����ѿ�var��¸�ߤ������
  �����롥var��ɸ��Ǥϥ�󥯤���ʤ��饤�֥����Τ�ΤǤ�
  ����ˤ����have_library�Ǥ��Υ饤�֥�������å����Ƥ���
  �����ѿ���¸�ߤ����true���֤���

have_header(header)

  �إå��ե������¸�ߤ�����å����롥�إå��ե����뤬¸�ߤ�
  ���true���֤���

find_header(header, path...)

  �إå��ե�����header��¸�ߤ� -Ipath ���ɲä��ʤ�������å�
  ���롥�إå��ե����뤬���դ��ä�����true���֤���

have_struct_member(type, member, header)

  �إå��ե�����header�򥤥󥯥롼�ɤ��Ʒ�type�˥���member
  ��¸�ߤ��뤫������å����롥type���������Ƥ��ơ�member��
  ���Ĥ����true���֤���

have_type(type, header, opt)

  �إå��ե�����header�򥤥󥯥롼�ɤ��Ʒ�type��¸�ߤ��뤫��
  �����å����롥type���������Ƥ����true���֤���

check_sizeof(type, header)

  �إå��ե�����header�򥤥󥯥롼�ɤ��Ʒ�type��charñ�̥���
  ����Ĵ�٤롥type���������Ƥ�������Υ��������֤��������
  ��Ƥ��ʤ��Ȥ���nil���֤���

create_makefile(target)

  ��ĥ�饤�֥���Ѥ�Makefile���������롥���δؿ���ƤФʤ���
  �Ф��Υ饤�֥��ϥ���ѥ��뤵��ʤ���target�ϥ⥸�塼��̾
  ��ɽ����

find_executable(command, path)

  ���ޥ��command��File::PATH_SEPARATOR�Ƕ��ڤ�줿�ѥ�̾��
  �ꥹ��path����õ����path��nil�ޤ��Ͼ�ά���줿���ϡ��Ķ�
  �ѿ�PATH���ͤ���Ѥ��롥�¹Բ�ǽ�ʥ��ޥ�ɤ����Ĥ��ä����
  �ϥѥ���ޤ�ե�����̾�����Ĥ���ʤ��ä�����nil���֤���

with_config(withval[, default=nil])

  ���ޥ�ɥ饤����--with-<withval>�ǻ��ꤵ�줿���ץ������
  �����롥

enable_config(config, *defaults)
disable_config(config, *defaults)

  ���ޥ�ɥ饤����--enable-<config>�ޤ���
  --disable-<config>�ǻ��ꤵ�줿�����ͤ����롥
  --enable-<config>�����ꤵ��Ƥ�������true��
  --disable-<config>�����ꤵ��Ƥ�������false���֤���
  �ɤ������ꤵ��Ƥ��ʤ����ϡ��֥��å��Ĥ��ǸƤӽФ����
  �������*defaults��yield������̡��֥��å��ʤ��ʤ�
  *defaults���֤���

dir_config(target[, default_dir])
dir_config(target[, default_include, default_lib])

  ���ޥ�ɥ饤����--with-<target>-dir, --with-<target>-include,
  --with-<target>-lib�Τ����줫�ǻ��ꤵ���ǥ��쥯�ȥ��
  $CFLAGS �� $LDFLAGS ���ɲä��롥--with-<target>-dir=/path��
  --with-<target>-include=/path/include --with-<target>-lib=/path/lib
  �������Ǥ��롥�ɲä��줿 include �ǥ��쥯�ȥ�� lib �ǥ���
  ���ȥ��������֤��� ([include_dir, lib_dir])

pkg_config(pkg)

  pkg-config���ޥ�ɤ���ѥå�����pkg�ξ�������롥 
  pkg-config�μºݤΥ��ޥ��̾�ϡ�--with-pkg-config���ޥ��
  �饤�󥪥ץ����ǻ����ǽ��

/*
 * Local variables:
 * fill-column: 60
 * end:
 */