Hacked By AnonymousFox

Current Path : /proc/thread-self/root/opt/alt/ruby19/share/doc/alt-ruby19/
Upload File :
Current File : //proc/thread-self/root/opt/alt/ruby19/share/doc/alt-ruby19/README.EXT.ja

.\" 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_HASH		Ϣ������
	T_STRUCT	(Ruby��)��¤��
	T_BIGNUM	¿��Ĺ����
	T_FIXNUM	Fixnum(31bit�ޤ���63bitĹ����)
	T_COMPLEX	ʣ�ǿ�
	T_RATIONAL	ͭ���
	T_FILE		�����
	T_TRUE		��
	T_FALSE		��
	T_DATA		�ǡ���
	T_SYMBOL	����ܥ�

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

	T_ICLASS
	T_MATCH
	T_UNDEF
	T_NODE
	T_ZOMBIE

�ۤȤ�ɤΥ����פ�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* ����Ф���硤 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)
  rb_str_new_cstr(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)
  rb_tainted_str_new_cstr(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_enc_str_new(const char *ptr, long len, rb_encoding *enc)
  
    ���ꤵ�줿���󥳡��ǥ��󥰤�Ruby��ʸ����������.
     
  rb_usascii_str_new(const char *ptr, long len)
  rb_usascii_str_new_cstr(const char *ptr)

    ���󥳡��ǥ��󥰤�US-ASCII��Ruby��ʸ����������.

  rb_str_resize(VALUE str, long len)

    Ruby��ʸ����Υ�������len�Х��Ȥ��ѹ����롥str��Ĺ�����
    �ʤƥ��åȤ���Ƥ��ʤ���Фʤ�ʤ���len������Ĺ������û
    �����ϡ�len�Х��Ȥ�ۤ�����ʬ�����ƤϼΤƤ��롥len����
    ��Ĺ������Ĺ�����ϡ�����Ĺ����ۤ�����ʬ�����Ƥ���¸��
    ��ʤ��ǥ��ߤˤʤ��������δؿ�θƤӽФ��ˤ�ä�
    RSTRING_PTR(str)���ѹ�����뤫�⤷��ʤ����Ȥ���ա�

  rb_str_set_len(VALUE str, long len)

    Ruby��ʸ����Υ�������len�Х��Ȥ˥��åȤ��롥str���ѹ���
    ǽ�Ǥʤ�����㳰��ȯ�����롥RSTRING_LEN(str)�Ȥ�̵�ط��ˡ�
    len�Х��ȤޤǤ����Ƥ���¸����롥len��str�����̤�ۤ��Ƥ�
    �ƤϤʤ�ʤ���


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

  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_to_ary(VALUE obj)

    ���֥������Ȥ�������Ѵ�����.
    Object#to_ary��Ʊ��Ǥ���.

 ¾�ˤ���������ؿ�¿���. ������
 ����ary��������Ϥ��ʤ���Фʤ�ʤ�. ����ʤ���
 �������Ǥ�.

  rb_ary_aref(argc, VALUE *argv, VALUE ary)

    Array#[]��Ʊ�.

  rb_ary_entry(VALUE ary, long offset)

    ary[offset]

  rb_ary_subseq(VALUE ary, long beg, long len)

    ary[beg, len]

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

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������Ȥ����Ϥ���ޤ���

�᥽�åɤ�������ؿ�Ϥޤ������Ĥ�����ޤ�. �ҤȤĤϥ᥽�å�
̾�Ȥ���ID����ޤ�. ID�ˤĤ��Ƥ�2.2.2�򻲾�.

  void rb_define_method_id(VALUE klass, ID name, 
                           VALUE (*func)(ANYARGS), int argc)

private/protected�ʥ᥽�åɤ�������դ��Ĥδؿ����ޤ�.

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

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

�Ǹ�ˡ� rb_define_module�ؿ�ϥ⥸�塼��ؿ�������ޤ���
�⥸�塼��ؿ�Ȥϥ⥸�塼����ðۥ᥽�åɤǤ��ꡤƱ����
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);

°���μ��������᥽�åɤ�������ˤ�

  void rb_define_attr(VALUE klass, const char *name, int read, int write)

���饹�᥽�å�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)

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

ɾ�����㳰��ȯ�����뤫�⤷��ʤ����Ȥ���դ��ޤ��礦. �����
�ʴؿ�⤢��ޤ�.

  VALUE rb_eval_string_protect(const char *str, int *state)

