PageRenderTime 70ms CodeModel.GetById 33ms RepoModel.GetById 0ms app.codeStats 0ms

/src/class.c

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