/* * call-seq: * obj === other -> true or false * * Case Equality---For class <code>Object</code>, effectively the same * as calling <code>#==</code>, but typically overridden by descendants * to provide meaningful semantics in <code>case</code> statements. */ static mrb_value mrb_equal_m(mrb_state *mrb, mrb_value self) { mrb_value arg; mrb_get_args(mrb, "o", &arg); return mrb_bool_value(mrb_equal(mrb, self, arg)); }
static mrb_value member_i(mrb_state *mrb, mrb_value iter, mrb_value *memo, int argc, mrb_value *argv) { if (mrb_equal(mrb, enum_values_pack(mrb, argc, argv), memo[0])) { memo[1] = mrb_true_value(); mrb_iter_break(); } return mrb_nil_value(); }
static mrb_value mrb_obj_not_equal_m(mrb_state *mrb, mrb_value self) { mrb_value arg; mrb_bool eql_p; mrb_get_args(mrb, "o", &arg); eql_p = mrb_equal(mrb, self, arg); return mrb_bool_value(!eql_p); }
static mrb_value hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql) { khash_t(ht) *h1, *h2; if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (!mrb_hash_p(hash2)) { if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) { return mrb_false_value(); } if (eql) return mrb_fixnum_value(mrb_eql(mrb, hash2, hash1)); else return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1)); } h1 = RHASH_TBL(hash1); h2 = RHASH_TBL(hash2); if (!h1) { if (!h2) return mrb_true_value(); return mrb_false_value(); } if (!h2) return mrb_false_value(); if (kh_size(h1) != kh_size(h2)) return mrb_false_value(); else { khiter_t k1, k2; mrb_value key; for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) { if (!kh_exist(h1, k1)) continue; key = kh_key(h1,k1); k2 = kh_get(ht, h2, key); if (k2 != kh_end(h2)) { if (mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2))) { continue; /* next key */ } } return mrb_false_value(); } } return mrb_true_value(); }
/* * call-seq: * obj === other -> true or false * * Case Equality---For class <code>Object</code>, effectively the same * as calling <code>#==</code>, but typically overridden by descendants * to provide meaningful semantics in <code>case</code> statements. */ static mrb_value mrb_equal_m(mrb_state *mrb, mrb_value self) { mrb_value arg; mrb_get_args(mrb, "o", &arg); if (mrb_equal(mrb, self, arg)){ return mrb_true_value(); } else { return mrb_false_value(); } }
static mrb_value mrb_ary_equal(mrb_state *mrb, mrb_value ary1) { mrb_value ary2; mrb_bool equal_p; mrb_get_args(mrb, "o", &ary2); if (mrb_obj_equal(mrb, ary1, ary2)) { equal_p = 1; } else if (mrb_special_const_p(ary2)) { equal_p = 0; } else if (!mrb_array_p(ary2)) { if (!mrb_respond_to(mrb, ary2, mrb_intern2(mrb, "to_ary", 6))) { equal_p = 0; } else { equal_p = mrb_equal(mrb, ary2, ary1); } } else if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) { equal_p = 0; } else { mrb_int i; equal_p = 1; for (i=0; i<RARRAY_LEN(ary1); i++) { if (!mrb_equal(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) { equal_p = 0; break; } } } return mrb_bool_value(equal_p); }
/* * call-seq: * num.eql?(numeric) -> true or false * * Returns <code>true</code> if <i>num</i> and <i>numeric</i> are the * same type and have equal values. * * 1 == 1.0 #=> true * 1.eql?(1.0) #=> false * (1.0).eql?(1.0) #=> true */ static mrb_value num_eql(mrb_state *mrb, mrb_value x) { mrb_value y; mrb_get_args(mrb, "o", &y); if (mrb_type(x) != mrb_type(y)) return mrb_false_value(); if (mrb_equal(mrb, x, y)) { return mrb_true_value(); } else { return mrb_false_value(); } }
static mrb_value mrb_ary_index_m(mrb_state *mrb, mrb_value self) { mrb_value obj; mrb_int i; mrb_get_args(mrb, "o", &obj); for (i = 0; i < RARRAY_LEN(self); i++) { if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { return mrb_fixnum_value(i); } } return mrb_nil_value(); }
mrb_value mrb_ary_rindex_m(mrb_state *mrb, mrb_value self) { mrb_value obj; int i; mrb_get_args(mrb, "o", &obj); for (i = RARRAY_LEN(self) - 1; i >= 0; i--) { if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { return mrb_fixnum_value(i); } } return mrb_nil_value(); }
static mrb_value recursive_equal(mrb_state *mrb, mrb_value s, mrb_value s2, int recur) { mrb_value *ptr, *ptr2; long i, len; if (recur) return mrb_true_value(); /* Subtle! */ ptr = RSTRUCT_PTR(s); ptr2 = RSTRUCT_PTR(s2); len = RSTRUCT_LEN(s); for (i=0; i<len; i++) { if (!mrb_equal(mrb, ptr[i], ptr2[i])) return mrb_false_value(); } return mrb_true_value(); }
static mrb_value mrb_ary_assoc(mrb_state *mrb, mrb_value ary) { mrb_int i; mrb_value v, k; mrb_get_args(mrb, "o", &k); for (i = 0; i < RARRAY_LEN(ary); ++i) { v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]); if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 && mrb_equal(mrb, RARRAY_PTR(v)[0], k)) return v; } return mrb_nil_value(); }
/* * call-seq: * num.eql?(numeric) -> true or false * * Returns <code>true</code> if <i>num</i> and <i>numeric</i> are the * same type and have equal values. * * 1 == 1.0 #=> true * 1.eql?(1.0) #=> false * (1.0).eql?(1.0) #=> true */ static mrb_value num_eql(mrb_state *mrb, mrb_value x) { mrb_value y; mrb_bool eql_p; mrb_get_args(mrb, "o", &y); if (mrb_type(x) != mrb_type(y)) { eql_p = 0; } else { eql_p = mrb_equal(mrb, x, y); } return mrb_bool_value(eql_p); }
static mrb_value mrb_ary_rassoc(mrb_state *mrb, mrb_value ary) { mrb_int i; mrb_value v, value; mrb_get_args(mrb, "o", &value); for (i = 0; i < RARRAY_LEN(ary); ++i) { v = RARRAY_PTR(ary)[i]; if (mrb_type(v) == MRB_TT_ARRAY && RARRAY_LEN(v) > 1 && mrb_equal(mrb, RARRAY_PTR(v)[1], value)) return v; } return mrb_nil_value(); }
static mrb_value mrb_hash_has_valueWithvalue(mrb_state *mrb, mrb_value hash, mrb_value value) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; if (h) { for (k = kh_begin(h); k != kh_end(h); k++) { if (!kh_exist(h, k)) continue; if (mrb_equal(mrb, kh_value(h,k), value)) { return mrb_true_value(); } } } return mrb_false_value(); }
static mrb_value hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql) { if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (mrb_type(hash2) != MRB_TT_HASH) { if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) { return mrb_false_value(); } if (eql) return mrb_fixnum_value(mrb_eql(mrb, hash2, hash1)); else return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1)); } if (RHASH_SIZE(hash1) != RHASH_SIZE(hash2)) return mrb_false_value(); if (!RHASH(hash1)->ht || !RHASH(hash2)->ht) return mrb_true_value(); return mrb_exec_recursive_paired(mrb, recursive_eql, hash1, hash2, (void*)0); }
static mrb_value recursive_eql(mrb_state *mrb, mrb_value hash, mrb_value dt, int recur) { khash_t(ht) *h1 = RHASH_TBL(hash); khash_t(ht) *h2 = RHASH_TBL(dt); khiter_t k1, k2; mrb_value key1; for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) { if (!kh_exist(h1, k1)) continue; key1 = kh_key(h1,k1); k2 = kh_get(ht, h2, key1); if ( k2 != kh_end(h2)) { if (mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2))) { continue; /* next key */ } } return mrb_false_value(); } return mrb_true_value(); }
static mrb_value mrb_hash_has_value(mrb_state *mrb, mrb_value hash) { mrb_value val; khash_t(ht) *h; khiter_t k; mrb_get_args(mrb, "o", &val); h = RHASH_TBL(hash); if (h) { for (k = kh_begin(h); k != kh_end(h); k++) { if (!kh_exist(h, k)) continue; if (mrb_equal(mrb, kh_value(h, k).v, val)) { return mrb_true_value(); } } } return mrb_false_value(); }
static mrb_value mrb_struct_equal(mrb_state *mrb, mrb_value s) { mrb_value s2; mrb_value *ptr, *ptr2; long i, len; mrb_get_args(mrb, "o", &s2); if (mrb_obj_equal(mrb, s, s2)) return mrb_true_value(); if (mrb_type(s2) != MRB_TT_STRUCT) return mrb_false_value(); if (mrb_obj_class(mrb, s) != mrb_obj_class(mrb, s2)) return mrb_false_value(); if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) { mrb_bug("inconsistent struct"); /* should never happen */ } ptr = RSTRUCT_PTR(s); ptr2 = RSTRUCT_PTR(s2); len = RSTRUCT_LEN(s); for (i=0; i<len; i++) { if (!mrb_equal(mrb, ptr[i], ptr2[i])) return mrb_false_value(); } return mrb_true_value(); }
static khint_t mrb_hash_ht_hash_equal(mrb_state *mrb, mrb_value a, mrb_value b) { return mrb_equal(mrb, a, b); }