���δؿ�ϥ��顼��ȯ�������nil���֤��ޤ��������ơ��������ˤ�
*state�ϥ���ˡ�����ʤ����󥼥�ˤʤ�ޤ���


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()��Ʊ���ˤʤ롥

getter��setter�λ��ͤϼ����̤�Ǥ���

  VALUE (*getter)(ID id, VALUE *var);
  void (*setter)(VALUE val, ID id, VALUE *var);


���줫�顤�б�����C���ѿ����ʤ�Ruby������ѿ��������
���Ȥ�Ǥ��ޤ�. �����ѿ���ͤϥեå��ؿ�Τߤˤ�äƼ��������
����ޤ�.

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

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

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

  (*getter)(ID id);
  (*setter)(VALUE val, ID id);

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�פȤ����ե�����
�Ȥ����ͤ��뤫��Ǥ����ޤ�����Ҥ��� mkmf �饤�֥��Τ�����
���δؿ����ѥ�����פ���ƥ��ȤΤ���ˡ�conftest.c�פȤ�
���ե�����̾����Ѥ��뤳�Ȥ���դ��Ƥ����������������ե�����
̾�Ȥ��ơ�conftest.c�פ���Ѥ��ƤϤʤ�ޤ���

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�ѿ�ʹߤ˻��ꤷ��VALUE�ؤλ��Ȥ��ͤ�������Ƥ����
����


�����Ruby������Ȥ��Ƽ������᥽�åɤ���ˤ�
Thread#initialize������ޤ�������Ϥ����Ǥ���

