Index: complex.c
===================================================================
--- complex.c	(revision 2107)
+++ complex.c	(working copy)
@@ -309,7 +309,7 @@
 }
 
 static VALUE
-nucomp_s_generic_p(VALUE klass, VALUE x)
+nucomp_s_generic_p(VALUE klass, SEL sel, VALUE x)
 {
     return f_generic_p(x);
 }
@@ -342,7 +342,7 @@
 }
 
 static VALUE
-nucomp_s_new_bang(int argc, VALUE *argv, VALUE klass)
+nucomp_s_new_bang(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE real, image;
 
@@ -448,7 +448,7 @@
 #endif
 
 static VALUE
-nucomp_s_new(int argc, VALUE *argv, VALUE klass)
+nucomp_s_new(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE real, image;
 
@@ -479,7 +479,7 @@
 }
 
 static VALUE
-nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
+nucomp_f_complex(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     return rb_funcall2(rb_cComplex, id_convert, argc, argv);
 }
@@ -564,7 +564,7 @@
 }
 
 static VALUE
-nucomp_s_polar(VALUE klass, VALUE abs, VALUE arg)
+nucomp_s_polar(VALUE klass, SEL sel, VALUE abs, VALUE arg)
 {
     return f_complex_new2(klass,
 			  f_mul(abs, m_cos(arg)),
@@ -572,21 +572,21 @@
 }
 
 static VALUE
-nucomp_real(VALUE self)
+nucomp_real(VALUE self, SEL sel)
 {
     get_dat1(self);
     return dat->real;
 }
 
 static VALUE
-nucomp_image(VALUE self)
+nucomp_image(VALUE self, SEL sel)
 {
     get_dat1(self);
     return dat->image;
 }
 
 static VALUE
-nucomp_add(VALUE self, VALUE other)
+nucomp_add(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -616,7 +616,7 @@
 }
 
 static VALUE
-nucomp_sub(VALUE self, VALUE other)
+nucomp_sub(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -646,7 +646,7 @@
 }
 
 static VALUE
-nucomp_mul(VALUE self, VALUE other)
+nucomp_mul(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -679,7 +679,7 @@
 }
 
 static VALUE
-nucomp_div(VALUE self, VALUE other)
+nucomp_div(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -715,7 +715,7 @@
 }
 
 static VALUE
-nucomp_quo(VALUE self, VALUE other)
+nucomp_quo(VALUE self, SEL sel, VALUE other)
 {
     get_dat1(self);
 
@@ -725,7 +725,7 @@
 }
 
 static VALUE
-nucomp_fdiv(VALUE self, VALUE other)
+nucomp_fdiv(VALUE self, SEL sel, VALUE other)
 {
     get_dat1(self);
 
@@ -735,7 +735,7 @@
 }
 
 static VALUE
-nucomp_expt(VALUE self, VALUE other)
+nucomp_expt(VALUE self, SEL sel, VALUE other)
 {
     if (f_zero_p(other))
 	return f_complex_new_bang1(CLASS_OF(self), ONE);
@@ -782,7 +782,7 @@
 	    a = f_polar(self);
 	    r = RARRAY_AT(a, 0);
 	    theta = RARRAY_AT(a, 1);
-	    return nucomp_s_polar(CLASS_OF(self), f_expt(r, other),
+	    return nucomp_s_polar(CLASS_OF(self), NULL, f_expt(r, other),
 				  f_mul(theta, other));
 	}
       case T_COMPLEX:
@@ -800,7 +800,7 @@
 	    nr = m_exp_bang(f_sub(f_mul(ore, m_log_bang(r)),
 				  f_mul(oim, theta)));
 	    ntheta = f_add(f_mul(theta, ore), f_mul(oim, m_log_bang(r)));
-	    return nucomp_s_polar(CLASS_OF(self), nr, ntheta);
+	    return nucomp_s_polar(CLASS_OF(self), NULL, nr, ntheta);
 	}
       default:
 	return rb_num_coerce_bin(self, other, id_expt);
@@ -808,7 +808,7 @@
 }
 
 static VALUE
-nucomp_equal_p(VALUE self, VALUE other)
+nucomp_equal_p(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -833,7 +833,7 @@
 }
 
 static VALUE
-nucomp_coerce(VALUE self, VALUE other)
+nucomp_coerce(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -849,14 +849,14 @@
 }
 
 static VALUE
-nucomp_abs(VALUE self)
+nucomp_abs(VALUE self, SEL sel)
 {
     get_dat1(self);
     return m_hypot(dat->real, dat->image);
 }
 
 static VALUE
