src/object.c

   1 /*
   2 ** object.c - Object, NilClass, TrueClass, FalseClass class
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/class.h>
   9 #include <mruby/numeric.h>
  10 #include <mruby/string.h>
  11 #include <mruby/class.h>
  12 #include <mruby/internal.h>
  13 #include <mruby/presym.h>
  14
  15 MRB_API mrb_bool
  16 mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
  17 {
  18 #if defined(MRB_NAN_BOXING)
  19   return v1.u == v2.u;
  20 #elif defined(MRB_WORD_BOXING)
  21   return v1.w == v2.w;
  22 #else  /* MRB_NO_BOXING */
  23   if (mrb_type(v1) != mrb_type(v2)) return FALSE;
  24   switch (mrb_type(v1)) {
  25   case MRB_TT_TRUE:
  26     return TRUE;
  27
  28   case MRB_TT_FALSE:
  29     return (mrb_fixnum(v1) == mrb_fixnum(v2));
  30   case MRB_TT_INTEGER:
  31     return (mrb_integer(v1) == mrb_integer(v2));
  32   case MRB_TT_SYMBOL:
  33     return (mrb_symbol(v1) == mrb_symbol(v2));
  34
  35 #ifndef MRB_NO_FLOAT
  36   case MRB_TT_FLOAT:
  37     return (mrb_float(v1) == mrb_float(v2));
  38 #endif
  39
  40   default:
  41     return (mrb_ptr(v1) == mrb_ptr(v2));
  42   }
  43 #endif
  44 }
  45
  46 MRB_API mrb_bool
  47 mrb_obj_equal(mrb_state *mrb, mrb_value v1, mrb_value v2)
  48 {
  49   /* temporary definition */
  50   return mrb_obj_eq(mrb, v1, v2);
  51 }
  52
  53 MRB_API mrb_bool
  54 mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
  55 {
  56   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
  57 #ifndef MRB_NO_FLOAT
  58   /* value mixing with integer and float */
  59   else if (mrb_integer_p(obj1) && mrb_float_p(obj2)) {
  60     if ((mrb_float)mrb_integer(obj1) == mrb_float(obj2))
  61       return TRUE;
  62   }
  63   else if (mrb_float_p(obj1) && mrb_integer_p(obj2)) {
  64     if (mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
  65       return TRUE;
  66   }
  67 #endif
  68 #ifdef MRB_USE_BIGINT
  69   else if (mrb_bigint_p(obj1) &&
  70       (mrb_integer_p(obj2) || mrb_bigint_p(obj2) || mrb_float_p(obj2))) {
  71     if (mrb_bint_cmp(mrb, obj1, obj2) == 0)
  72       return TRUE;
  73   }
  74 #endif
  75   else if (!mrb_func_basic_p(mrb, obj1, MRB_OPSYM(eq), mrb_obj_equal_m)) {
  76     mrb_value result = mrb_funcall_argv(mrb, obj1, MRB_OPSYM(eq), 1, &obj2);
  77     if (mrb_test(result)) return TRUE;
  78   }
  79   return FALSE;
  80 }
  81
  82 /*
  83  * Document-class: NilClass
  84  *
  85  *  The class of the singleton object <code>nil</code>.
  86  */
  87
  88 /* 15.2.4.3.4  */
  89 /*
  90  * call_seq:
  91  *   nil.nil?               -> true
  92  *
  93  * Only the object <i>nil</i> responds <code>true</code> to <code>nil?</code>.
  94  */
  95
  96 static mrb_value
  97 mrb_true(mrb_state *mrb, mrb_value obj)
  98 {
  99   return mrb_true_value();
 100 }
 101
 102 /* 15.2.4.3.5  */
 103 /*
 104  *  call-seq:
 105  *     nil.to_s    -> ""
 106  *
 107  *  Always returns the empty string.
 108  */
 109
 110 static mrb_value
 111 nil_to_s(mrb_state *mrb, mrb_value obj)
 112 {
 113   mrb_value str = mrb_str_new_frozen(mrb, NULL, 0);
 114   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
 115   return str;
 116 }
 117
 118 static mrb_value
 119 nil_inspect(mrb_state *mrb, mrb_value obj)
 120 {
 121   mrb_value str = mrb_str_new_lit_frozen(mrb, "nil");
 122   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
 123   return str;
 124 }
 125
 126 /***********************************************************************
 127  *  Document-class: TrueClass
 128  *
 129  *  The global value <code>true</code> is the only instance of class
 130  *  <code>TrueClass</code> and represents a logically true value in
 131  *  boolean expressions. The class provides operators allowing
 132  *  <code>true</code> to be used in logical expressions.
 133  */
 134
 135 /* 15.2.5.3.1  */
 136 /*
 137  *  call-seq:
 138  *     true & obj    -> true or false
 139  *
 140  *  And---Returns <code>false</code> if <i>obj</i> is
 141  *  <code>nil</code> or <code>false</code>, <code>true</code> otherwise.
 142  */
 143
 144 static mrb_value
 145 true_and(mrb_state *mrb, mrb_value obj)
 146 {
 147   mrb_bool obj2;
 148
 149   mrb_get_args(mrb, "b", &obj2);
 150
 151   return mrb_bool_value(obj2);
 152 }
 153
 154 /* 15.2.5.3.2  */
 155 /*
 156  *  call-seq:
 157  *     true ^ obj   -> !obj
 158  *
 159  *  Exclusive Or---Returns <code>true</code> if <i>obj</i> is
 160  *  <code>nil</code> or <code>false</code>, <code>false</code>
 161  *  otherwise.
 162  */
 163
 164 static mrb_value
 165 true_xor(mrb_state *mrb, mrb_value obj)
 166 {
 167   mrb_bool obj2;
 168
 169   mrb_get_args(mrb, "b", &obj2);
 170   return mrb_bool_value(!obj2);
 171 }
 172
 173 /* 15.2.5.3.3  */
 174 /*
 175  * call-seq:
 176  *   true.to_s   ->  "true"
 177  *
 178  * The string representation of <code>true</code> is "true".
 179  */
 180
 181 static mrb_value
 182 true_to_s(mrb_state *mrb, mrb_value obj)
 183 {
 184   mrb_value str = mrb_str_new_lit_frozen(mrb, "true");
 185   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
 186   return str;
 187 }
 188
 189 /* 15.2.5.3.4  */
 190 /*
 191  *  call-seq:
 192  *     true | obj   -> true
 193  *
 194  *  Or---Returns <code>true</code>. As <i>anObject</i> is an argument to
 195  *  a method call, it is always evaluated; there is no short-circuit
 196  *  evaluation in this case.
 197  *
 198  *     true |  puts("or")
 199  *     true || puts("logical or")
 200  *
 201  *  <em>produces:</em>
 202  *
 203  *     or
 204  */
 205
 206 static mrb_value
 207 true_or(mrb_state *mrb, mrb_value obj)
 208 {
 209   return mrb_true_value();
 210 }
 211
 212 /*
 213  *  Document-class: FalseClass
 214  *
 215  *  The global value <code>false</code> is the only instance of class
 216  *  <code>FalseClass</code> and represents a logically false value in
 217  *  boolean expressions. The class provides operators allowing
 218  *  <code>false</code> to participate correctly in logical expressions.
 219  *
 220  */
 221
 222 /* 15.2.4.3.1  */
 223 /* 15.2.6.3.1  */
 224 /*
 225  *  call-seq:
 226  *     false & obj   -> false
 227  *     nil & obj     -> false
 228  *
 229  *  And---Returns <code>false</code>. <i>obj</i> is always
 230  *  evaluated as it is the argument to a method call---there is no
 231  *  short-circuit evaluation in this case.
 232  */
 233
 234 static mrb_value
 235 false_and(mrb_state *mrb, mrb_value obj)
 236 {
 237   return mrb_false_value();
 238 }
 239
 240 /* 15.2.4.3.2  */
 241 /* 15.2.6.3.2  */
 242 /*
 243  *  call-seq:
 244  *     false ^ obj    -> true or false
 245  *     nil   ^ obj    -> true or false
 246  *
 247  *  Exclusive Or---If <i>obj</i> is <code>nil</code> or
 248  *  <code>false</code>, returns <code>false</code>; otherwise, returns
 249  *  <code>true</code>.
 250  *
 251  */
 252
 253 static mrb_value
 254 false_xor(mrb_state *mrb, mrb_value obj)
 255 {
 256   mrb_bool obj2;
 257
 258   mrb_get_args(mrb, "b", &obj2);
 259   return mrb_bool_value(obj2);
 260 }
 261
 262 /* 15.2.4.3.3  */
 263 /* 15.2.6.3.4  */
 264 /*
 265  *  call-seq:
 266  *     false | obj   ->   true or false
 267  *     nil   | obj   ->   true or false
 268  *
 269  *  Or---Returns <code>false</code> if <i>obj</i> is
 270  *  <code>nil</code> or <code>false</code>; <code>true</code> otherwise.
 271  */
 272
 273 static mrb_value
 274 false_or(mrb_state *mrb, mrb_value obj)
 275 {
 276   mrb_bool obj2;
 277
 278   mrb_get_args(mrb, "b", &obj2);
 279   return mrb_bool_value(obj2);
 280 }
 281
 282 /* 15.2.6.3.3  */
 283 /*
 284  * call-seq:
 285  *   false.to_s   ->  "false"
 286  *
 287  * 'nuf said...
 288  */
 289
 290 static mrb_value
 291 false_to_s(mrb_state *mrb, mrb_value obj)
 292 {
 293   mrb_value str = mrb_str_new_lit_frozen(mrb, "false");
 294   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
 295   return str;
 296 }
 297
 298 void
 299 mrb_init_object(mrb_state *mrb)
 300 {
 301   struct RClass *n;
 302   struct RClass *t;
 303   struct RClass *f;
 304
 305   mrb->nil_class = n = mrb_define_class_id(mrb, MRB_SYM(NilClass), mrb->object_class);
 306   MRB_SET_INSTANCE_TT(n, MRB_TT_FALSE);
 307   mrb_undef_class_method_id(mrb, n, MRB_SYM(new));
 308   mrb_define_method_id(mrb, n, MRB_OPSYM(and),  false_and,      MRB_ARGS_REQ(1));  /* 15.2.4.3.1  */
 309   mrb_define_method_id(mrb, n, MRB_OPSYM(or),   false_or,       MRB_ARGS_REQ(1));  /* 15.2.4.3.2  */
 310   mrb_define_method_id(mrb, n, MRB_OPSYM(xor),  false_xor,      MRB_ARGS_REQ(1));  /* 15.2.4.3.3  */
 311   mrb_define_method_id(mrb, n, MRB_SYM_Q(nil),  mrb_true,       MRB_ARGS_NONE());  /* 15.2.4.3.4  */
 312   mrb_define_method_id(mrb, n, MRB_SYM(to_s),   nil_to_s,       MRB_ARGS_NONE());  /* 15.2.4.3.5  */
 313   mrb_define_method_id(mrb, n, MRB_SYM(inspect), nil_inspect, MRB_ARGS_NONE());
 314
 315   mrb->true_class = t = mrb_define_class_id(mrb, MRB_SYM(TrueClass), mrb->object_class);
 316   MRB_SET_INSTANCE_TT(t, MRB_TT_TRUE);
 317   mrb_undef_class_method_id(mrb, t, MRB_SYM(new));
 318   mrb_define_method_id(mrb, t, MRB_OPSYM(and),  true_and,       MRB_ARGS_REQ(1));  /* 15.2.5.3.1  */
 319   mrb_define_method_id(mrb, t, MRB_OPSYM(or),   true_or,        MRB_ARGS_REQ(1));  /* 15.2.5.3.2  */
 320   mrb_define_method_id(mrb, t, MRB_OPSYM(xor),  true_xor,       MRB_ARGS_REQ(1));  /* 15.2.5.3.3  */
 321   mrb_define_method_id(mrb, t, MRB_SYM(to_s),   true_to_s,      MRB_ARGS_NONE());  /* 15.2.5.3.4  */
 322   mrb_define_method_id(mrb, t, MRB_SYM(inspect), true_to_s,   MRB_ARGS_NONE());
 323
 324   mrb->false_class = f = mrb_define_class_id(mrb, MRB_SYM(FalseClass), mrb->object_class);
 325   MRB_SET_INSTANCE_TT(f, MRB_TT_FALSE);
 326   mrb_undef_class_method_id(mrb, f, MRB_SYM(new));
 327   mrb_define_method_id(mrb, f, MRB_OPSYM(and),  false_and,      MRB_ARGS_REQ(1));  /* 15.2.6.3.1  */
 328   mrb_define_method_id(mrb, f, MRB_OPSYM(or),   false_or,       MRB_ARGS_REQ(1));  /* 15.2.6.3.2  */
 329   mrb_define_method_id(mrb, f, MRB_OPSYM(xor),  false_xor,      MRB_ARGS_REQ(1));  /* 15.2.6.3.3  */
 330   mrb_define_method_id(mrb, f, MRB_SYM(to_s),   false_to_s,     MRB_ARGS_NONE());  /* 15.2.6.3.4  */
 331   mrb_define_method_id(mrb, f, MRB_SYM(inspect), false_to_s,  MRB_ARGS_NONE());
 332 }
 333
 334 static const char*
 335 type_name(enum mrb_vtype t)
 336 {
 337   switch (t) {
 338 #define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
 339     MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
 340 #undef MRB_VTYPE_NAME
 341     default: return NULL;
 342   }
 343 }
 344
 345 static mrb_value
 346 convert_type(mrb_state *mrb, mrb_value val, const char *tname, mrb_sym method, mrb_bool raise)
 347 {
 348   if (!mrb_respond_to(mrb, val, method)) {
 349     if (raise) {
 350       if (tname) mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
 351       mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y", val);
 352     }
 353     return mrb_nil_value();
 354   }
 355   return mrb_funcall_argv(mrb, val, method, 0, 0);
 356 }
 357
 358 MRB_API mrb_value
 359 mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
 360 {
 361   mrb_value v;
 362   const char *tname;
 363
 364   if (mrb_type(val) == type) return val;
 365   tname = type_name(type);
 366   v = convert_type(mrb, val, tname, method, TRUE);
 367   if (mrb_type(v) != type) {
 368     if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val);
 369     mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%n", val, tname, method);
 370   }
 371   return v;
 372 }
 373
 374 MRB_API mrb_value
 375 mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
 376 {
 377   mrb_value v;
 378
 379   if (mrb_type(val) == type && type != MRB_TT_CDATA && type != MRB_TT_ISTRUCT) return val;
 380   v = convert_type(mrb, val, type_name(type), method, FALSE);
 381   if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
 382   return v;
 383 }
 384
 385 MRB_API void
 386 mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
 387 {
 388   enum mrb_vtype xt = mrb_type(x);
 389   const char *tname, *ename;
 390
 391   if (t == xt) return;
 392
 393   tname = type_name(t);
 394   if (mrb_nil_p(x)) {
 395     ename = "nil";
 396   }
 397   else if (mrb_integer_p(x)) {
 398     ename = "Integer";
 399   }
 400   else if (mrb_symbol_p(x)) {
 401     ename = "Symbol";
 402   }
 403   else if (mrb_immediate_p(x)) {
 404     ename = RSTRING_PTR(mrb_obj_as_string(mrb, x));
 405   }
 406   else {
 407     ename = mrb_obj_classname(mrb, x);
 408   }
 409   if (tname) {
 410     mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
 411                ename, tname);
 412   }
 413   mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%s given)", t, ename);
 414 }
 415
 416 /* 15.3.1.3.46 */
 417 /*
 418  *  call-seq:
 419  *     obj.to_s    => string
 420  *
 421  *  Returns a string representing <i>obj</i>. The default
 422  *  <code>to_s</code> prints the object's class and an encoding of the
 423  *  object id. As a special case, the top-level object that is the
 424  *  initial execution context of Ruby programs returns "main."
 425  */
 426
 427 MRB_API mrb_value
 428 mrb_any_to_s(mrb_state *mrb, mrb_value obj)
 429 {
 430   mrb_value str = mrb_str_new_capa(mrb, 20);
 431   const char *cname = mrb_obj_classname(mrb, obj);
 432
 433   mrb_str_cat_lit(mrb, str, "#<");
 434   mrb_str_cat_cstr(mrb, str, cname);
 435   if (!mrb_immediate_p(obj)) {
 436     mrb_str_cat_lit(mrb, str, ":");
 437     mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_ptr(obj)));
 438   }
 439   mrb_str_cat_lit(mrb, str, ">");
 440
 441   return str;
 442 }
 443
 444 /*
 445  *  call-seq:
 446  *     obj.is_a?(class)       => true or false
 447  *     obj.kind_of?(class)    => true or false
 448  *
 449  *  Returns <code>true</code> if <i>class</i> is the class of
 450  *  <i>obj</i>, or if <i>class</i> is one of the superclasses of
 451  *  <i>obj</i> or modules included in <i>obj</i>.
 452  *
 453  *     module M;    end
 454  *     class A
 455  *       include M
 456  *     end
 457  *     class B < A; end
 458  *     class C < B; end
 459  *     b = B.new
 460  *     b.instance_of? A   #=> false
 461  *     b.instance_of? B   #=> true
 462  *     b.instance_of? C   #=> false
 463  *     b.instance_of? M   #=> false
 464  *     b.kind_of? A       #=> true
 465  *     b.kind_of? B       #=> true
 466  *     b.kind_of? C       #=> false
 467  *     b.kind_of? M       #=> true
 468  */
 469
 470 MRB_API mrb_bool
 471 mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
 472 {
 473   struct RClass *cl = mrb_class(mrb, obj);
 474
 475   switch (c->tt) {
 476     case MRB_TT_MODULE:
 477     case MRB_TT_CLASS:
 478     case MRB_TT_ICLASS:
 479     case MRB_TT_SCLASS:
 480       break;
 481
 482     default:
 483       mrb_raise(mrb, E_TYPE_ERROR, "class or module required");
 484   }
 485
 486   MRB_CLASS_ORIGIN(c);
 487   while (cl) {
 488     if (cl == c || cl->mt == c->mt)
 489       return TRUE;
 490     cl = cl->super;
 491   }
 492   return FALSE;
 493 }
 494
 495 #ifdef MRB_USE_RATIONAL
 496 // provided by mruby-rational with MRB_USE_RATIONAL
 497 mrb_value mrb_rational_to_i(mrb_state *mrb, mrb_value rat);
 498 mrb_value mrb_rational_to_f(mrb_state *mrb, mrb_value rat);
 499 #endif
 500 #ifdef MRB_USE_COMPLEX
 501 // provided by mruby-complex with MRB_USE_COMPLEX
 502 mrb_value mrb_complex_to_f(mrb_state *mrb, mrb_value comp);
 503 mrb_value mrb_complex_to_i(mrb_state *mrb, mrb_value comp);
 504 #endif
 505
 506 MRB_API mrb_value
 507 mrb_ensure_integer_type(mrb_state *mrb, mrb_value val)
 508 {
 509   if (!mrb_integer_p(val)) {
 510 #ifndef MRB_NO_FLOAT
 511     if (mrb_float_p(val)) {
 512       return mrb_float_to_integer(mrb, val);
 513     }
 514     else {
 515       switch (mrb_type(val)) {
 516 #ifdef MRB_USE_BIGINT
 517       case MRB_TT_BIGINT:
 518         return val;
 519 #endif
 520 #ifdef MRB_USE_RATIONAL
 521       case MRB_TT_RATIONAL:
 522         return mrb_rational_to_i(mrb, val);
 523 #endif
 524 #ifdef MRB_USE_COMPLEX
 525       case MRB_TT_COMPLEX:
 526         return mrb_complex_to_i(mrb, val);
 527 #endif
 528       default:
 529         break;
 530       }
 531     }
 532 #endif
 533     mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Integer", val);
 534   }
 535   return val;
 536 }
 537
 538 MRB_API mrb_value
 539 mrb_ensure_int_type(mrb_state *mrb, mrb_value val)
 540 {
 541   val = mrb_ensure_integer_type(mrb, val);
 542 #ifdef MRB_USE_BIGINT
 543   if (mrb_bigint_p(val)) {
 544     return mrb_int_value(mrb, mrb_bint_as_int(mrb, val));
 545   }
 546 #endif
 547   return val;
 548 }
 549
 550 #ifndef MRB_NO_FLOAT
 551 MRB_API mrb_value
 552 mrb_ensure_float_type(mrb_state *mrb, mrb_value val)
 553 {
 554   if (mrb_nil_p(val)) {
 555     mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float");
 556   }
 557   switch (mrb_type(val)) {
 558     case MRB_TT_INTEGER:
 559       return mrb_float_value(mrb, (mrb_float)mrb_integer(val));
 560
 561     case MRB_TT_FLOAT:
 562       return val;
 563
 564 #ifdef MRB_USE_RATIONAL
 565     case MRB_TT_RATIONAL:
 566       return mrb_rational_to_f(mrb, val);
 567 #endif
 568
 569 #ifdef MRB_USE_COMPLEX
 570     case MRB_TT_COMPLEX:
 571       return mrb_complex_to_f(mrb, val);
 572 #endif
 573
 574 #ifdef MRB_USE_BIGINT
 575     case MRB_TT_BIGINT:
 576       return mrb_float_value(mrb, mrb_bint_as_float(mrb, val));
 577 #endif
 578
 579     default:
 580       mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Float", val);
 581       /* not reached */
 582       return val;
 583   }
 584 }
 585 #endif
 586
 587 MRB_API mrb_value
 588 mrb_ensure_string_type(mrb_state *mrb, mrb_value str)
 589 {
 590   if (!mrb_string_p(str)) {
 591     mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to String", str);
 592   }
 593   return str;
 594 }
 595
 596 MRB_API mrb_value
 597 mrb_check_string_type(mrb_state *mrb, mrb_value str)
 598 {
 599   if (!mrb_string_p(str)) return mrb_nil_value();
 600   return str;
 601 }
 602
 603 MRB_API mrb_value
 604 mrb_ensure_array_type(mrb_state *mrb, mrb_value ary)
 605 {
 606   if (!mrb_array_p(ary)) {
 607     mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Array", ary);
 608   }
 609   return ary;
 610 }
 611
 612 MRB_API mrb_value
 613 mrb_check_array_type(mrb_state *mrb, mrb_value ary)
 614 {
 615   if (!mrb_array_p(ary)) return mrb_nil_value();
 616   return ary;
 617 }
 618
 619 MRB_API mrb_value
 620 mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash)
 621 {
 622   if (!mrb_hash_p(hash)) {
 623     mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Hash", hash);
 624   }
 625   return hash;
 626 }
 627
 628 MRB_API mrb_value
 629 mrb_check_hash_type(mrb_state *mrb, mrb_value hash)
 630 {
 631   if (!mrb_hash_p(hash)) return mrb_nil_value();
 632   return hash;
 633 }
 634
 635 MRB_API mrb_value
 636 mrb_inspect(mrb_state *mrb, mrb_value obj)
 637 {
 638   mrb_value v = mrb_funcall_argv(mrb, obj, MRB_SYM(inspect), 0, NULL);
 639   if (!mrb_string_p(v)) {
 640     v = mrb_obj_as_string(mrb, obj);
 641   }
 642   return v;
 643 }
 644
 645 MRB_API mrb_bool
 646 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 647 {
 648   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
 649   return mrb_test(mrb_funcall_argv(mrb, obj1, MRB_SYM_Q(eql), 1, &obj2));
 650 }
 651
 652 MRB_API mrb_value
 653 mrb_obj_itself(mrb_state *mrb, mrb_value self)
 654 {
 655   return self;
 656 }