--
static VALUE
thread_initialize(VALUE thread, 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         : �㳰���饹���㳰����
  gc.c            : �������
  load.c          : �饤�֥��Υ���
  object.c        : ���֥�������
  variable.c      : �ѿ�����

Ruby�ι�ʸ��ϴ�
  parse.y         : �����ϴ�ȹ�ʸ��
    -> parse.c    : ��ư����
  keywords        : ͽ���
    -> lex.c      : ��ư����

Ruby��ɾ���� (�̾�YARV)
  compile.c
  eval.c
  eval_error.c
  eval_jump.c
  eval_safe.c
  insns.def           : ���۵��������
  iseq.c              : VM::ISeq��
  thread.c            : ����åɴ���ȥ���ƥ�����ڤ��ؤ�
  thread_win32.c      : ����åɼ��
  thread_pthread.c    : Ʊ��
  vm.c
  vm_dump.c
  vm_eval.c
  vm_exec.c
  vm_insnhelper.c
  vm_method.c

  opt_insns_unif.def  : ̿��ͻ��
  opt_operand.def     : ��Ŭ���Τ������

    -> insn*.inc      : ��ư����
    -> opt*.inc       : ��ư����
    -> vm.inc         : ��ư����

����ɽ�����󥸥� (����)
  regex.c
  regcomp.c
  regenc.c
  regerror.c
  regexec.c
  regparse.c
  regsyntax.c

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

  debug.c       : C�ǥХå��ѤΥǥХå�����ܥ�
  dln.c         : ưŪ���ǥ���
  st.c          : ���ѥϥå���ɽ
  strftime.c    : ������
  util.c        : ����¾�Υ桼�ƥ���ƥ�

Ruby���ޥ�ɤμ��

  dmyext.c
  dmydln.c
  dmyencoding.c
  id.c
  inits.c
  main.c
  ruby.c
  version.c

  gem_prelude.rb
  prelude.rb

���饹�饤�֥��

  array.c       : Array
  bignum.c      : Bignum
  compar.c      : Comparable
  complex.c     : Complex
  cont.c        : Fiber, Continuation
  dir.c         : Dir
  enum.c        : Enumerable
  enumerator.c  : Enumerator
  file.c        : File
  hash.c        : Hash
  io.c          : IO
  marshal.c     : Marshal
  math.c        : Math
  numeric.c     : Numeric, Integer, Fixnum, Float
  pack.c        : Array#pack, String#unpack
  proc.c        : Binding, Proc
  process.c     : Process
  random.c      : ���
  range.c       : Range
  rational.c    : Rational
  re.c          : Regexp, MatchData
  signal.c      : Signal
  sprintf.c     : 
  string.c      : String
  struct.c      : Struct
  time.c        : Time

  defs/known_errors.def  : �㳰���饹 Errno::*
    -> known_errors.inc  : ��ư����

¿���첽
  encoding.c    : Encoding
  transcode.c   : Encoding::Converter
  enc/*.c       : ���󥳡��ǥ��󥰥��饹��
  enc/trans/*   : �����ɥݥ�����б�ɽ

goruby���ޥ�ɤμ��
  
  goruby.c
  golf_prelude.rb      : goruby��ͭ�Υ饤�֥��
    -> golf_prelude.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), INT2FIX(i)
FIX2LONG(value), LONG2FIX(l)
NUM2INT(value), INT2NUM(i)
NUM2UINT(value), UINT2NUM(ui)
NUM2LONG(value), LONG2NUM(l)
NUM2ULONG(value), ULONG2NUM(ul)
NUM2LL(value), LL2NUM(ll)
NUM2ULL(value), ULL2NUM(ull)
NUM2OFFT(value), OFFT2NUM(off)
NUM2SIZET(value), SIZET2NUM(size)
NUM2SSIZET(value), SSIZET2NUM(ssize)
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������Ϳ����줿���ꤵ�줿�ե����ޥåȤ˽��äư�
  ���ʬ�򤷡�³��VALUE�ؤλ��Ȥ˥��åȤ��ޤ������Υե����ޥ�
  �Ȥϡ�ABNF�ǵ��Ҥ���Ȱʲ����̤�Ǥ���

--
scan-arg-spec  := param-arg-spec [option-hash-arg-spec] [block-arg-spec]

param-arg-spec := pre-arg-spec [post-arg-spec] / post-arg-spec / pre-opt-post-arg-spec
pre-arg-spec   := num-of-leading-mandatory-args [num-of-optional-args]
post-arg-spec  := sym-for-variable-length-args [num-of-trailing-mandatory-args]
pre-opt-post-arg-spec := num-of-leading-mandatory-args num-of-optional-args num-of-trailing-mandatory-args
option-hash-arg-spec := sym-for-option-hash-arg
block-arg-spec := sym-for-block-arg

num-of-leading-mandatory-args  := DIGIT ; ��Ƭ���֤�����ά��ǽ�ʰ���ο�
num-of-optional-args           := DIGIT ; ³�����֤�����ά��ǽ�ʰ���ο�
sym-for-variable-length-args   := "*"   ; ³�����֤�������Ĺ�����
                                        ; Ruby������Ǽ�����뤿��λ���
num-of-trailing-mandatory-args := DIGIT ; ��ü���֤�����ά��ǽ�ʰ���ο�
sym-for-option-hash-arg        := ":"   ; ���ץ����ϥå����������
                                        ; ����λ���; ��ά��ǽ�ʰ����
                                        ; �����¿���ΰ�����ꤵ�졤
                                        ; �Ǹ�ΰ���ϥå���ʤޤ���
                                        ; #to_hash���Ѵ���ǽ�ˤξ���
                                        ; �������롥�Ǹ�ΰ���nil��
                                        ; ��硤����Ĺ������꤬�ʤ���
                                        ; ��ά��ǽ����ο����¿����
                                        ; ������ꤵ�줿���˼�������
sym-for-block-arg              := "&"   ; ���ƥ졼���֥�å��������뤿���
                                        ; ����
--

  �ե����ޥåȤ�"12"�ξ�硤����Ϻ���1�Ĥǡ�3��(1+2)�ޤǵ���
  ���Ȥ�����̣�ˤʤ�ޤ������äơ��ե����ޥå�ʸ�����³��
  ��3�Ĥ�VALUE�ؤλ��Ȥ��֤�ɬ�פ�����ޤ��������ˤϼ������
  �ѿ���åȤ���ޤ����ѿ�ؤλ��Ȥ������NULL����ꤹ��
  ���Ȥ�Ǥ������ξ��ϼ������������ͤϼΤƤ��ޤ����ʤ���
  ��ά��ǽ�����ά���줿�����ѿ���ͤ�nil(C����Υ�٥�Ǥ�
  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_block_call(VALUE obj, ID mid, int argc, VALUE * argv,
		    VALUE (*func) (ANYARGS), VALUE data2)

  func��֥�å��Ȥ�����ꤷ��obj��쥷���С�argc��argv���
  �Ȥ���mid�᥽�åɤ�ƤӽФ���func��������yield���줿�͡�
  ������data2�����롥ʣ����ͤ�yield���줿���(C�Ǥ�
  rb_yield_values()��rb_yield_values2(), rb_yield_splat())��
  data2��Array�Ȥ��ƥѥå�����Ƥ��롥�軰, ��Ͱ����argc��
  argv�ˤ�ä�yield���줿�ͤ���Ф����Ȥ��Ǥ��롥

[OBSOLETE] VALUE rb_iterate(VALUE (*func1)(), VALUE arg1, VALUE (*func2)(), VALUE arg2)

  func2��֥�å��Ȥ�����ꤷ, func1�򥤥ƥ졼���Ȥ��ƸƤ֡� 
  func1�ˤ� arg1������Ȥ����Ϥ���, func2�ˤ���1����˥��ƥ졼
  ������Ϳ����줿��, ��2�����arg2���Ϥ���롥
 
  1.9��rb_iterate��Ȥ�����, func1�����Ruby��٥�Υ᥽�å�
  ��ƤӽФ��ʤ���Фʤ�ʤ�.
  1.9��obsolete�Ȥʤä�. �����rb_block_call���Ѱդ��줿.

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, VALUE (*func2)(), VALUE arg2)

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

VALUE rb_protect(VALUE (*func) (VALUE), VALUE arg, int *state)

  �ؿ�func��arg���Ȥ��Ƽ¹Ԥ�, �㳰��ȯ�����ʤ���Ф�����
  ���ͤ��֤����㳰��ȯ����������, *state����0�򥻥åȤ���
  Qnil���֤���

void rb_jump_tag(int state)

  rb_protect()��rb_eval_string_protect()����ª���줿�㳰���
  �����롥state�Ϥ����δؿ���֤��줿�ͤǤʤ���Фʤ�ʤ���
  ���δؿ��ľ�ܤθƤӽФ��������ʤ���

** �㳰�����顼

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_flag_t events, VALUE data)

���ꤵ�줿���󥿥ץ꥿�Υ��٥�Ȥ��Ф���եå��ؿ���ɲä��ޤ���
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, VALUE data,
 				      VALUE self, ID id, VALUE klass)

rb_add_event_hook() ����3���� data �ϡ��եå��ؿ����2�����
�����Ϥ���ޤ��������1.8�Ǥϸ��ߤ�NODE�ؤΥݥ��󥿤Ǥ�������
���� RB_EVENT_HOOKS_HAVE_CALLBACK_DATA �⻲�Ȥ��Ƥ���������

 int rb_remove_event_hook(rb_event_hook_func_t func)

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

** �ߴ����Τ���Υޥ���

API�θߴ�������å����뤿��˰ʲ��Υޥ����ǥե���Ȥ�������Ƥ��ޤ���

NORETURN_STYLE_NEW

  NORETURN �ޥ����ؿ�ޥ���Ȥ���������Ƥ��뤳�Ȥ��̣���롥

HAVE_RB_DEFINE_ALLOC_FUNC

  rb_define_alloc_func() �ؿ��󶡤���Ƥ��뤳�ȡ��Ĥޤ�
  allocation framework ���Ȥ��뤳�Ȥ��̣���롥
  have_func("rb_define_alloc_func", "ruby.h")
  �η�̤�Ʊ����

HAVE_RB_REG_NEW_STR

  String���֥������Ȥ���Regexp���֥������Ȥ���
  rb_reg_new_str() �ؿ��󶡤���Ƥ��뤳�Ȥ��̣���롥
  have_func("rb_reg_new_str", "ruby.h").
  �η�̤�Ʊ����

HAVE_RB_IO_T

  rb_io_t �����󶡤���Ƥ��뤳�Ȥ��̣���롥

USE_SYMBOL_AS_METHOD_NAME

  �᥽�å�̾���֤��᥽�åɡ�Module#methods, #singleton_methods
  �ʤɤ�Symbol���֤����Ȥ��̣���롥

HAVE_RUBY_*_H

  ruby.h ��������Ƥ��롥�б�����إå����󶡤���Ƥ��뤳��
  ���̣���롥���Ȥ��С�HAVE_RUBY_ST_H ��������Ƥ������
  ñ�ʤ� st.h �ǤϤʤ� ruby/st.h ����Ѥ��롥

RB_EVENT_HOOKS_HAVE_CALLBACK_DATA

  rb_add_event_hook() ���եå��ؿ���Ϥ� data ����3����Ȥ���
  ������뤳�Ȥ��̣���롥

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

Hacked By AnonymousFox1.0, Coded By AnonymousFox