-nucomp_abs2(VALUE self)
+nucomp_abs2(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_add(f_mul(dat->real, dat->real),
@@ -864,20 +864,20 @@
 }
 
 static VALUE
-nucomp_arg(VALUE self)
+nucomp_arg(VALUE self, SEL sel)
 {
     get_dat1(self);
     return m_atan2_bang(dat->image, dat->real);
 }
 
 static VALUE
-nucomp_polar(VALUE self)
+nucomp_polar(VALUE self, SEL sel)
 {
     return rb_assoc_new(f_abs(self), f_arg(self));
 }
 
 static VALUE
-nucomp_conjugate(VALUE self)
+nucomp_conjugate(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->image));
@@ -913,14 +913,14 @@
 extern VALUE rb_lcm(VALUE x, VALUE y);
 
 static VALUE
-nucomp_denominator(VALUE self)
+nucomp_denominator(VALUE self, SEL sel)
 {
     get_dat1(self);
     return rb_lcm(f_denominator(dat->real), f_denominator(dat->image));
 }
 
 static VALUE
-nucomp_numerator(VALUE self)
+nucomp_numerator(VALUE self, SEL sel)
 {
     VALUE cd;
 
@@ -935,7 +935,7 @@
 }
 
 static VALUE
-nucomp_hash(VALUE self)
+nucomp_hash(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_xor(dat->real, dat->image);
@@ -980,7 +980,7 @@
 }
 
 static VALUE
-nucomp_to_s(VALUE self)
+nucomp_to_s(VALUE self, SEL sel)
 {
     VALUE s, rezero, impos;
 
@@ -1011,7 +1011,7 @@
 }
 
 static VALUE
-nucomp_inspect(VALUE self)
+nucomp_inspect(VALUE self, SEL sel)
 {
     VALUE s;
 
@@ -1027,14 +1027,14 @@
 }
 
 static VALUE
-nucomp_marshal_dump(VALUE self)
+nucomp_marshal_dump(VALUE self, SEL sel)
 {
     get_dat1(self);
     return rb_assoc_new(dat->real, dat->image);
 }
 
 static VALUE
-nucomp_marshal_load(VALUE self, VALUE a)
+nucomp_marshal_load(VALUE self, SEL sel, VALUE a)
 {
     get_dat1(self);
     dat->real = RARRAY_AT(a, 0);
@@ -1056,7 +1056,7 @@
     return nucomp_s_canonicalize_internal(rb_cComplex, x, y);
 }
 
-static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass);
+static VALUE nucomp_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv);
 
 VALUE
 rb_Complex(VALUE x, VALUE y)
@@ -1064,7 +1064,7 @@
     VALUE a[2];
     a[0] = x;
     a[1] = y;
-    return nucomp_s_convert(2, a, rb_cComplex);
+    return nucomp_s_convert(rb_cComplex, NULL, 2, a);
 }
 
 static VALUE
@@ -1113,13 +1113,13 @@
 }
 
 static VALUE
-nilclass_to_c(VALUE self)
+nilclass_to_c(VALUE self, SEL sel)
 {
     return rb_complex_new1(INT2FIX(0));
 }
 
 static VALUE
-numeric_to_c(VALUE self)
+numeric_to_c(VALUE self, SEL sel)
 {
     return rb_complex_new1(self);
 }
@@ -1260,7 +1260,7 @@
 #define f_gsub(x,y,z) rb_funcall(x, id_gsub, 2, y, z)
 
 static VALUE
-string_to_c(VALUE self)
+string_to_c(VALUE self, SEL sel)
 {
     VALUE s = f_gsub(self, underscores_pat, an_underscore);
     VALUE a = string_to_c_internal(s);
@@ -1270,7 +1270,7 @@
 }
 
 static VALUE
-nucomp_s_convert(int argc, VALUE *argv, VALUE klass)
+nucomp_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE a1, a2;
 
@@ -1328,7 +1328,7 @@
 	VALUE argv2[2];
 	argv2[0] = a1;
 	argv2[1] = a2;
-	return nucomp_s_new(argc, argv2, klass);
+	return nucomp_s_new(klass, NULL, argc, argv2);
     }
 }
 
@@ -1337,25 +1337,25 @@
 #define id_Complex rb_intern("Complex")
 
 static VALUE
-numeric_re(VALUE self)
+numeric_re(VALUE self, SEL sel)
 {
     return rb_Complex1(self);
 }
 
 static VALUE
-numeric_im(VALUE self)
+numeric_im(VALUE self, SEL sel)
 {
     return rb_Complex2(ZERO, self);
 }
 
 static VALUE
-numeric_real(VALUE self)
+numeric_real(VALUE self, SEL sel)
 {
     return self;
 }
 
 static VALUE
-numeric_image(VALUE self)
+numeric_image(VALUE self, SEL sel)
 {
     return INT2FIX(0);
 }
@@ -1363,7 +1363,7 @@
 #define id_PI rb_intern("PI")
 
 static VALUE
