From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/compar.c | 246 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 jni/ruby/compar.c (limited to 'jni/ruby/compar.c') diff --git a/jni/ruby/compar.c b/jni/ruby/compar.c new file mode 100644 index 0000000..0cb899d --- /dev/null +++ b/jni/ruby/compar.c @@ -0,0 +1,246 @@ +/********************************************************************** + + compar.c - + + $Author: naruse $ + created at: Thu Aug 26 14:39:48 JST 1993 + + Copyright (C) 1993-2007 Yukihiro Matsumoto + +**********************************************************************/ + +#include "ruby/ruby.h" + +VALUE rb_mComparable; + +static ID cmp; + +void +rb_cmperr(VALUE x, VALUE y) +{ + VALUE classname; + + if (SPECIAL_CONST_P(y) || BUILTIN_TYPE(y) == T_FLOAT) { + classname = rb_inspect(y); + } + else { + classname = rb_obj_class(y); + } + rb_raise(rb_eArgError, "comparison of %"PRIsVALUE" with %"PRIsVALUE" failed", + rb_obj_class(x), classname); +} + +static VALUE +invcmp_recursive(VALUE x, VALUE y, int recursive) +{ + if (recursive) return Qnil; + return rb_check_funcall(y, cmp, 1, &x); +} + +VALUE +rb_invcmp(VALUE x, VALUE y) +{ + VALUE invcmp = rb_exec_recursive(invcmp_recursive, x, y); + if (invcmp == Qundef || NIL_P(invcmp)) { + return Qnil; + } + else { + int result = -rb_cmpint(invcmp, x, y); + return INT2FIX(result); + } +} + +static VALUE +cmp_eq_recursive(VALUE arg1, VALUE arg2, int recursive) +{ + if (recursive) return Qnil; + return rb_funcallv(arg1, cmp, 1, &arg2); +} + +static VALUE +cmp_eq(VALUE *a) +{ + VALUE c = rb_exec_recursive_paired_outer(cmp_eq_recursive, a[0], a[1], a[1]); + + if (NIL_P(c)) return Qfalse; + if (rb_cmpint(c, a[0], a[1]) == 0) return Qtrue; + return Qfalse; +} + +static VALUE +cmp_failed(void) +{ + rb_warn("Comparable#== will no more rescue exceptions of #<=> in the next release."); + rb_warn("Return nil in #<=> if the comparison is inappropriate or avoid such comparison."); + return Qfalse; +} + +/* + * call-seq: + * obj == other -> true or false + * + * Compares two objects based on the receiver's <=> + * method, returning true if it returns 0. Also returns true if + * _obj_ and _other_ are the same object. + * + * Even if _obj_ <=> _other_ raised an exception, the exception + * is ignored and returns false. + */ + +static VALUE +cmp_equal(VALUE x, VALUE y) +{ + VALUE a[2]; + + if (x == y) return Qtrue; + + a[0] = x; a[1] = y; + return rb_rescue(cmp_eq, (VALUE)a, cmp_failed, 0); +} + +/* + * call-seq: + * obj > other -> true or false + * + * Compares two objects based on the receiver's <=> + * method, returning true if it returns 1. + */ + +static VALUE +cmp_gt(VALUE x, VALUE y) +{ + VALUE c = rb_funcall(x, cmp, 1, y); + + if (rb_cmpint(c, x, y) > 0) return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * obj >= other -> true or false + * + * Compares two objects based on the receiver's <=> + * method, returning true if it returns 0 or 1. + */ + +static VALUE +cmp_ge(VALUE x, VALUE y) +{ + VALUE c = rb_funcall(x, cmp, 1, y); + + if (rb_cmpint(c, x, y) >= 0) return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * obj < other -> true or false + * + * Compares two objects based on the receiver's <=> + * method, returning true if it returns -1. + */ + +static VALUE +cmp_lt(VALUE x, VALUE y) +{ + VALUE c = rb_funcall(x, cmp, 1, y); + + if (rb_cmpint(c, x, y) < 0) return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * obj <= other -> true or false + * + * Compares two objects based on the receiver's <=> + * method, returning true if it returns -1 or 0. + */ + +static VALUE +cmp_le(VALUE x, VALUE y) +{ + VALUE c = rb_funcall(x, cmp, 1, y); + + if (rb_cmpint(c, x, y) <= 0) return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * obj.between?(min, max) -> true or false + * + * Returns false if obj <=> + * min is less than zero or if anObject <=> + * max is greater than zero, true otherwise. + * + * 3.between?(1, 5) #=> true + * 6.between?(1, 5) #=> false + * 'cat'.between?('ant', 'dog') #=> true + * 'gnu'.between?('ant', 'dog') #=> false + * + */ + +static VALUE +cmp_between(VALUE x, VALUE min, VALUE max) +{ + if (RTEST(cmp_lt(x, min))) return Qfalse; + if (RTEST(cmp_gt(x, max))) return Qfalse; + return Qtrue; +} + +/* + * The Comparable mixin is used by classes whose objects + * may be ordered. The class must define the <=> operator, + * which compares the receiver against another object, returning -1, 0, + * or +1 depending on whether the receiver is less than, equal to, or + * greater than the other object. If the other object is not comparable + * then the <=> operator should return nil. + * Comparable uses + * <=> to implement the conventional comparison operators + * (<, <=, ==, >=, + * and >) and the method between?. + * + * class SizeMatters + * include Comparable + * attr :str + * def <=>(anOther) + * str.size <=> anOther.str.size + * end + * def initialize(str) + * @str = str + * end + * def inspect + * @str + * end + * end + * + * s1 = SizeMatters.new("Z") + * s2 = SizeMatters.new("YY") + * s3 = SizeMatters.new("XXX") + * s4 = SizeMatters.new("WWWW") + * s5 = SizeMatters.new("VVVVV") + * + * s1 < s2 #=> true + * s4.between?(s1, s3) #=> false + * s4.between?(s3, s5) #=> true + * [ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV] + * + */ + +void +Init_Comparable(void) +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + rb_mComparable = rb_define_module("Comparable"); + rb_define_method(rb_mComparable, "==", cmp_equal, 1); + rb_define_method(rb_mComparable, ">", cmp_gt, 1); + rb_define_method(rb_mComparable, ">=", cmp_ge, 1); + rb_define_method(rb_mComparable, "<", cmp_lt, 1); + rb_define_method(rb_mComparable, "<=", cmp_le, 1); + rb_define_method(rb_mComparable, "between?", cmp_between, 2); + + cmp = rb_intern("<=>"); +} -- cgit v1.2.3