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