-numeric_arg(VALUE self)
+numeric_arg(VALUE self, SEL sel)
 {
     if (!f_negative_p(self))
 	return INT2FIX(0);
@@ -1371,13 +1371,13 @@
 }
 
 static VALUE
-numeric_polar(VALUE self)
+numeric_polar(VALUE self, SEL sel)
 {
     return rb_assoc_new(f_abs(self), f_arg(self));
 }
 
 static VALUE
-numeric_conjugate(VALUE self)
+numeric_conjugate(VALUE self, SEL sel)
 {
     return self;
 }
@@ -1425,17 +1425,17 @@
 
     rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric);
 
-    rb_define_alloc_func(rb_cComplex, nucomp_s_alloc);
+    rb_objc_define_method(rb_cComplex, "alloc", nucomp_s_alloc, 0);
 //    rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("allocate")));
 
-    rb_define_singleton_method(rb_cComplex, "generic?", nucomp_s_generic_p, 1);
+    rb_objc_define_method(*(VALUE *)rb_cComplex, "generic?", nucomp_s_generic_p, 2);
 
-    rb_define_singleton_method(rb_cComplex, "new!", nucomp_s_new_bang, -1);
+    rb_objc_define_method(*(VALUE *)rb_cComplex, "new!", nucomp_s_new_bang, -1);
 //    rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("new!")));
 
-    rb_define_singleton_method(rb_cComplex, "new", nucomp_s_new, -1);
+    rb_objc_define_method(*(VALUE *)rb_cComplex, "new", nucomp_s_new, -1);
 //    rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("new")));
 
@@ -1443,9 +1443,9 @@
     rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1);
     rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1);
 #endif
-    rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, 2);
+    rb_objc_define_method(*(VALUE *)rb_cComplex, "polar", nucomp_s_polar, 2);
 
-    rb_define_global_function(COMPLEX_NAME, nucomp_f_complex, -1);
+    rb_objc_define_method(rb_mKernel, COMPLEX_NAME, nucomp_f_complex, -1);
 
     rb_undef_method(rb_cComplex, "<");
     rb_undef_method(rb_cComplex, "<=");
@@ -1465,31 +1465,31 @@
     rb_undef_method(rb_cComplex, "//");
 #endif
 
-    rb_define_method(rb_cComplex, "real", nucomp_real, 0);
-    rb_define_method(rb_cComplex, "image", nucomp_image, 0);
-    rb_define_method(rb_cComplex, "imag", nucomp_image, 0);
+    rb_objc_define_method(rb_cComplex, "real", nucomp_real, 0);
+    rb_objc_define_method(rb_cComplex, "image", nucomp_image, 0);
+    rb_objc_define_method(rb_cComplex, "imag", nucomp_image, 0);
 
-    rb_define_method(rb_cComplex, "+", nucomp_add, 1);
-    rb_define_method(rb_cComplex, "-", nucomp_sub, 1);
-    rb_define_method(rb_cComplex, "*", nucomp_mul, 1);
-    rb_define_method(rb_cComplex, "/", nucomp_div, 1);
-    rb_define_method(rb_cComplex, "quo", nucomp_quo, 1);
-    rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1);
-    rb_define_method(rb_cComplex, "**", nucomp_expt, 1);
+    rb_objc_define_method(rb_cComplex, "+", nucomp_add, 1);
+    rb_objc_define_method(rb_cComplex, "-", nucomp_sub, 1);
+    rb_objc_define_method(rb_cComplex, "*", nucomp_mul, 1);
+    rb_objc_define_method(rb_cComplex, "/", nucomp_div, 1);
+    rb_objc_define_method(rb_cComplex, "quo", nucomp_quo, 1);
+    rb_objc_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1);
+    rb_objc_define_method(rb_cComplex, "**", nucomp_expt, 1);
 
-    rb_define_method(rb_cComplex, "==", nucomp_equal_p, 1);
-    rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1);
+    rb_objc_define_method(rb_cComplex, "==", nucomp_equal_p, 1);
+    rb_objc_define_method(rb_cComplex, "coerce", nucomp_coerce, 1);
 
-    rb_define_method(rb_cComplex, "abs", nucomp_abs, 0);
+    rb_objc_define_method(rb_cComplex, "abs", nucomp_abs, 0);
 #if 0
     rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0);
 #endif
