PageRenderTime 49ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 0ms

/src/class.c

https://github.com/gzohari/mruby
C | 1942 lines | 1414 code | 230 blank | 298 comment | 212 complexity | 88bf52805f4d828af0219809a745f0d6 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

  1. /*
  2. ** class.c - Class class
  3. **
  4. ** See Copyright Notice in mruby.h
  5. */
  6. #include "mruby.h"
  7. #include <stdarg.h>
  8. #include <ctype.h>
  9. #include "mruby/array.h"
  10. #include "mruby/class.h"
  11. #include "mruby/numeric.h"
  12. #include "mruby/proc.h"
  13. #include "mruby/string.h"
  14. #include "mruby/variable.h"
  15. #include "error.h"
  16. KHASH_DEFINE(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal)
  17. void
  18. mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
  19. {
  20. khiter_t k;
  21. khash_t(mt) *h = c->mt;
  22. if (!h) return;
  23. for (k = kh_begin(h); k != kh_end(h); k++) {
  24. if (kh_exist(h, k)){
  25. struct RProc *m = kh_value(h, k);
  26. if (m) {
  27. mrb_gc_mark(mrb, (struct RBasic*)m);
  28. }
  29. }
  30. }
  31. }
  32. size_t
  33. mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
  34. {
  35. khash_t(mt) *h = c->mt;
  36. if (!h) return 0;
  37. return kh_size(h);
  38. }
  39. void
  40. mrb_gc_free_mt(mrb_state *mrb, struct RClass *c)
  41. {
  42. kh_destroy(mt, c->mt);
  43. }
  44. void
  45. mrb_name_class(mrb_state *mrb, struct RClass *c, mrb_sym name)
  46. {
  47. mrb_obj_iv_set(mrb, (struct RObject*)c,
  48. mrb_intern2(mrb, "__classid__", 11), mrb_symbol_value(name));
  49. }
  50. #define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  51. static void
  52. prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
  53. {
  54. struct RClass *sc, *c;
  55. if (o->c->tt == MRB_TT_SCLASS) return;
  56. sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class);
  57. sc->mt = 0;
  58. sc->iv = 0;
  59. if (o->tt == MRB_TT_CLASS) {
  60. c = (struct RClass*)o;
  61. if (!c->super) {
  62. sc->super = mrb->class_class;
  63. }
  64. else {
  65. sc->super = c->super->c;
  66. }
  67. }
  68. else if (o->tt == MRB_TT_SCLASS) {
  69. c = (struct RClass*)o;
  70. while (c->super->tt == MRB_TT_ICLASS)
  71. c = c->super;
  72. make_metaclass(mrb, c->super);
  73. sc->super = c->super->c;
  74. }
  75. else {
  76. sc->super = o->c;
  77. }
  78. o->c = sc;
  79. mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc);
  80. mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o);
  81. mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern2(mrb, "__attached__", 12), mrb_obj_value(o));
  82. }
  83. struct RClass*
  84. mrb_define_module_id(mrb_state *mrb, mrb_sym name)
  85. {
  86. struct RClass *m = mrb_module_new(mrb);
  87. mrb_obj_iv_set(mrb, (struct RObject*)mrb->object_class,
  88. name, mrb_obj_value(m));
  89. mrb_name_class(mrb, m, name);
  90. return m;
  91. }
  92. struct RClass*
  93. mrb_define_module(mrb_state *mrb, const char *name)
  94. {
  95. return mrb_define_module_id(mrb, mrb_intern_cstr(mrb, name));
  96. }
  97. static void
  98. setup_class(mrb_state *mrb, mrb_value outer, struct RClass *c, mrb_sym id)
  99. {
  100. mrb_name_class(mrb, c, id);
  101. mrb_const_set(mrb, outer, id, mrb_obj_value(c));
  102. mrb_obj_iv_set(mrb, (struct RObject*)c,
  103. mrb_intern2(mrb, "__outer__", 9), outer);
  104. }
  105. struct RClass*
  106. mrb_class_outer_module(mrb_state *mrb, struct RClass *c)
  107. {
  108. mrb_value outer;
  109. outer = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern2(mrb, "__outer__", 9));
  110. if (mrb_nil_p(outer)) return 0;
  111. return mrb_class_ptr(outer);
  112. }
  113. struct RClass*
  114. mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
  115. {
  116. struct RClass *c;
  117. mrb_value v;
  118. if (mrb_const_defined(mrb, outer, id)) {
  119. v = mrb_const_get(mrb, outer, id);
  120. c = mrb_class_ptr(v);
  121. }
  122. else {
  123. c = mrb_module_new(mrb);
  124. setup_class(mrb, outer, c, id);
  125. }
  126. return c;
  127. }
  128. struct RClass*
  129. mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
  130. {
  131. struct RClass *c = mrb_class_new(mrb, super);
  132. mrb_obj_iv_set(mrb, (struct RObject*)mrb->object_class,
  133. name, mrb_obj_value(c));
  134. mrb_name_class(mrb, c, name);
  135. return c;
  136. }
  137. struct RClass*
  138. mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
  139. {
  140. return mrb_define_class_id(mrb, mrb_intern_cstr(mrb, name), super);
  141. }
  142. struct RClass*
  143. mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
  144. {
  145. struct RClass *c, *s;
  146. if (mrb_const_defined(mrb, outer, id)) {
  147. mrb_value v = mrb_const_get(mrb, outer, id);
  148. mrb_check_type(mrb, v, MRB_TT_CLASS);
  149. c = mrb_class_ptr(v);
  150. if (!mrb_nil_p(super)) {
  151. if (mrb_type(super) != MRB_TT_CLASS) {
  152. mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)", super);
  153. }
  154. if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) {
  155. mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %S", mrb_sym2str(mrb, id));
  156. }
  157. }
  158. return c;
  159. }
  160. if (!mrb_nil_p(super)) {
  161. if (mrb_type(super) != MRB_TT_CLASS) {
  162. mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)", super);
  163. }
  164. s = mrb_class_ptr(super);
  165. }
  166. else {
  167. s = mrb->object_class;
  168. }
  169. c = mrb_class_new(mrb, s);
  170. setup_class(mrb, outer, c, id);
  171. mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c));
  172. return c;
  173. }
  174. int
  175. mrb_class_defined(mrb_state *mrb, const char *name)
  176. {
  177. mrb_value sym = mrb_check_intern_cstr(mrb, name);
  178. if (mrb_nil_p(sym)) {
  179. return FALSE;
  180. }
  181. return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
  182. }
  183. static struct RClass *
  184. class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
  185. {
  186. mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
  187. if (mrb_type(c) != MRB_TT_MODULE && mrb_type(c) != MRB_TT_CLASS) {
  188. mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a class/module", mrb_sym2str(mrb, id));
  189. }
  190. return mrb_class_ptr(c);
  191. }
  192. struct RClass *
  193. mrb_class_get(mrb_state *mrb, const char *name)
  194. {
  195. return mrb_class_get_under(mrb, mrb->object_class, name);
  196. }
  197. struct RClass *
  198. mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
  199. {
  200. return class_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
  201. }
  202. /*!
  203. * Defines a class under the namespace of \a outer.
  204. * \param outer a class which contains the new class.
  205. * \param id name of the new class
  206. * \param super a class from which the new class will derive.
  207. * NULL means \c Object class.
  208. * \return the created class
  209. * \throw TypeError if the constant name \a name is already taken but
  210. * the constant is not a \c Class.
  211. * \throw NameError if the class is already defined but the class can not
  212. * be reopened because its superclass is not \a super.
  213. * \post top-level constant named \a name refers the returned class.
  214. *
  215. * \note if a class named \a name is already defined and its superclass is
  216. * \a super, the function just returns the defined class.
  217. */
  218. struct RClass *
  219. mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
  220. {
  221. struct RClass * c;
  222. mrb_sym id = mrb_intern_cstr(mrb, name);
  223. if (mrb_const_defined_at(mrb, outer, id)) {
  224. c = class_from_sym(mrb, outer, id);
  225. if (mrb_class_real(c->super) != super) {
  226. mrb_name_error(mrb, id, "%S is already defined", name);
  227. }
  228. return c;
  229. }
  230. if (!super) {
  231. mrb_warn(mrb, "no super class for `%S::%S', Object assumed", outer, name);
  232. }
  233. c = mrb_class_new(mrb, super);
  234. setup_class(mrb, mrb_obj_value(outer), c, id);
  235. return c;
  236. }
  237. struct RClass *
  238. mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
  239. {
  240. struct RClass * c;
  241. mrb_sym id = mrb_intern_cstr(mrb, name);
  242. if (mrb_const_defined_at(mrb, outer, id)) {
  243. c = class_from_sym(mrb, outer, id);
  244. return c;
  245. }
  246. c = mrb_module_new(mrb);
  247. setup_class(mrb, mrb_obj_value(outer), c, id);
  248. return c;
  249. }
  250. void
  251. mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RProc *p)
  252. {
  253. khash_t(mt) *h = c->mt;
  254. khiter_t k;
  255. if (!h) h = c->mt = kh_init(mt, mrb);
  256. k = kh_put(mt, h, mid);
  257. kh_value(h, k) = p;
  258. if (p) {
  259. mrb_field_write_barrier(mrb, (struct RBasic *)c, (struct RBasic *)p);
  260. }
  261. }
  262. void
  263. mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
  264. {
  265. struct RProc *p;
  266. int ai = mrb_gc_arena_save(mrb);
  267. p = mrb_proc_new_cfunc(mrb, func);
  268. p->target_class = c;
  269. mrb_define_method_raw(mrb, c, mid, p);
  270. mrb_gc_arena_restore(mrb, ai);
  271. }
  272. void
  273. mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
  274. {
  275. mrb_define_method_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
  276. }
  277. void
  278. mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value body)
  279. {
  280. khash_t(mt) *h = c->mt;
  281. khiter_t k;
  282. struct RProc *p;
  283. if (!h) h = c->mt = kh_init(mt, mrb);
  284. k = kh_put(mt, h, name);
  285. p = mrb_proc_ptr(body);
  286. kh_value(h, k) = p;
  287. if (p) {
  288. mrb_field_write_barrier(mrb, (struct RBasic *)c, (struct RBasic *)p);
  289. }
  290. }
  291. static mrb_value
  292. check_type(mrb_state *mrb, mrb_value val, enum mrb_vtype t, const char *c, const char *m)
  293. {
  294. mrb_value tmp;
  295. tmp = mrb_check_convert_type(mrb, val, t, c, m);
  296. if (mrb_nil_p(tmp)) {
  297. mrb_raisef(mrb, E_TYPE_ERROR, "expected %S", mrb_str_new_cstr(mrb, c));
  298. }
  299. return tmp;
  300. }
  301. static mrb_value
  302. to_str(mrb_state *mrb, mrb_value val)
  303. {
  304. return check_type(mrb, val, MRB_TT_STRING, "String", "to_str");
  305. }
  306. static mrb_value
  307. to_ary(mrb_state *mrb, mrb_value val)
  308. {
  309. return check_type(mrb, val, MRB_TT_ARRAY, "Array", "to_ary");
  310. }
  311. static mrb_value
  312. to_hash(mrb_state *mrb, mrb_value val)
  313. {
  314. return check_type(mrb, val, MRB_TT_HASH, "Hash", "to_hash");
  315. }
  316. /*
  317. retrieve arguments from mrb_state.
  318. mrb_get_args(mrb, format, ...)
  319. returns number of arguments parsed.
  320. format specifiers:
  321. string mruby type C type note
  322. ----------------------------------------------------------------------------------------------
  323. o: Object [mrb_value]
  324. S: String [mrb_value]
  325. A: Array [mrb_value]
  326. H: Hash [mrb_value]
  327. s: String [char*,int] Receive two arguments.
  328. z: String [char*] NUL terminated string.
  329. a: Array [mrb_value*,mrb_int] Receive two arguments.
  330. f: Float [mrb_float]
  331. i: Integer [mrb_int]
  332. b: Boolean [mrb_bool]
  333. n: Symbol [mrb_sym]
  334. &: Block [mrb_value]
  335. *: rest argument [mrb_value*,int] Receive the rest of the arguments as an array.
  336. |: optional Next argument of '|' and later are optional.
  337. */
  338. int
  339. mrb_get_args(mrb_state *mrb, const char *format, ...)
  340. {
  341. char c;
  342. int i = 0;
  343. mrb_value *sp = mrb->c->stack + 1;
  344. va_list ap;
  345. int argc = mrb->c->ci->argc;
  346. int opt = 0;
  347. va_start(ap, format);
  348. if (argc < 0) {
  349. struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]);
  350. argc = a->len;
  351. sp = a->ptr;
  352. }
  353. while ((c = *format++)) {
  354. switch (c) {
  355. case '|': case '*': case '&':
  356. break;
  357. default:
  358. if (argc <= i && !opt) {
  359. mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
  360. }
  361. break;
  362. }
  363. switch (c) {
  364. case 'o':
  365. {
  366. mrb_value *p;
  367. p = va_arg(ap, mrb_value*);
  368. if (i < argc) {
  369. *p = *sp++;
  370. i++;
  371. }
  372. }
  373. break;
  374. case 'S':
  375. {
  376. mrb_value *p;
  377. p = va_arg(ap, mrb_value*);
  378. if (i < argc) {
  379. *p = to_str(mrb, *sp++);
  380. i++;
  381. }
  382. }
  383. break;
  384. case 'A':
  385. {
  386. mrb_value *p;
  387. p = va_arg(ap, mrb_value*);
  388. if (i < argc) {
  389. *p = to_ary(mrb, *sp++);
  390. i++;
  391. }
  392. }
  393. break;
  394. case 'H':
  395. {
  396. mrb_value *p;
  397. p = va_arg(ap, mrb_value*);
  398. if (i < argc) {
  399. *p = to_hash(mrb, *sp++);
  400. i++;
  401. }
  402. }
  403. break;
  404. case 's':
  405. {
  406. mrb_value ss;
  407. struct RString *s;
  408. char **ps = 0;
  409. int *pl = 0;
  410. ps = va_arg(ap, char**);
  411. pl = va_arg(ap, int*);
  412. if (i < argc) {
  413. ss = to_str(mrb, *sp++);
  414. s = mrb_str_ptr(ss);
  415. *ps = s->ptr;
  416. *pl = s->len;
  417. i++;
  418. }
  419. }
  420. break;
  421. case 'z':
  422. {
  423. mrb_value ss;
  424. struct RString *s;
  425. char **ps;
  426. ps = va_arg(ap, char**);
  427. if (i < argc) {
  428. ss = to_str(mrb, *sp++);
  429. s = mrb_str_ptr(ss);
  430. if (strlen(s->ptr) < s->len) {
  431. mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL");
  432. }
  433. *ps = s->ptr;
  434. i++;
  435. }
  436. }
  437. break;
  438. case 'a':
  439. {
  440. mrb_value aa;
  441. struct RArray *a;
  442. mrb_value **pb;
  443. mrb_int *pl;
  444. pb = va_arg(ap, mrb_value**);
  445. pl = va_arg(ap, mrb_int*);
  446. if (i < argc) {
  447. aa = to_ary(mrb, *sp++);
  448. a = mrb_ary_ptr(aa);
  449. *pb = a->ptr;
  450. *pl = a->len;
  451. i++;
  452. }
  453. }
  454. break;
  455. case 'f':
  456. {
  457. mrb_float *p;
  458. p = va_arg(ap, mrb_float*);
  459. if (i < argc) {
  460. switch (mrb_type(*sp)) {
  461. case MRB_TT_FLOAT:
  462. *p = mrb_float(*sp);
  463. break;
  464. case MRB_TT_FIXNUM:
  465. *p = (mrb_float)mrb_fixnum(*sp);
  466. break;
  467. case MRB_TT_STRING:
  468. mrb_raise(mrb, E_TYPE_ERROR, "String can't be coerced into Float");
  469. break;
  470. default:
  471. {
  472. mrb_value tmp;
  473. tmp = mrb_convert_type(mrb, *sp, MRB_TT_FLOAT, "Float", "to_f");
  474. *p = mrb_float(tmp);
  475. }
  476. break;
  477. }
  478. sp++;
  479. i++;
  480. }
  481. }
  482. break;
  483. case 'i':
  484. {
  485. mrb_int *p;
  486. p = va_arg(ap, mrb_int*);
  487. if (i < argc) {
  488. switch (mrb_type(*sp)) {
  489. case MRB_TT_FIXNUM:
  490. *p = mrb_fixnum(*sp);
  491. break;
  492. case MRB_TT_FLOAT:
  493. {
  494. mrb_float f = mrb_float(*sp);
  495. if (!FIXABLE(f)) {
  496. mrb_raise(mrb, E_RANGE_ERROR, "float too big for int");
  497. }
  498. *p = (mrb_int)f;
  499. }
  500. break;
  501. case MRB_TT_FALSE:
  502. *p = 0;
  503. break;
  504. default:
  505. {
  506. mrb_value tmp;
  507. tmp = mrb_convert_type(mrb, *sp, MRB_TT_FIXNUM, "Integer", "to_int");
  508. *p = mrb_fixnum(tmp);
  509. }
  510. break;
  511. }
  512. sp++;
  513. i++;
  514. }
  515. }
  516. break;
  517. case 'b':
  518. {
  519. mrb_bool *boolp = va_arg(ap, mrb_bool*);
  520. if (i < argc) {
  521. mrb_value b = *sp++;
  522. *boolp = mrb_test(b);
  523. i++;
  524. }
  525. }
  526. break;
  527. case 'n':
  528. {
  529. mrb_sym *symp;
  530. symp = va_arg(ap, mrb_sym*);
  531. if (i < argc) {
  532. mrb_value ss;
  533. ss = *sp++;
  534. if (mrb_type(ss) == MRB_TT_SYMBOL) {
  535. *symp = mrb_symbol(ss);
  536. }
  537. else if (mrb_string_p(ss)) {
  538. *symp = mrb_intern_str(mrb, to_str(mrb, ss));
  539. }
  540. else {
  541. mrb_value obj = mrb_funcall(mrb, ss, "inspect", 0);
  542. mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", obj);
  543. }
  544. i++;
  545. }
  546. }
  547. break;
  548. case '&':
  549. {
  550. mrb_value *p, *bp;
  551. p = va_arg(ap, mrb_value*);
  552. if (mrb->c->ci->argc < 0) {
  553. bp = mrb->c->stack + 2;
  554. }
  555. else {
  556. bp = mrb->c->stack + mrb->c->ci->argc + 1;
  557. }
  558. *p = *bp;
  559. }
  560. break;
  561. case '|':
  562. opt = 1;
  563. break;
  564. case '*':
  565. {
  566. mrb_value **var;
  567. int *pl;
  568. var = va_arg(ap, mrb_value**);
  569. pl = va_arg(ap, int*);
  570. if (argc > i) {
  571. *pl = argc-i;
  572. if (*pl > 0) {
  573. *var = sp;
  574. }
  575. i = argc;
  576. sp += *pl;
  577. }
  578. else {
  579. *pl = 0;
  580. *var = NULL;
  581. }
  582. }
  583. break;
  584. default:
  585. mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid argument specifier %S", mrb_str_new(mrb, &c, 1));
  586. break;
  587. }
  588. }
  589. if (!c && argc > i) {
  590. mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
  591. }
  592. va_end(ap);
  593. return i;
  594. }
  595. static struct RClass*
  596. boot_defclass(mrb_state *mrb, struct RClass *super)
  597. {
  598. struct RClass *c;
  599. c = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_CLASS, mrb->class_class);
  600. c->super = super ? super : mrb->object_class;
  601. mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super);
  602. c->mt = kh_init(mt, mrb);
  603. return c;
  604. }
  605. void
  606. mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
  607. {
  608. struct RClass *ins_pos;
  609. ins_pos = c;
  610. while (m) {
  611. struct RClass *p = c, *ic;
  612. int superclass_seen = 0;
  613. if (c->mt == m->mt) {
  614. mrb_raise(mrb, E_ARGUMENT_ERROR, "cyclic include detected");
  615. }
  616. while (p) {
  617. if (c != p && p->tt == MRB_TT_CLASS) {
  618. superclass_seen = 1;
  619. }
  620. else if (p->mt == m->mt){
  621. if (p->tt == MRB_TT_ICLASS && !superclass_seen) {
  622. ins_pos = p;
  623. }
  624. goto skip;
  625. }
  626. p = p->super;
  627. }
  628. ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class);
  629. if (m->tt == MRB_TT_ICLASS) {
  630. ic->c = m->c;
  631. }
  632. else {
  633. ic->c = m;
  634. }
  635. ic->mt = m->mt;
  636. ic->iv = m->iv;
  637. ic->super = ins_pos->super;
  638. ins_pos->super = ic;
  639. mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic);
  640. ins_pos = ic;
  641. skip:
  642. m = m->super;
  643. }
  644. }
  645. static mrb_value
  646. mrb_mod_append_features(mrb_state *mrb, mrb_value mod)
  647. {
  648. mrb_value klass;
  649. mrb_check_type(mrb, mod, MRB_TT_MODULE);
  650. mrb_get_args(mrb, "o", &klass);
  651. mrb_include_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
  652. return mod;
  653. }
  654. static mrb_value
  655. mrb_mod_include(mrb_state *mrb, mrb_value klass)
  656. {
  657. mrb_value *argv;
  658. int argc, i;
  659. mrb_get_args(mrb, "*", &argv, &argc);
  660. for (i=0; i<argc; i++) {
  661. mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
  662. }
  663. while (argc--) {
  664. mrb_funcall(mrb, argv[argc], "append_features", 1, klass);
  665. mrb_funcall(mrb, argv[argc], "included", 1, klass);
  666. }
  667. return klass;
  668. }
  669. /* 15.2.2.4.28 */
  670. /*
  671. * call-seq:
  672. * mod.include?(module) -> true or false
  673. *
  674. * Returns <code>true</code> if <i>module</i> is included in
  675. * <i>mod</i> or one of <i>mod</i>'s ancestors.
  676. *
  677. * module A
  678. * end
  679. * class B
  680. * include A
  681. * end
  682. * class C < B
  683. * end
  684. * B.include?(A) #=> true
  685. * C.include?(A) #=> true
  686. * A.include?(A) #=> false
  687. */
  688. static mrb_value
  689. mrb_mod_include_p(mrb_state *mrb, mrb_value mod)
  690. {
  691. mrb_value mod2;
  692. struct RClass *c = mrb_class_ptr(mod);
  693. mrb_get_args(mrb, "o", &mod2);
  694. mrb_check_type(mrb, mod2, MRB_TT_MODULE);
  695. while (c) {
  696. if (c->tt == MRB_TT_ICLASS) {
  697. if (c->c == mrb_class_ptr(mod2)) return mrb_true_value();
  698. }
  699. c = c->super;
  700. }
  701. return mrb_false_value();
  702. }
  703. static mrb_value
  704. mrb_mod_ancestors(mrb_state *mrb, mrb_value self)
  705. {
  706. mrb_value result;
  707. struct RClass *c = mrb_class_ptr(self);
  708. result = mrb_ary_new(mrb);
  709. mrb_ary_push(mrb, result, mrb_obj_value(c));
  710. c = c->super;
  711. while (c) {
  712. if (c->tt == MRB_TT_ICLASS) {
  713. mrb_ary_push(mrb, result, mrb_obj_value(c->c));
  714. }
  715. else if (c->tt != MRB_TT_SCLASS) {
  716. mrb_ary_push(mrb, result, mrb_obj_value(c));
  717. }
  718. c = c->super;
  719. }
  720. return result;
  721. }
  722. static mrb_value
  723. mrb_mod_extend_object(mrb_state *mrb, mrb_value mod)
  724. {
  725. mrb_value obj;
  726. mrb_check_type(mrb, mod, MRB_TT_MODULE);
  727. mrb_get_args(mrb, "o", &obj);
  728. mrb_include_module(mrb, mrb_class_ptr(mrb_singleton_class(mrb, obj)), mrb_class_ptr(mod));
  729. return mod;
  730. }
  731. static mrb_value
  732. mrb_mod_included_modules(mrb_state *mrb, mrb_value self)
  733. {
  734. mrb_value result;
  735. struct RClass *c = mrb_class_ptr(self);
  736. result = mrb_ary_new(mrb);
  737. while (c) {
  738. if (c->tt == MRB_TT_ICLASS) {
  739. mrb_ary_push(mrb, result, mrb_obj_value(c->c));
  740. }
  741. c = c->super;
  742. }
  743. return result;
  744. }
  745. mrb_value class_instance_method_list(mrb_state*, mrb_bool, struct RClass*, int);
  746. /* 15.2.2.4.33 */
  747. /*
  748. * call-seq:
  749. * mod.instance_methods(include_super=true) -> array
  750. *
  751. * Returns an array containing the names of the public and protected instance
  752. * methods in the receiver. For a module, these are the public and protected methods;
  753. * for a class, they are the instance (not singleton) methods. With no
  754. * argument, or with an argument that is <code>false</code>, the
  755. * instance methods in <i>mod</i> are returned, otherwise the methods
  756. * in <i>mod</i> and <i>mod</i>'s superclasses are returned.
  757. *
  758. * module A
  759. * def method1() end
  760. * end
  761. * class B
  762. * def method2() end
  763. * end
  764. * class C < B
  765. * def method3() end
  766. * end
  767. *
  768. * A.instance_methods #=> [:method1]
  769. * B.instance_methods(false) #=> [:method2]
  770. * C.instance_methods(false) #=> [:method3]
  771. * C.instance_methods(true).length #=> 43
  772. */
  773. static mrb_value
  774. mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
  775. {
  776. struct RClass *c = mrb_class_ptr(mod);
  777. mrb_bool recur = TRUE;
  778. mrb_get_args(mrb, "|b", &recur);
  779. return class_instance_method_list(mrb, recur, c, 0);
  780. }
  781. mrb_value mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
  782. /* 15.2.2.4.35 */
  783. /*
  784. * call-seq:
  785. * mod.class_eval {| | block } -> obj
  786. * mod.module_eval {| | block } -> obj
  787. *
  788. * Evaluates block in the context of _mod_. This can
  789. * be used to add methods to a class. <code>module_eval</code> returns
  790. * the result of evaluating its argument.
  791. */
  792. mrb_value
  793. mrb_mod_module_eval(mrb_state *mrb, mrb_value mod)
  794. {
  795. mrb_value a, b;
  796. struct RClass *c;
  797. if (mrb_get_args(mrb, "|S&", &a, &b) == 1) {
  798. mrb_raise(mrb, E_NOTIMP_ERROR, "module_eval/class_eval with string not implemented");
  799. }
  800. c = mrb_class_ptr(mod);
  801. return mrb_yield_internal(mrb, b, 0, 0, mod, c);
  802. }
  803. mrb_value
  804. mrb_mod_dummy_visibility(mrb_state *mrb, mrb_value mod)
  805. {
  806. return mod;
  807. }
  808. mrb_value
  809. mrb_singleton_class(mrb_state *mrb, mrb_value v)
  810. {
  811. struct RBasic *obj;
  812. switch (mrb_type(v)) {
  813. case MRB_TT_FALSE:
  814. if (mrb_nil_p(v))
  815. return mrb_obj_value(mrb->nil_class);
  816. return mrb_obj_value(mrb->false_class);
  817. case MRB_TT_TRUE:
  818. return mrb_obj_value(mrb->true_class);
  819. case MRB_TT_VOIDP:
  820. return mrb_obj_value(mrb->object_class);
  821. case MRB_TT_SYMBOL:
  822. case MRB_TT_FIXNUM:
  823. case MRB_TT_FLOAT:
  824. mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton");
  825. return mrb_nil_value(); /* not reached */
  826. default:
  827. break;
  828. }
  829. obj = mrb_basic_ptr(v);
  830. prepare_singleton_class(mrb, obj);
  831. return mrb_obj_value(obj->c);
  832. }
  833. void
  834. mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, mrb_func_t func, mrb_aspec aspec)
  835. {
  836. prepare_singleton_class(mrb, (struct RBasic*)o);
  837. mrb_define_method_id(mrb, o->c, mrb_intern_cstr(mrb, name), func, aspec);
  838. }
  839. void
  840. mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
  841. {
  842. mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
  843. }
  844. void
  845. mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
  846. {
  847. mrb_define_class_method(mrb, c, name, func, aspec);
  848. mrb_define_method(mrb, c, name, func, aspec);
  849. }
  850. struct RProc*
  851. mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
  852. {
  853. khiter_t k;
  854. struct RProc *m;
  855. struct RClass *c = *cp;
  856. while (c) {
  857. khash_t(mt) *h = c->mt;
  858. if (h) {
  859. k = kh_get(mt, h, mid);
  860. if (k != kh_end(h)) {
  861. m = kh_value(h, k);
  862. if (!m) break;
  863. *cp = c;
  864. return m;
  865. }
  866. }
  867. c = c->super;
  868. }
  869. return 0; /* no method */
  870. }
  871. struct RProc*
  872. mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
  873. {
  874. struct RProc *m;
  875. m = mrb_method_search_vm(mrb, &c, mid);
  876. if (!m) {
  877. mrb_value inspect = mrb_funcall(mrb, mrb_obj_value(c), "inspect", 0);
  878. if (RSTRING_LEN(inspect) > 64) {
  879. inspect = mrb_any_to_s(mrb, mrb_obj_value(c));
  880. }
  881. mrb_name_error(mrb, mid, "undefined method '%S' for class %S",
  882. mrb_sym2str(mrb, mid), inspect);
  883. }
  884. return m;
  885. }
  886. void
  887. mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv)
  888. {
  889. mrb_funcall_argv(mrb, obj, mrb->init_sym, argc, argv);
  890. }
  891. /*
  892. * call-seq:
  893. * class.new(args, ...) -> obj
  894. *
  895. * Calls <code>allocate</code> to create a new object of
  896. * <i>class</i>'s class, then invokes that object's
  897. * <code>initialize</code> method, passing it <i>args</i>.
  898. * This is the method that ends up getting called whenever
  899. * an object is constructed using .new.
  900. *
  901. */
  902. mrb_value
  903. mrb_class_new_instance(mrb_state *mrb, int argc, mrb_value *argv, struct RClass * klass)
  904. {
  905. mrb_value obj;
  906. struct RClass * c = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, klass);
  907. c->super = klass;
  908. obj = mrb_obj_value(c);
  909. mrb_obj_call_init(mrb, obj, argc, argv);
  910. return obj;
  911. }
  912. mrb_value
  913. mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass)
  914. {
  915. mrb_value *argv;
  916. mrb_value blk;
  917. struct RClass *k = mrb_class_ptr(klass);
  918. struct RClass *c;
  919. int argc;
  920. mrb_value obj;
  921. mrb_get_args(mrb, "*&", &argv, &argc, &blk);
  922. c = (struct RClass*)mrb_obj_alloc(mrb, k->tt, k);
  923. c->super = k;
  924. obj = mrb_obj_value(c);
  925. mrb_funcall_with_block(mrb, obj, mrb->init_sym, argc, argv, blk);
  926. return obj;
  927. }
  928. mrb_value
  929. mrb_instance_new(mrb_state *mrb, mrb_value cv)
  930. {
  931. struct RClass *c = mrb_class_ptr(cv);
  932. struct RObject *o;
  933. enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
  934. mrb_value obj, blk;
  935. mrb_value *argv;
  936. int argc;
  937. if (c->tt == MRB_TT_SCLASS)
  938. mrb_raise(mrb, E_TYPE_ERROR, "can't create instance of singleton class");
  939. if (ttype == 0) ttype = MRB_TT_OBJECT;
  940. o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
  941. obj = mrb_obj_value(o);
  942. mrb_get_args(mrb, "*&", &argv, &argc, &blk);
  943. mrb_funcall_with_block(mrb, obj, mrb->init_sym, argc, argv, blk);
  944. return obj;
  945. }
  946. mrb_value
  947. mrb_class_new_class(mrb_state *mrb, mrb_value cv)
  948. {
  949. mrb_value super;
  950. struct RClass *new_class;
  951. if (mrb_get_args(mrb, "|o", &super) == 0) {
  952. super = mrb_obj_value(mrb->object_class);
  953. }
  954. new_class = mrb_class_new(mrb, mrb_class_ptr(super));
  955. mrb_funcall(mrb, super, "inherited", 1, mrb_obj_value(new_class));
  956. return mrb_obj_value(new_class);
  957. }
  958. mrb_value
  959. mrb_class_superclass(mrb_state *mrb, mrb_value klass)
  960. {
  961. struct RClass *c;
  962. c = mrb_class_ptr(klass);
  963. c = c->super;
  964. while (c && c->tt == MRB_TT_ICLASS) {
  965. c = c->super;
  966. }
  967. if (!c) return mrb_nil_value();
  968. return mrb_obj_value(c);
  969. }
  970. static mrb_value
  971. mrb_bob_init(mrb_state *mrb, mrb_value cv)
  972. {
  973. return mrb_nil_value();
  974. }
  975. static mrb_value
  976. mrb_bob_not(mrb_state *mrb, mrb_value cv)
  977. {
  978. return mrb_bool_value(!mrb_test(cv));
  979. }
  980. /* 15.3.1.3.30 */
  981. /*
  982. * call-seq:
  983. * obj.method_missing(symbol [, *args] ) -> result
  984. *
  985. * Invoked by Ruby when <i>obj</i> is sent a message it cannot handle.
  986. * <i>symbol</i> is the symbol for the method called, and <i>args</i>
  987. * are any arguments that were passed to it. By default, the interpreter
  988. * raises an error when this method is called. However, it is possible
  989. * to override the method to provide more dynamic behavior.
  990. * If it is decided that a particular method should not be handled, then
  991. * <i>super</i> should be called, so that ancestors can pick up the
  992. * missing method.
  993. * The example below creates
  994. * a class <code>Roman</code>, which responds to methods with names
  995. * consisting of roman numerals, returning the corresponding integer
  996. * values.
  997. *
  998. * class Roman
  999. * def romanToInt(str)
  1000. * # ...
  1001. * end
  1002. * def method_missing(methId)
  1003. * str = methId.id2name
  1004. * romanToInt(str)
  1005. * end
  1006. * end
  1007. *
  1008. * r = Roman.new
  1009. * r.iv #=> 4
  1010. * r.xxiii #=> 23
  1011. * r.mm #=> 2000
  1012. */
  1013. static mrb_value
  1014. mrb_bob_missing(mrb_state *mrb, mrb_value mod)
  1015. {
  1016. mrb_sym name;
  1017. mrb_value *a;
  1018. int alen;
  1019. mrb_value inspect;
  1020. mrb_get_args(mrb, "n*", &name, &a, &alen);
  1021. if (mrb_respond_to(mrb,mod,mrb_intern2(mrb, "inspect",7))){
  1022. inspect = mrb_funcall(mrb, mod, "inspect", 0);
  1023. if (RSTRING_LEN(inspect) > 64) {
  1024. inspect = mrb_any_to_s(mrb, mod);
  1025. }
  1026. }
  1027. else {
  1028. inspect = mrb_any_to_s(mrb, mod);
  1029. }
  1030. mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%S' for %S",
  1031. mrb_sym2str(mrb, name), inspect);
  1032. /* not reached */
  1033. return mrb_nil_value();
  1034. }
  1035. int
  1036. mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
  1037. {
  1038. khiter_t k;
  1039. while (c) {
  1040. khash_t(mt) *h = c->mt;
  1041. if (h) {
  1042. k = kh_get(mt, h, mid);
  1043. if (k != kh_end(h)) {
  1044. if (kh_value(h, k)) {
  1045. return TRUE; /* method exists */
  1046. }
  1047. else {
  1048. return FALSE; /* undefined method */
  1049. }
  1050. }
  1051. }
  1052. c = c->super;
  1053. }
  1054. return FALSE; /* no method */
  1055. }
  1056. int
  1057. mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid)
  1058. {
  1059. return mrb_obj_respond_to(mrb_class(mrb, obj), mid);
  1060. }
  1061. mrb_value
  1062. mrb_class_path(mrb_state *mrb, struct RClass *c)
  1063. {
  1064. mrb_value path;
  1065. const char *name;
  1066. size_t len;
  1067. mrb_sym classpath = mrb_intern2(mrb, "__classpath__", 13);
  1068. path = mrb_obj_iv_get(mrb, (struct RObject*)c, classpath);
  1069. if (mrb_nil_p(path)) {
  1070. struct RClass *outer = mrb_class_outer_module(mrb, c);
  1071. mrb_sym sym = mrb_class_sym(mrb, c, outer);
  1072. if (sym == 0) {
  1073. return mrb_nil_value();
  1074. }
  1075. else if (outer && outer != mrb->object_class) {
  1076. mrb_value base = mrb_class_path(mrb, outer);
  1077. path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2));
  1078. name = mrb_sym2name_len(mrb, sym, &len);
  1079. mrb_str_concat(mrb, path, mrb_str_new(mrb, name, len));
  1080. }
  1081. else {
  1082. name = mrb_sym2name_len(mrb, sym, &len);
  1083. path = mrb_str_new(mrb, name, len);
  1084. }
  1085. mrb_obj_iv_set(mrb, (struct RObject*)c, classpath, path);
  1086. }
  1087. return path;
  1088. }
  1089. struct RClass *
  1090. mrb_class_real(struct RClass* cl)
  1091. {
  1092. while ((cl->tt == MRB_TT_SCLASS) || (cl->tt == MRB_TT_ICLASS)) {
  1093. cl = cl->super;
  1094. }
  1095. return cl;
  1096. }
  1097. const char*
  1098. mrb_class_name(mrb_state *mrb, struct RClass* c)
  1099. {
  1100. mrb_value path = mrb_class_path(mrb, c);
  1101. if (mrb_nil_p(path)) {
  1102. path = mrb_str_new(mrb, "#<Class:", 8);
  1103. mrb_str_concat(mrb, path, mrb_ptr_to_str(mrb, c));
  1104. mrb_str_cat(mrb, path, ">", 1);
  1105. }
  1106. return mrb_str_ptr(path)->ptr;
  1107. }
  1108. const char*
  1109. mrb_obj_classname(mrb_state *mrb, mrb_value obj)
  1110. {
  1111. return mrb_class_name(mrb, mrb_obj_class(mrb, obj));
  1112. }
  1113. /*!
  1114. * Ensures a class can be derived from super.
  1115. *
  1116. * \param super a reference to an object.
  1117. * \exception TypeError if \a super is not a Class or \a super is a singleton class.
  1118. */
  1119. void
  1120. mrb_check_inheritable(mrb_state *mrb, struct RClass *super)
  1121. {
  1122. if (super->tt != MRB_TT_CLASS) {
  1123. mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)", mrb_obj_value(super));
  1124. }
  1125. if (super->tt == MRB_TT_SCLASS) {
  1126. mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of singleton class");
  1127. }
  1128. if (super == mrb->class_class) {
  1129. mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of Class");
  1130. }
  1131. }
  1132. /*!
  1133. * Creates a new class.
  1134. * \param super a class from which the new class derives.
  1135. * \exception TypeError \a super is not inheritable.
  1136. * \exception TypeError \a super is the Class class.
  1137. */
  1138. struct RClass *
  1139. mrb_class_new(mrb_state *mrb, struct RClass *super)
  1140. {
  1141. struct RClass *c;
  1142. if (super) {
  1143. mrb_check_inheritable(mrb, super);
  1144. }
  1145. c = boot_defclass(mrb, super);
  1146. if (super){
  1147. MRB_SET_INSTANCE_TT(c, MRB_INSTANCE_TT(super));
  1148. }
  1149. make_metaclass(mrb, c);
  1150. return c;
  1151. }
  1152. /*!
  1153. * Creates a new module.
  1154. */
  1155. struct RClass *
  1156. mrb_module_new(mrb_state *mrb)
  1157. {
  1158. struct RClass *m = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_MODULE, mrb->module_class);
  1159. m->mt = kh_init(mt, mrb);
  1160. return m;
  1161. }
  1162. /*
  1163. * call-seq:
  1164. * obj.class => class
  1165. *
  1166. * Returns the class of <i>obj</i>, now preferred over
  1167. * <code>Object#type</code>, as an object's type in Ruby is only
  1168. * loosely tied to that object's class. This method must always be
  1169. * called with an explicit receiver, as <code>class</code> is also a
  1170. * reserved word in Ruby.
  1171. *
  1172. * 1.class #=> Fixnum
  1173. * self.class #=> Object
  1174. */
  1175. struct RClass*
  1176. mrb_obj_class(mrb_state *mrb, mrb_value obj)
  1177. {
  1178. return mrb_class_real(mrb_class(mrb, obj));
  1179. }
  1180. void
  1181. mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b)
  1182. {
  1183. struct RProc *m = mrb_method_search(mrb, c, b);
  1184. mrb_define_method_vm(mrb, c, a, mrb_obj_value(m));
  1185. }
  1186. /*!
  1187. * Defines an alias of a method.
  1188. * \param klass the class which the original method belongs to
  1189. * \param name1 a new name for the method
  1190. * \param name2 the original name of the method
  1191. */
  1192. void
  1193. mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2)
  1194. {
  1195. mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
  1196. }
  1197. /*
  1198. * call-seq:
  1199. * mod.to_s -> string
  1200. *
  1201. * Return a string representing this module or class. For basic
  1202. * classes and modules, this is the name. For singletons, we
  1203. * show information on the thing we're attached to as well.
  1204. */
  1205. static mrb_value
  1206. mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
  1207. {
  1208. mrb_value str;
  1209. if (mrb_type(klass) == MRB_TT_SCLASS) {
  1210. mrb_value v = mrb_iv_get(mrb, klass, mrb_intern2(mrb, "__attached__", 12));
  1211. str = mrb_str_new(mrb, "#<Class:", 8);
  1212. switch (mrb_type(v)) {
  1213. case MRB_TT_CLASS:
  1214. case MRB_TT_MODULE:
  1215. case MRB_TT_SCLASS:
  1216. mrb_str_append(mrb, str, mrb_inspect(mrb, v));
  1217. break;
  1218. default:
  1219. mrb_str_append(mrb, str, mrb_any_to_s(mrb, v));
  1220. break;
  1221. }
  1222. mrb_str_cat(mrb, str, ">", 1);
  1223. }
  1224. else {
  1225. struct RClass *c;
  1226. mrb_value path;
  1227. str = mrb_str_buf_new(mrb, 32);
  1228. c = mrb_class_ptr(klass);
  1229. path = mrb_class_path(mrb, c);
  1230. if (mrb_nil_p(path)) {
  1231. switch (mrb_type(klass)) {
  1232. case MRB_TT_CLASS:
  1233. mrb_str_cat(mrb, str, "#<Class:", 8);
  1234. break;
  1235. case MRB_TT_MODULE:
  1236. mrb_str_cat(mrb, str, "#<Module:", 9);
  1237. break;
  1238. default:
  1239. /* Shouldn't be happened? */
  1240. mrb_str_cat(mrb, str, "#<??????:", 9);
  1241. break;
  1242. }
  1243. mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, c));
  1244. mrb_str_cat(mrb, str, ">", 1);
  1245. }
  1246. else {
  1247. str = path;
  1248. }
  1249. }
  1250. return str;
  1251. }
  1252. mrb_value
  1253. mrb_mod_alias(mrb_state *mrb, mrb_value mod)
  1254. {
  1255. struct RClass *c = mrb_class_ptr(mod);
  1256. mrb_sym new_name, old_name;
  1257. mrb_get_args(mrb, "nn", &new_name, &old_name);
  1258. mrb_alias_method(mrb, c, new_name, old_name);
  1259. return mrb_nil_value();
  1260. }
  1261. static void
  1262. undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
  1263. {
  1264. mrb_value m;
  1265. if (!mrb_obj_respond_to(c, a)) {
  1266. mrb_name_error(mrb, a, "undefined method '%S' for class '%S'", mrb_sym2str(mrb, a), mrb_obj_value(c));
  1267. } else {
  1268. MRB_SET_VALUE(m, MRB_TT_PROC, value.p, 0);
  1269. mrb_define_method_vm(mrb, c, a, m);
  1270. }
  1271. }
  1272. void
  1273. mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
  1274. {
  1275. undef_method(mrb, c, mrb_intern_cstr(mrb, name));
  1276. }
  1277. void
  1278. mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
  1279. {
  1280. mrb_undef_method(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
  1281. }
  1282. mrb_value
  1283. mrb_mod_undef(mrb_state *mrb, mrb_value mod)
  1284. {
  1285. struct RClass *c = mrb_class_ptr(mod);
  1286. int argc;
  1287. mrb_value *argv;
  1288. mrb_get_args(mrb, "*", &argv, &argc);
  1289. while (argc--) {
  1290. undef_method(mrb, c, mrb_symbol(*argv));
  1291. argv++;
  1292. }
  1293. return mrb_nil_value();
  1294. }
  1295. static mrb_value
  1296. mod_define_method(mrb_state *mrb, mrb_value self)
  1297. {
  1298. struct RClass *c = mrb_class_ptr(self);
  1299. struct RProc *p;
  1300. mrb_sym mid;
  1301. mrb_value blk;
  1302. mrb_get_args(mrb, "n&", &mid, &blk);
  1303. if (mrb_nil_p(blk)) {
  1304. mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
  1305. }
  1306. p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
  1307. mrb_proc_copy(p, mrb_proc_ptr(blk));
  1308. mrb_define_method_raw(mrb, c, mid, p);
  1309. return blk;
  1310. }
  1311. static void
  1312. check_cv_name_sym(mrb_state *mrb, mrb_sym id)
  1313. {
  1314. const char *s;
  1315. size_t len;
  1316. s = mrb_sym2name_len(mrb, id, &len);
  1317. if (len < 3 || !(s[0] == '@' && s[1] == '@')) {
  1318. mrb_name_error(mrb, id, "`%S' is not allowed as a class variable name", mrb_sym2str(mrb, id));
  1319. }
  1320. }
  1321. static void
  1322. check_cv_name_str(mrb_state *mrb, mrb_value str)
  1323. {
  1324. const char *s = RSTRING_PTR(str);
  1325. size_t const len = RSTRING_LEN(str);
  1326. if (len < 3 || !(s[0] == '@' && s[1] == '@')) {
  1327. mrb_name_error(mrb, mrb_intern_str(mrb, str), "`%S' is not allowed as a class variable name", str);
  1328. }
  1329. }
  1330. static mrb_value
  1331. get_sym_or_str_arg(mrb_state *mrb)
  1332. {
  1333. mrb_value sym_or_str;
  1334. mrb_get_args(mrb, "o", &sym_or_str);
  1335. if (mrb_symbol_p(sym_or_str) || mrb_string_p(sym_or_str)) {
  1336. return sym_or_str;
  1337. } else {
  1338. mrb_value obj = mrb_funcall(mrb, sym_or_str, "inspect", 0);
  1339. mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", obj);
  1340. return mrb_nil_value();
  1341. }
  1342. }
  1343. /* 15.2.2.4.16 */
  1344. /*
  1345. * call-seq:
  1346. * obj.class_variable_defined?(symbol) -> true or false
  1347. *
  1348. * Returns <code>true</code> if the given class variable is defined
  1349. * in <i>obj</i>.
  1350. *
  1351. * class Fred
  1352. * @@foo = 99
  1353. * end
  1354. * Fred.class_variable_defined?(:@@foo) #=> true
  1355. * Fred.class_variable_defined?(:@@bar) #=> false
  1356. */
  1357. static mrb_value
  1358. mrb_mod_cvar_defined(mrb_state *mrb, mrb_value mod)
  1359. {
  1360. mrb_value id;
  1361. mrb_bool defined_p;
  1362. id = get_sym_or_str_arg(mrb);
  1363. if (mrb_symbol_p(id)) {
  1364. check_cv_name_sym(mrb, mrb_symbol(id));
  1365. defined_p = mrb_cv_defined(mrb, mod, mrb_symbol(id));
  1366. } else {
  1367. mrb_value sym;
  1368. check_cv_name_str(mrb, id);
  1369. sym = mrb_check_intern_str(mrb, id);
  1370. if (mrb_nil_p(sym)) {
  1371. defined_p = FALSE;
  1372. }
  1373. else {
  1374. defined_p = mrb_cv_defined(mrb, mod, mrb_symbol(sym));
  1375. }
  1376. }
  1377. return mrb_bool_value(defined_p);
  1378. }
  1379. /* 15.2.2.4.17 */
  1380. /*
  1381. * call-seq:
  1382. * mod.class_variable_get(symbol) -> obj
  1383. *
  1384. * Returns the value of the given class variable (or throws a
  1385. * <code>NameError</code> exception). The <code>@@</code> part of the
  1386. * variable name should be included for regular class variables
  1387. *
  1388. * class Fred
  1389. * @@foo = 99
  1390. * end
  1391. * Fred.class_variable_get(:@@foo) #=> 99
  1392. */
  1393. static mrb_value
  1394. mrb_mod_cvar_get(mrb_state *mrb, mrb_value mod)
  1395. {
  1396. mrb_sym id;
  1397. mrb_get_args(mrb, "n", &id);
  1398. check_cv_name_sym(mrb, id);
  1399. return mrb_cv_get(mrb, mod, id);
  1400. }
  1401. /* 15.2.2.4.18 */
  1402. /*
  1403. * call-seq:
  1404. * obj.class_variable_set(symbol, obj) -> obj
  1405. *
  1406. * Sets the class variable names by <i>symbol</i> to
  1407. * <i>object</i>.
  1408. *
  1409. * class Fred
  1410. * @@foo = 99
  1411. * def foo
  1412. * @@foo
  1413. * end
  1414. * end
  1415. * Fred.class_variable_set(:@@foo, 101) #=> 101
  1416. * Fred.new.foo #=> 101
  1417. */
  1418. static mrb_value
  1419. mrb_mod_cvar_set(mrb_state *mrb, mrb_value mod)
  1420. {
  1421. mrb_value value;
  1422. mrb_sym id;
  1423. mrb_get_args(mrb, "no", &id, &value);
  1424. check_cv_name_sym(mrb, id);
  1425. mrb_cv_set(mrb, mod, id, value);
  1426. return value;
  1427. }
  1428. /* 15.2.2.4.39 */
  1429. /*
  1430. * call-seq:
  1431. * remove_class_variable(sym) -> obj
  1432. *
  1433. * Removes the definition of the <i>sym</i>, returning that
  1434. * constant's value.
  1435. *
  1436. * class Dummy
  1437. * @@var = 99
  1438. * puts @@var
  1439. * p class_variables
  1440. * remove_class_variable(:@@var)
  1441. * p class_variables
  1442. * end
  1443. *
  1444. * <em>produces:</em>
  1445. *
  1446. * 99
  1447. * [:@@var]
  1448. * []
  1449. */
  1450. mrb_value
  1451. mrb_mod_remove_cvar(mrb_state *mrb, mrb_value mod)
  1452. {
  1453. mrb_value val;
  1454. mrb_sym id;
  1455. mrb_get_args(mrb, "n", &id);
  1456. check_cv_name_sym(mrb, id);
  1457. val = mrb_iv_remove(mrb, mod, id);
  1458. if (!mrb_undef_p(val)) return val;
  1459. if (mrb_cv_defined(mrb, mod, id)){
  1460. mrb_name_error(mrb, id, "cannot remove %S for %S",
  1461. mrb_sym2str(mrb, id), mod);
  1462. }
  1463. mrb_name_error(mrb, id, "class variable %S not defined for %S",
  1464. mrb_sym2str(mrb, id), mod);
  1465. /* not reached */
  1466. return mrb_nil_value();
  1467. }
  1468. /* 15.2.2.4.34 */
  1469. /*
  1470. * call-seq:
  1471. * mod.method_defined?(symbol) -> true or false
  1472. *
  1473. * Returns +true+ if the named method is defined by
  1474. * _mod_ (or its included modules and, if _mod_ is a class,
  1475. * its ancestors). Public and protected methods are matched.
  1476. *
  1477. * module A
  1478. * def method1() end
  1479. * end
  1480. * class B
  1481. * def method2() end
  1482. * end
  1483. * class C < B
  1484. * include A
  1485. * def method3() end
  1486. * end
  1487. *
  1488. * A.method_defined? :method1 #=> true
  1489. * C.method_defined? "method1" #=> true
  1490. * C.method_defined? "method2" #=> true
  1491. * C.method_defined? "method3" #=> true
  1492. * C.method_defined? "method4" #=> false
  1493. */
  1494. static mrb_value
  1495. mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
  1496. {
  1497. mrb_value id;
  1498. mrb_bool method_defined_p;
  1499. id = get_sym_or_str_arg(mrb);
  1500. if (mrb_symbol_p(id)) {
  1501. method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(id));
  1502. } else {
  1503. mrb_value sym = mrb_check_intern_str(mrb, id);
  1504. if (mrb_nil_p(sym)) {
  1505. method_defined_p = FALSE;
  1506. }
  1507. else {
  1508. method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(sym));
  1509. }
  1510. }
  1511. return mrb_bool_value(method_defined_p);
  1512. }
  1513. static void
  1514. remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
  1515. {
  1516. struct RClass *c = mrb_class_ptr(mod);
  1517. khash_t(mt) *h = c->mt;
  1518. khiter_t k;
  1519. if (h) {
  1520. k = kh_get(mt, h, mid);
  1521. if (k != kh_end(h)) {
  1522. kh_del(mt, h, k);
  1523. return;
  1524. }
  1525. }
  1526. mrb_name_error(mrb, mid, "method `%S' not defined in %S",
  1527. mrb_sym2str(mrb, mid), mod);
  1528. }
  1529. /* 15.2.2.4.41 */
  1530. /*
  1531. * call-seq:
  1532. * remove_method(symbol) -> self
  1533. *
  1534. * Removes the method identified by _symbol_ from the current
  1535. * class. For an example, see <code>Module.undef_method</code>.
  1536. */
  1537. mrb_value
  1538. mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
  1539. {
  1540. int argc;
  1541. mrb_value *argv;
  1542. mrb_get_args(mrb, "*", &argv, &argc);
  1543. while (argc--) {
  1544. remove_method(mrb, mod, mrb_symbol(*argv));
  1545. argv++;
  1546. }
  1547. return mod;
  1548. }
  1549. static void
  1550. check_const_name_sym(mrb_state *mrb, mrb_sym id)
  1551. {
  1552. const char *s;
  1553. size_t len;
  1554. s = mrb_sym2name_len(mrb, id, &len);
  1555. if (len < 1 || !ISUPPER(*s)) {
  1556. mrb_name_error(mrb, id, "wrong constant name %S", mrb_sym2str(mrb, id));
  1557. }
  1558. }
  1559. static void
  1560. check_const_name_str(mrb_state *mrb, mrb_value str)
  1561. {
  1562. if (RSTRING_LEN(str) < 1 || !ISUPPER(*RSTRING_PTR(str))) {
  1563. mrb_name_error(mrb, mrb_intern_str(mrb, str), "wrong constant name %S", str);
  1564. }
  1565. }
  1566. mrb_value
  1567. mrb_mod_const_defined(mrb_state *mrb, mrb_value mod)
  1568. {
  1569. mrb_value id;
  1570. mrb_bool const_defined_p;
  1571. id = get_sym_or_str_arg(mrb);
  1572. if (mrb_type(id) == MRB_TT_SYMBOL) {
  1573. check_const_name_sym(mrb, mrb_symbol(id));
  1574. const_defined_p = mrb_const_defined(mrb, mod, mrb_symbol(id));
  1575. } else {
  1576. mrb_value sym;
  1577. check_const_name_str(mrb, id);
  1578. sym = mrb_check_intern_str(mrb, id);
  1579. if (mrb_nil_p(sym)) {
  1580. const_defined_p = FALSE;
  1581. }
  1582. else {
  1583. const_defined_p = mrb_const_defined(mrb, mod, mrb_symbol(sym));
  1584. }
  1585. }
  1586. return mrb_bool_value(const_defined_p);
  1587. }
  1588. mrb_value
  1589. mrb_mod_const_get(mrb_state *mrb, mrb_value mod)
  1590. {
  1591. mrb_sym id;
  1592. mrb_get_args(mrb, "n", &id);
  1593. check_const_name_sym(mrb, id);
  1594. return mrb_const_get(mrb, mod, id);
  1595. }
  1596. mrb_value
  1597. mrb_mod_const_set(mrb_state *mrb, mrb_value mod)
  1598. {
  1599. mrb_sym id;
  1600. mrb_value value;
  1601. mrb_get_args(mrb, "no", &id, &value);
  1602. check_const_name_sym(mrb, id);
  1603. mrb_const_set(mrb, mod, id, value);
  1604. return value;
  1605. }
  1606. mrb_value
  1607. mrb_mod_remove_const(mrb_state *mrb, mrb_value mod)
  1608. {
  1609. mrb_sym id;
  1610. mrb_value val;
  1611. mrb_get_args(mrb, "n", &id);
  1612. check_const_name_sym(mrb, id);
  1613. val = mrb_iv_remove(mrb, mod, id);
  1614. if (mrb_undef_p(val)) {
  1615. mrb_name_error(mrb, id, "constant %S not defined", mrb_sym2str(mrb, id));
  1616. }
  1617. return val;
  1618. }
  1619. static mrb_value
  1620. mrb_mod_s_constants(mrb_state *mrb, mrb_value mod)
  1621. {
  1622. mrb_raise(mrb, E_NOTIMP_ERROR, "Module.constants not implemented");
  1623. return mrb_nil_value(); /* not reached */
  1624. }
  1625. static mrb_value
  1626. mrb_mod_eqq(mrb_state *mrb, mrb_value mod)
  1627. {
  1628. mrb_value obj;
  1629. mrb_bool eqq;
  1630. mrb_get_args(mrb, "o", &obj);
  1631. eqq = mrb_obj_is_kind_of(mrb, obj, mrb_class_ptr(mod));
  1632. return mrb_bool_value(eqq);
  1633. }
  1634. void
  1635. mrb_init_class(mrb_state *mrb)
  1636. {
  1637. struct RClass *bob; /* BasicObject */
  1638. struct RClass *obj; /* Object */
  1639. struct RClass *mod; /* Module */
  1640. struct RClass *cls; /* Class */
  1641. //struct RClass *krn; /* Kernel */
  1642. /* boot class hierarchy */
  1643. bob = boot_defclass(mrb, 0);
  1644. obj = boot_defclass(mrb, bob); mrb->object_class = obj;
  1645. mod = boot_defclass(mrb, obj); mrb->module_class = mod;/* obj -> mod */
  1646. cls = boot_defclass(mrb, mod); mrb->class_class = cls; /* obj -> cls */
  1647. /* fix-up loose ends */
  1648. bob->c = obj->c = mod->c = cls->c = cls;
  1649. make_metaclass(mrb, bob);
  1650. make_metaclass(mrb, obj);
  1651. make_metaclass(mrb, mod);
  1652. make_metaclass(mrb, cls);
  1653. /* name basic classes */
  1654. mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob));
  1655. mrb_define_const(mrb, obj, "BasicObject", mrb_obj_value(bob));
  1656. mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj));
  1657. mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod));
  1658. mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls));
  1659. /* name each classes */
  1660. mrb_name_class(mrb, bob, mrb_intern2(mrb, "BasicObject", 11));
  1661. mrb_name_class(mrb, obj, mrb_intern2(mrb, "Object", 6));
  1662. mrb_name_class(mrb, mod, mrb_intern2(mrb, "Module", 6));
  1663. mrb_name_class(mrb, cls, mrb_intern2(mrb, "Class", 5));
  1664. MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS);
  1665. mrb_define_method(mrb, bob, "initialize", mrb_bob_init, MRB_ARGS_NONE());
  1666. mrb_define_method(mrb, bob, "!", mrb_bob_not, MRB_ARGS_NONE());
  1667. mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, MRB_ARGS_ANY()); /* 15.3.1.3.30 */
  1668. mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, MRB_ARGS_ANY());
  1669. mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, MRB_ARGS_NONE()); /* 15.2.3.3.4 */
  1670. mrb_define_method(mrb, cls, "new", mrb_instance_new, MRB_ARGS_ANY()); /* 15.2.3.3.3 */
  1671. mrb_define_method(mrb, cls, "inherited", mrb_bob_init, MRB_ARGS_REQ(1));
  1672. MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE);
  1673. mrb_define_method(mrb, mod, "class_variable_defined?", mrb_mod_cvar_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.16 */
  1674. mrb_define_method(mrb, mod, "class_variable_get", mrb_mod_cvar_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.17 */
  1675. mrb_define_method(mrb, mod, "class_variable_set", mrb_mod_cvar_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.18 */
  1676. mrb_define_method(mrb, mod, "extend_object", mrb_mod_extend_object, MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
  1677. mrb_define_method(mrb, mod, "extended", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
  1678. mrb_define_method(mrb, mod, "include", mrb_mod_include, MRB_ARGS_ANY()); /* 15.2.2.4.27 */
  1679. mrb_define_method(mrb, mod, "include?", mrb_mod_include_p, MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
  1680. mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
  1681. mrb_define_method(mrb, mod, "class_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.15 */
  1682. mrb_define_method(mrb, mod, "included", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */
  1683. mrb_define_method(mrb, mod, "included_modules", mrb_mod_included_modules, MRB_ARGS_NONE()); /* 15.2.2.4.30 */
  1684. mrb_define_method(mrb, mod, "instance_methods", mrb_mod_instance_methods, MRB_ARGS_ANY()); /* 15.2.2.4.33 */
  1685. mrb_define_method(mrb, mod, "method_defined?", mrb_mod_method_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.34 */
  1686. mrb_define_method(mrb, mod, "module_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.35 */
  1687. mrb_define_method(mrb, mod, "private", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.36 */
  1688. mrb_define_method(mrb, mod, "protected", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.37 */
  1689. mrb_define_method(mrb, mod, "public", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.38 */
  1690. mrb_define_method(mrb, mod, "remove_class_variable", mrb_mod_remove_cvar, MRB_ARGS_REQ(1)); /* 15.2.2.4.39 */
  1691. mrb_define_method(mrb, mod, "remove_method", mrb_mod_remove_method, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
  1692. mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, MRB_ARGS_NONE());
  1693. mrb_define_method(mrb, mod, "inspect", mrb_mod_to_s, MRB_ARGS_NONE());
  1694. mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, MRB_ARGS_ANY()); /* 15.2.2.4.8 */
  1695. mrb_define_method(mrb, mod, "ancestors", mrb_mod_ancestors, MRB_ARGS_NONE()); /* 15.2.2.4.9 */
  1696. mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
  1697. mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.20 */
  1698. mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.21 */
  1699. mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.23 */
  1700. mrb_define_method(mrb, mod, "constants", mrb_mod_constants, MRB_ARGS_NONE()); /* 15.2.2.4.24 */
  1701. mrb_define_method(mrb, mod, "remove_const", mrb_mod_remove_const, MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
  1702. mrb_define_method(mrb, mod, "define_method", mo

Large files files are truncated, but you can click here to view the full file