-    rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0);
-    rb_define_method(rb_cComplex, "arg", nucomp_arg, 0);
-    rb_define_method(rb_cComplex, "angle", nucomp_arg, 0);
-    rb_define_method(rb_cComplex, "polar", nucomp_polar, 0);
-    rb_define_method(rb_cComplex, "conjugate", nucomp_conjugate, 0);
-    rb_define_method(rb_cComplex, "conj", nucomp_conjugate, 0);
+    rb_objc_define_method(rb_cComplex, "abs2", nucomp_abs2, 0);
+    rb_objc_define_method(rb_cComplex, "arg", nucomp_arg, 0);
+    rb_objc_define_method(rb_cComplex, "angle", nucomp_arg, 0);
+    rb_objc_define_method(rb_cComplex, "polar", nucomp_polar, 0);
+    rb_objc_define_method(rb_cComplex, "conjugate", nucomp_conjugate, 0);
+    rb_objc_define_method(rb_cComplex, "conj", nucomp_conjugate, 0);
 #if 0
     rb_define_method(rb_cComplex, "~", nucomp_conjugate, 0); /* gcc */
 #endif
@@ -1501,46 +1501,46 @@
     rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0);
 #endif
 
-    rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0);
-    rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0);
+    rb_objc_define_method(rb_cComplex, "numerator", nucomp_numerator, 0);
+    rb_objc_define_method(rb_cComplex, "denominator", nucomp_denominator, 0);
 
-    rb_define_method(rb_cComplex, "hash", nucomp_hash, 0);
+    rb_objc_define_method(rb_cComplex, "hash", nucomp_hash, 0);
 
-    rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0);
-    rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0);
+    rb_objc_define_method(rb_cComplex, "to_s", nucomp_to_s, 0);
+    rb_objc_define_method(rb_cComplex, "inspect", nucomp_inspect, 0);
 
-    rb_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0);
-    rb_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1);
+    rb_objc_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0);
+    rb_objc_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1);
 
     /* --- */
 
-    rb_define_method(rb_cComplex, "scalar?", nucomp_scalar_p, 0);
-    rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0);
-    rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0);
-    rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0);
-    rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0);
-    rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0);
+    rb_objc_define_method(rb_cComplex, "scalar?", nucomp_scalar_p, 0);
+    rb_objc_define_method(rb_cComplex, "to_i", nucomp_to_i, 0);
+    rb_objc_define_method(rb_cComplex, "to_f", nucomp_to_f, 0);
+    rb_objc_define_method(rb_cComplex, "to_r", nucomp_to_r, 0);
+    rb_objc_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0);
+    rb_objc_define_method(rb_cNumeric, "to_c", numeric_to_c, 0);
 
     make_patterns();
 
-    rb_define_method(rb_cString, "to_c", string_to_c, 0);
+    rb_objc_define_method(rb_cString, "to_c", string_to_c, 0);
 
-    rb_define_singleton_method(rb_cComplex, "convert", nucomp_s_convert, -1);
+    rb_objc_define_method(*(VALUE *)rb_cComplex, "convert", nucomp_s_convert, -1);
 //    rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("convert")));
 
     /* --- */
 
-    rb_define_method(rb_cNumeric, "re", numeric_re, 0);
-    rb_define_method(rb_cNumeric, "im", numeric_im, 0);
-    rb_define_method(rb_cNumeric, "real", numeric_real, 0);
-    rb_define_method(rb_cNumeric, "image", numeric_image, 0);
-    rb_define_method(rb_cNumeric, "imag", numeric_image, 0);
-    rb_define_method(rb_cNumeric, "arg", numeric_arg, 0);
-    rb_define_method(rb_cNumeric, "angle", numeric_arg, 0);
-    rb_define_method(rb_cNumeric, "polar", numeric_polar, 0);
-    rb_define_method(rb_cNumeric, "conjugate", numeric_conjugate, 0);
-    rb_define_method(rb_cNumeric, "conj", numeric_conjugate, 0);
+    rb_objc_define_method(rb_cNumeric, "re", numeric_re, 0);
+    rb_objc_define_method(rb_cNumeric, "im", numeric_im, 0);
+    rb_objc_define_method(rb_cNumeric, "real", numeric_real, 0);
+    rb_objc_define_method(rb_cNumeric, "image", numeric_image, 0);
+    rb_objc_define_method(rb_cNumeric, "imag", numeric_image, 0);
+    rb_objc_define_method(rb_cNumeric, "arg", numeric_arg, 0);
+    rb_objc_define_method(rb_cNumeric, "angle", numeric_arg, 0);
+    rb_objc_define_method(rb_cNumeric, "polar", numeric_polar, 0);
+    rb_objc_define_method(rb_cNumeric, "conjugate", numeric_conjugate, 0);
+    rb_objc_define_method(rb_cNumeric, "conj", numeric_conjugate, 0);
 
     rb_define_const(rb_cComplex, "I",
 		    f_complex_new_bang2(rb_cComplex, ZERO, ONE));
Index: rational.c
===================================================================
--- rational.c	(revision 2107)
+++ rational.c	(working copy)
@@ -385,13 +385,13 @@
 }
 
 static VALUE
-nurat_s_alloc(VALUE klass)
+nurat_s_alloc(VALUE klass, SEL sel)
 {
     return nurat_s_new_internal(klass, ZERO, ONE);
 }
 
 static VALUE
-nurat_s_new_bang(int argc, VALUE *argv, VALUE klass)
+nurat_s_new_bang(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE num, den;
 
@@ -521,7 +521,7 @@
 }
 
 static VALUE
-nurat_s_new_m(int argc, VALUE *argv, VALUE klass)
+nurat_s_new_m(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE num, den;
 
@@ -562,20 +562,20 @@
 }
 
 static VALUE
-nurat_f_rational(int argc, VALUE *argv, VALUE klass)
+nurat_f_rational(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     return rb_funcall2(rb_cRational, id_convert, argc, argv);
 }
 
 static VALUE
-nurat_numerator(VALUE self)
+nurat_numerator(VALUE self, SEL sel)
 {
     get_dat1(self);
     return dat->num;
 }
 
 static VALUE
-nurat_denominator(VALUE self)
+nurat_denominator(VALUE self, SEL sel)
 {
     get_dat1(self);
     return dat->den;
@@ -667,7 +667,7 @@
 }
 
 static VALUE
-nurat_add(VALUE self, VALUE other)
+nurat_add(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -695,7 +695,7 @@
 }
 
 static VALUE
-nurat_sub(VALUE self, VALUE other)
+nurat_sub(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -762,7 +762,7 @@
 }
 
 static VALUE
-nurat_mul(VALUE self, VALUE other)
+nurat_mul(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -790,13 +790,13 @@
 }
 
 static VALUE
-nurat_div(VALUE self, VALUE other)
+nurat_div(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
       case T_BIGNUM:
 	if (f_zero_p(other))
-	    rb_raise(rb_eZeroDivError, "devided by zero");
+	    rb_raise(rb_eZeroDivError, "divided by zero");
 	{
 	    get_dat1(self);
 
@@ -808,7 +808,7 @@
 	return rb_funcall(f_to_f(self), '/', 1, other);
       case T_RATIONAL:
 	if (f_zero_p(other))
-	    rb_raise(rb_eZeroDivError, "devided by zero");
+	    rb_raise(rb_eZeroDivError, "divided by zero");
 	{
 	    get_dat2(self, other);
 
@@ -822,13 +822,13 @@
 }
 
 static VALUE
-nurat_fdiv(VALUE self, VALUE other)
+nurat_fdiv(VALUE self, SEL sel, VALUE other)
 {
     return f_div(f_to_f(self), other);
 }
 
 static VALUE
-nurat_expt(VALUE self, VALUE other)
+nurat_expt(VALUE self, SEL sel, VALUE other)
 {
     if (f_zero_p(other))
 	return f_rational_new_bang1(CLASS_OF(self), ONE);
@@ -873,7 +873,7 @@
 }
 
 static VALUE
-nurat_cmp(VALUE self, VALUE other)
+nurat_cmp(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -911,7 +911,7 @@
 }
 
 static VALUE
-nurat_equal_p(VALUE self, VALUE other)
+nurat_equal_p(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -943,7 +943,7 @@
 }
 
 static VALUE
-nurat_coerce(VALUE self, VALUE other)
+nurat_coerce(VALUE self, SEL sel, VALUE other)
 {
     switch (TYPE(other)) {
       case T_FIXNUM:
@@ -959,20 +959,20 @@
 }
 
 static VALUE
-nurat_idiv(VALUE self, VALUE other)
+nurat_idiv(VALUE self, SEL sel, VALUE other)
 {
     return f_floor(f_div(self, other));
 }
 
 static VALUE
-nurat_mod(VALUE self, VALUE other)
+nurat_mod(VALUE self, SEL sel, VALUE other)
 {
     VALUE val = f_floor(f_div(self, other));
     return f_sub(self, f_mul(other, val));
 }
 
 static VALUE
-nurat_divmod(VALUE self, VALUE other)
+nurat_divmod(VALUE self, SEL sel, VALUE other)
 {
     VALUE val = f_floor(f_div(self, other));
     return rb_assoc_new(val, f_sub(self, f_mul(other, val)));
@@ -987,7 +987,7 @@
 #endif
 
 static VALUE
-nurat_rem(VALUE self, VALUE other)
+nurat_rem(VALUE self, SEL sel, VALUE other)
 {
     VALUE val = f_truncate(f_div(self, other));
     return f_sub(self, f_mul(other, val));
@@ -1003,7 +1003,7 @@
 #endif
 
 static VALUE
-nurat_abs(VALUE self)
+nurat_abs(VALUE self, SEL sel)
 {
     if (!f_negative_p(self))
 	return self;
@@ -1020,21 +1020,21 @@
 #endif
 
 static VALUE
-nurat_floor(VALUE self)
+nurat_floor(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_idiv(dat->num, dat->den);
 }
 
 static VALUE
-nurat_ceil(VALUE self)
+nurat_ceil(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_negate(f_idiv(f_negate(dat->num), dat->den));
 }
 
 static VALUE
-nurat_truncate(VALUE self)
+nurat_truncate(VALUE self, SEL sel)
 {
     get_dat1(self);
     if (f_negative_p(dat->num))
@@ -1043,7 +1043,7 @@
 }
 
 static VALUE
-nurat_round(VALUE self)
+nurat_round(VALUE self, SEL sel)
 {
     get_dat1(self);
 
@@ -1089,7 +1089,7 @@
 }
 
 static VALUE
-nurat_to_f(VALUE self)
+nurat_to_f(VALUE self, SEL sel)
 {
     VALUE num, den;
     int minus = 0;
@@ -1147,47 +1147,43 @@
 }
 
 static VALUE
-nurat_to_r(VALUE self)
+nurat_to_r(VALUE self, SEL sel)
 {
     return self;
 }
 
 static VALUE
-nurat_hash(VALUE self)
+nurat_hash(VALUE self, SEL sel)
 {
     get_dat1(self);
     return f_xor(dat->num, dat->den);
 }
 
 static VALUE
-nurat_to_s(VALUE self)
+nurat_to_s(VALUE self, SEL sel)
 {
     get_dat1(self);
-
-    if (f_one_p(dat->den))
-	return f_to_s(dat->num);
-    else
-	return rb_funcall(rb_mKernel, id_format, 3,
-			  rb_str_new2("%d/%d"), dat->num, dat->den);
+    return rb_funcall(rb_mKernel, id_format, 3,
+		      rb_str_new2("%d/%d"), dat->num, dat->den);
 }
 
 static VALUE
-nurat_inspect(VALUE self)
+nurat_inspect(VALUE self, SEL sel)
 {
     get_dat1(self);
     return rb_funcall(rb_mKernel, id_format, 3,
-		      rb_str_new2("Rational(%d, %d)"), dat->num, dat->den);
+		      rb_str_new2("(%d/%d)"), dat->num, dat->den);
 }
 
 static VALUE
-nurat_marshal_dump(VALUE self)
+nurat_marshal_dump(VALUE self, SEL sel)
 {
     get_dat1(self);
     return rb_assoc_new(dat->num, dat->den);
 }
 
 static VALUE
-nurat_marshal_load(VALUE self, VALUE a)
+nurat_marshal_load(VALUE self, SEL sel, VALUE a)
 {
     get_dat1(self);
     dat->num = RARRAY_AT(a, 0);
@@ -1202,21 +1198,21 @@
 /* --- */
 
 VALUE
-rb_gcd(VALUE self, VALUE other)
+rb_gcd(VALUE self, SEL sel, VALUE other)
 {
     nurat_int_check(other);
     return f_gcd(self, other);
 }
 
 VALUE
-rb_lcm(VALUE self, VALUE other)
+rb_lcm(VALUE self, SEL sel, VALUE other)
 {
     nurat_int_check(other);
     return f_lcm(self, other);
 }
 
 VALUE
-rb_gcdlcm(VALUE self, VALUE other)
+rb_gcdlcm(VALUE self, SEL sel, VALUE other)
 {
     nurat_int_check(other);
     return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
@@ -1234,7 +1230,7 @@
     return nurat_s_canonicalize_internal(rb_cRational, x, y);
 }
 
-static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass);
+static VALUE nurat_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv);
 
 VALUE
 rb_Rational(VALUE x, VALUE y)
@@ -1242,17 +1238,17 @@
     VALUE a[2];
     a[0] = x;
     a[1] = y;
-    return nurat_s_convert(2, a, rb_cRational);
+    return nurat_s_convert(rb_cRational, NULL, 2, a);
 }
 
 static VALUE
-nilclass_to_r(VALUE self)
+nilclass_to_r(VALUE self, SEL sel)
 {
     return rb_rational_new1(INT2FIX(0));
 }
 
 static VALUE
-integer_to_r(VALUE self)
+integer_to_r(VALUE self, SEL sel)
 {
     return rb_rational_new1(self);
 }
@@ -1270,7 +1266,7 @@
 }
 
 static VALUE
-float_to_r(VALUE self)
+float_to_r(VALUE self, SEL sel)
 {
     VALUE a = float_decode(self);
     return f_mul(RARRAY_AT(a, 0),
@@ -1409,7 +1405,7 @@
 #define f_gsub(x,y,z) rb_funcall(x, id_gsub, 2, y, z)
 
 static VALUE
-string_to_r(VALUE self)
+string_to_r(VALUE self, SEL sel)
 {
     VALUE s = f_gsub(self, underscores_pat, an_underscore);
     VALUE a = string_to_r_internal(s);
@@ -1422,7 +1418,7 @@
 #define f_to_r(x) rb_funcall(x, id_to_r, 0)
 
 static VALUE
-nurat_s_convert(int argc, VALUE *argv, VALUE klass)
+nurat_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv)
 {
     VALUE a1, a2;
 
@@ -1491,7 +1487,7 @@
 }
 
 static VALUE
-nurat_s_induced_from(VALUE klass, VALUE n)
+nurat_s_induced_from(VALUE klass, SEL sel, VALUE n)
 {
     return f_to_r(n);
 }
@@ -1521,94 +1517,94 @@
 
     rb_cRational = rb_define_class(RATIONAL_NAME, rb_cNumeric);
 
-    rb_define_alloc_func(rb_cRational, nurat_s_alloc);
+    rb_objc_define_method(rb_cRational, "alloc", nurat_s_alloc, 0);
 //    rb_funcall(rb_cRational, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("allocate")));
 
-    rb_define_singleton_method(rb_cRational, "new!", nurat_s_new_bang, -1);
+    rb_objc_define_method(*(VALUE *)rb_cRational, "new!", nurat_s_new_bang, -1);
 //    rb_funcall(rb_cRational, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("new!")));
 
-    rb_define_singleton_method(rb_cRational, "new", nurat_s_new_m, -1);
+    rb_objc_define_method(*(VALUE *)rb_cRational, "new", nurat_s_new_m, -1);
 //    rb_funcall(rb_cRational, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("new")));
 
-    rb_define_global_function(RATIONAL_NAME, nurat_f_rational, -1);
+    rb_objc_define_method(rb_mKernel, RATIONAL_NAME, nurat_f_rational, -1);
 
-    rb_define_method(rb_cRational, "numerator", nurat_numerator, 0);
-    rb_define_method(rb_cRational, "denominator", nurat_denominator, 0);
+    rb_objc_define_method(rb_cRational, "numerator", nurat_numerator, 0);
+    rb_objc_define_method(rb_cRational, "denominator", nurat_denominator, 0);
 
-    rb_define_method(rb_cRational, "+", nurat_add, 1);
-    rb_define_method(rb_cRational, "-", nurat_sub, 1);
-    rb_define_method(rb_cRational, "*", nurat_mul, 1);
-    rb_define_method(rb_cRational, "/", nurat_div, 1);
-    rb_define_method(rb_cRational, "quo", nurat_div, 1);
-    rb_define_method(rb_cRational, "fdiv", nurat_fdiv, 1);
-    rb_define_method(rb_cRational, "**", nurat_expt, 1);
+    rb_objc_define_method(rb_cRational, "+", nurat_add, 1);
+    rb_objc_define_method(rb_cRational, "-", nurat_sub, 1);
+    rb_objc_define_method(rb_cRational, "*", nurat_mul, 1);
+    rb_objc_define_method(rb_cRational, "/", nurat_div, 1);
+    rb_objc_define_method(rb_cRational, "quo", nurat_div, 1);
+    rb_objc_define_method(rb_cRational, "fdiv", nurat_fdiv, 1);
+    rb_objc_define_method(rb_cRational, "**", nurat_expt, 1);
 
-    rb_define_method(rb_cRational, "<=>", nurat_cmp, 1);
-    rb_define_method(rb_cRational, "==", nurat_equal_p, 1);
-    rb_define_method(rb_cRational, "coerce", nurat_coerce, 1);
+    rb_objc_define_method(rb_cRational, "<=>", nurat_cmp, 1);
+    rb_objc_define_method(rb_cRational, "==", nurat_equal_p, 1);
+    rb_objc_define_method(rb_cRational, "coerce", nurat_coerce, 1);
 
-    rb_define_method(rb_cRational, "div", nurat_idiv, 1);
+    rb_objc_define_method(rb_cRational, "div", nurat_idiv, 1);
 #if NUBY
     rb_define_method(rb_cRational, "//", nurat_idiv, 1);
 #endif
-    rb_define_method(rb_cRational, "modulo", nurat_mod, 1);
-    rb_define_method(rb_cRational, "%", nurat_mod, 1);
-    rb_define_method(rb_cRational, "divmod", nurat_divmod, 1);
+    rb_objc_define_method(rb_cRational, "modulo", nurat_mod, 1);
+    rb_objc_define_method(rb_cRational, "%", nurat_mod, 1);
+    rb_objc_define_method(rb_cRational, "divmod", nurat_divmod, 1);
 
 #if 0
     rb_define_method(rb_cRational, "quot", nurat_quot, 1);
 #endif
-    rb_define_method(rb_cRational, "remainder", nurat_rem, 1);
+    rb_objc_define_method(rb_cRational, "remainder", nurat_rem, 1);
 #if 0
     rb_define_method(rb_cRational, "quotrem", nurat_quotrem, 1);
 #endif
 
-    rb_define_method(rb_cRational, "abs", nurat_abs, 0);
+    rb_objc_define_method(rb_cRational, "abs", nurat_abs, 0);
 
 #if 0
     rb_define_method(rb_cRational, "rational?", nurat_true, 0);
     rb_define_method(rb_cRational, "exact?", nurat_true, 0);
 #endif
 
-    rb_define_method(rb_cRational, "floor", nurat_floor, 0);
-    rb_define_method(rb_cRational, "ceil", nurat_ceil, 0);
-    rb_define_method(rb_cRational, "truncate", nurat_truncate, 0);
-    rb_define_method(rb_cRational, "round", nurat_round, 0);
+    rb_objc_define_method(rb_cRational, "floor", nurat_floor, 0);
+    rb_objc_define_method(rb_cRational, "ceil", nurat_ceil, 0);
+    rb_objc_define_method(rb_cRational, "truncate", nurat_truncate, 0);
+    rb_objc_define_method(rb_cRational, "round", nurat_round, 0);
 
-    rb_define_method(rb_cRational, "to_i", nurat_truncate, 0);
-    rb_define_method(rb_cRational, "to_f", nurat_to_f, 0);
-    rb_define_method(rb_cRational, "to_r", nurat_to_r, 0);
+    rb_objc_define_method(rb_cRational, "to_i", nurat_truncate, 0);
+    rb_objc_define_method(rb_cRational, "to_f", nurat_to_f, 0);
+    rb_objc_define_method(rb_cRational, "to_r", nurat_to_r, 0);
 
-    rb_define_method(rb_cRational, "hash", nurat_hash, 0);
+    rb_objc_define_method(rb_cRational, "hash", nurat_hash, 0);
 
-    rb_define_method(rb_cRational, "to_s", nurat_to_s, 0);
-    rb_define_method(rb_cRational, "inspect", nurat_inspect, 0);
+    rb_objc_define_method(rb_cRational, "to_s", nurat_to_s, 0);
+    rb_objc_define_method(rb_cRational, "inspect", nurat_inspect, 0);
 
-    rb_define_method(rb_cRational, "marshal_dump", nurat_marshal_dump, 0);
-    rb_define_method(rb_cRational, "marshal_load", nurat_marshal_load, 1);
+    rb_objc_define_method(rb_cRational, "marshal_dump", nurat_marshal_dump, 0);
+    rb_objc_define_method(rb_cRational, "marshal_load", nurat_marshal_load, 1);
 
     /* --- */
 
-    rb_define_method(rb_cInteger, "gcd", rb_gcd, 1);
-    rb_define_method(rb_cInteger, "lcm", rb_lcm, 1);
-    rb_define_method(rb_cInteger, "gcdlcm", rb_gcdlcm, 1);
+    rb_objc_define_method(rb_cInteger, "gcd", rb_gcd, 1);
+    rb_objc_define_method(rb_cInteger, "lcm", rb_lcm, 1);
+    rb_objc_define_method(rb_cInteger, "gcdlcm", rb_gcdlcm, 1);
 
-    rb_define_method(rb_cNilClass, "to_r", nilclass_to_r, 0);
-    rb_define_method(rb_cInteger, "to_r", integer_to_r, 0);
-    rb_define_method(rb_cFloat, "to_r", float_to_r, 0);
+    rb_objc_define_method(rb_cNilClass, "to_r", nilclass_to_r, 0);
+    rb_objc_define_method(rb_cInteger, "to_r", integer_to_r, 0);
+    rb_objc_define_method(rb_cFloat, "to_r", float_to_r, 0);
 
     make_patterns();
 
-    rb_define_method(rb_cString, "to_r", string_to_r, 0);
+    rb_objc_define_method(rb_cString, "to_r", string_to_r, 0);
 
-    rb_define_singleton_method(rb_cRational, "convert", nurat_s_convert, -1);
+    rb_objc_define_method(*(VALUE *)rb_cRational, "convert", nurat_s_convert, -1);
 //    rb_funcall(rb_cRational, rb_intern("private_class_method"), 1,
 //	       ID2SYM(rb_intern("convert")));
 
     rb_include_module(rb_cRational, rb_mPrecision);
-    rb_define_singleton_method(rb_cRational, "induced_from",
-			       nurat_s_induced_from, 1);
+    rb_objc_define_method(*(VALUE *)rb_cRational, "induced_from", nurat_s_induced_from, 1);
 }
+