summaryrefslogtreecommitdiffhomepage
path: root/src/kernel.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/kernel.c')
-rw-r--r--src/kernel.c1530
1 files changed, 1530 insertions, 0 deletions
diff --git a/src/kernel.c b/src/kernel.c
new file mode 100644
index 000000000..e5b2cab04
--- /dev/null
+++ b/src/kernel.c
@@ -0,0 +1,1530 @@
+#include "mruby.h"
+#include "mruby/string.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "mruby/proc.h"
+
+#include "mruby/range.h"
+#include "mruby/array.h"
+#include "mruby/hash.h"
+#include "mruby/class.h"
+#include "mruby/struct.h"
+#include "variable.h"
+#include "ritehash.h"
+#include "error.h"
+#include "method.h"
+#include "mdata.h"
+
+#ifdef INCLUDE_REGEXP
+#include "re.h"
+#include "regint.h"
+#endif
+
+KHASH_MAP_INIT_INT(mt, struct RProc*);
+KHASH_MAP_INIT_INT(iv, mrb_value);
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+static mrb_value tst_setconst(mrb_state *mrb, mrb_value obj);
+int kiv_lookup(khash_t(iv) *table, mrb_sym key, mrb_value *value);
+
+struct obj_ivar_tag {
+ mrb_value obj;
+ int (*func)(mrb_sym key, mrb_value val, void * arg);
+ void * arg;
+};
+
+static int
+obj_ivar_i(mrb_sym key, int index, struct obj_ivar_tag *arg)
+{
+ enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK};
+ struct obj_ivar_tag *data = (struct obj_ivar_tag *)arg;
+ if ((long)index < ROBJECT_NUMIV(data->obj)) {
+ mrb_value val = ROBJECT_IVPTR(data->obj)->vals[(long)index];
+ if (val.tt != MRB_TT_FREE) {
+ return (data->func)((mrb_sym)key, val, data->arg);
+ }
+ }
+ return ST_CONTINUE;
+}
+
+void
+mrb_ivar_foreach(mrb_state *mrb, mrb_value obj, int (*func)(ANYARGS), void* arg)
+{
+ struct obj_ivar_tag data;
+ switch (mrb_type(obj)) {
+ case MRB_TT_OBJECT:
+ //obj_ivar_each(mrb, obj, func, arg);
+ if (RCLASS_IV_TBL(obj)) {
+ data.obj = obj;
+ data.func = (int (*)(mrb_sym key, mrb_value val, void * arg))func;
+ data.arg = arg;
+ st_foreach_safe(mrb, RCLASS_IV_TBL(obj), obj_ivar_i, (void *)&data);
+ }
+ break;
+ case MRB_TT_CLASS:
+ case MRB_TT_MODULE:
+ if (RCLASS_IV_TBL(obj)) {
+ st_foreach_safe(mrb, RCLASS_IV_TBL(obj), func, arg);
+ }
+ break;
+ default:
+ if (!ROBJECT_IVPTR(obj)/*generic_iv_tbl*/) break;
+ if (/*FL_TEST(obj, FL_EXIVAR) ||*/ mrb_special_const_p(obj)) {
+ mrb_value *tbl=0;
+ if (kiv_lookup(ROBJECT_IVPTR(obj)/*generic_iv_tbl*/, SYM2ID(obj), tbl)) {
+ st_foreach_safe(mrb, (void *)tbl, func, arg);
+ }
+ }
+ break;
+ }
+}
+
+static int
+inspect_i(mrb_state *mrb, mrb_sym id, mrb_value value, mrb_value str)
+{
+ enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK};
+ mrb_value str2;
+ const char *ivname;
+ /* need not to show internal data */
+ if (RSTRING_PTR(str)[0] == '-') { /* first element */
+ RSTRING_PTR(str)[0] = '#';
+ mrb_str_cat2(mrb, str, " ");
+ }
+ else {
+ mrb_str_cat2(mrb, str, ", ");
+ }
+ ivname = mrb_sym2name(mrb, id);
+ mrb_str_cat2(mrb, str, ivname);
+ mrb_str_cat2(mrb, str, "=");
+ str2 = mrb_inspect(mrb, value);
+ mrb_str_append(mrb, str, str2);
+ //OBJ_INFECT(str, str2);
+
+ return ST_CONTINUE;
+}
+
+static mrb_value
+inspect_obj(mrb_state *mrb, mrb_value obj, mrb_value str, int recur)
+{
+ if (recur) {
+ mrb_str_cat2(mrb, str, " ...");
+ }
+ else {
+ mrb_ivar_foreach(mrb, obj, inspect_i, &str);
+ }
+ mrb_str_cat2(mrb, str, ">");
+ RSTRING_PTR(str)[0] = '#';
+ //OBJ_INFECT(str, obj);
+
+ return str;
+}
+
+int
+mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
+{
+ //const mrb_method_entry_t *me = mrb_method_entry(CLASS_OF(obj), mrb_intern("to_s"));
+ //if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC &&
+ //me->def->body.cfunc.func == mrb_any_to_s)
+ struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern(mrb, "to_s"));
+ if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s))
+ return 1;
+ return 0;
+}
+
+/* 15.3.1.3.17 */
+/*
+ * call-seq:
+ * obj.inspect -> string
+ *
+ * Returns a string containing a human-readable representation of
+ * <i>obj</i>. If not overridden and no instance variables, uses the
+ * <code>to_s</code> method to generate the string.
+ * <i>obj</i>. If not overridden, uses the <code>to_s</code> method to
+ * generate the string.
+ *
+ * [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]"
+ * Time.new.inspect #=> "2008-03-08 19:43:39 +0900"
+ */
+mrb_value
+mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
+{
+ if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) {
+ int has_ivar = 0;
+ mrb_value *ptr = (mrb_value *)ROBJECT_IVPTR(obj);
+ long len = ROBJECT_NUMIV(obj);
+ long i;
+
+ for (i = 0; i < len; i++) {
+ if (ptr[i].tt != MRB_TT_FREE) {
+ has_ivar = 1;
+ break;
+ }
+ }
+
+ if (has_ivar) {
+ mrb_value str;
+ const char *c = mrb_obj_classname(mrb, obj);
+
+ str = mrb_sprintf(mrb, "-<%s:%p", c, (void*)&obj);
+ return inspect_obj(mrb, obj, str, 0);
+ }
+ return mrb_any_to_s(mrb, obj);
+ }
+ else if (mrb_nil_p(obj)) {
+ return mrb_str_new_cstr(mrb, "nil");
+ }
+ return mrb_funcall(mrb, obj, "to_s", 0, 0);
+}
+
+/* 15.3.1.3.1 */
+/* 15.3.1.3.10 */
+/* 15.3.1.3.11 */
+/*
+ * call-seq:
+ * obj == other -> true or false
+ * obj.equal?(other) -> true or false
+ * obj.eql?(other) -> true or false
+ *
+ * Equality---At the <code>Object</code> level, <code>==</code> returns
+ * <code>true</code> only if <i>obj</i> and <i>other</i> are the
+ * same object. Typically, this method is overridden in descendant
+ * classes to provide class-specific meaning.
+ *
+ * Unlike <code>==</code>, the <code>equal?</code> method should never be
+ * overridden by subclasses: it is used to determine object identity
+ * (that is, <code>a.equal?(b)</code> iff <code>a</code> is the same
+ * object as <code>b</code>).
+ *
+ * The <code>eql?</code> method returns <code>true</code> if
+ * <i>obj</i> and <i>anObject</i> have the same value. Used by
+ * <code>Hash</code> to test members for equality. For objects of
+ * class <code>Object</code>, <code>eql?</code> is synonymous with
+ * <code>==</code>. Subclasses normally continue this tradition, but
+ * there are exceptions. <code>Numeric</code> types, for example,
+ * perform type conversion across <code>==</code>, but not across
+ * <code>eql?</code>, so:
+ *
+ * 1 == 1.0 #=> true
+ * 1.eql? 1.0 #=> false
+ */
+static mrb_value
+mrb_obj_equal_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ if (mrb_obj_equal(mrb, self, arg)) {
+ return mrb_true_value();
+ }
+ else {
+ return mrb_false_value();
+ }
+}
+
+static mrb_value
+mrb_obj_not_equal_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ if (mrb_obj_equal(mrb, self, arg)) {
+ return mrb_false_value();
+ }
+ else {
+ return mrb_true_value();
+ }
+}
+
+/* 15.3.1.3.2 */
+/*
+ * call-seq:
+ * obj === other -> true or false
+ *
+ * Case Equality---For class <code>Object</code>, effectively the same
+ * as calling <code>#==</code>, but typically overridden by descendants
+ * to provide meaningful semantics in <code>case</code> statements.
+ */
+static mrb_value
+mrb_equal_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ if (mrb_equal(mrb, self, arg)){
+ return mrb_true_value();
+ }
+ else {
+ return mrb_false_value();
+ }
+}
+
+/* 15.3.1.3.3 */
+/* 15.3.1.3.33 */
+/*
+ * call-seq:
+ * obj.hash -> fixnum
+ *
+ * Generates a <code>Fixnum</code> hash value for this object. This
+ * function must have the property that <code>a.eql?(b)</code> implies
+ * <code>a.hash == b.hash</code>. The hash value is used by class
+ * <code>Hash</code>. Any hash value that exceeds the capacity of a
+ * <code>Fixnum</code> will be truncated before being used.
+ */
+static mrb_value
+mrb_obj_id_m(mrb_state *mrb, mrb_value self)
+{
+ return mrb_fixnum_value(mrb_obj_id(self));
+}
+
+mrb_value
+send_internal(int argc, mrb_value *argv, mrb_value recv, enum call_type ctype)
+{
+ return mrb_nil_value(); /* dummy */
+}
+
+mrb_value
+mrb_f_send(int argc, mrb_value *argv, mrb_value recv)
+{
+ return send_internal(argc, argv, recv, CALL_FCALL);
+}
+
+/* 15.3.1.3.4 */
+/* 15.3.1.3.44 */
+/*
+ * call-seq:
+ * obj.send(symbol [, args...]) -> obj
+ * obj.__send__(symbol [, args...]) -> obj
+ *
+ * Invokes the method identified by _symbol_, passing it any
+ * arguments specified. You can use <code>__send__</code> if the name
+ * +send+ clashes with an existing method in _obj_.
+ *
+ * class Klass
+ * def hello(*args)
+ * "Hello " + args.join(' ')
+ * end
+ * end
+ * k = Klass.new
+ * k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
+ */
+static mrb_value
+mrb_f_send_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_f_send(argc, argv, self);
+}
+
+/* 15.3.1.2.1 */
+/* 15.3.1.3.5 */
+/*
+ * call-seq:
+ * spawn([env,] command... [,options]) -> pid
+ * Process.spawn([env,] command... [,options]) -> pid
+ *
+ * spawn executes specified command and return its pid.
+ */
+static mrb_value
+mrb_f_spawn_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return (mrb_f_send(argc, argv, self));
+}
+
+static mrb_value
+mrb_f_block_given_p(void)
+{
+ return mrb_false_value(); /* dummy */
+}
+
+/* 15.3.1.2.2 */
+/* 15.3.1.2.5 */
+/* 15.3.1.3.6 */
+/* 15.3.1.3.25 */
+/*
+ * call-seq:
+ * block_given? -> true or false
+ * iterator? -> true or false
+ *
+ * Returns <code>true</code> if <code>yield</code> would execute a
+ * block in the current context. The <code>iterator?</code> form
+ * is mildly deprecated.
+ *
+ * def try
+ * if block_given?
+ * yield
+ * else
+ * "no block"
+ * end
+ * end
+ * try #=> "no block"
+ * try { "hello" } #=> "hello"
+ * try do "hello" end #=> "hello"
+ */
+static mrb_value
+mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
+{
+ return mrb_f_block_given_p();
+}
+
+/* 15.3.1.3.7 */
+/*
+ * call-seq:
+ * obj.class -> class
+ *
+ * Returns the class of <i>obj</i>. This method must always be
+ * called with an explicit receiver, as <code>class</code> is also a
+ * reserved word in Ruby.
+ *
+ * 1.class #=> Fixnum
+ * self.class #=> Object
+ */
+static mrb_value
+mrb_obj_class_m(mrb_state *mrb, mrb_value self)
+{
+ return mrb_obj_value(mrb_obj_class(mrb, self));
+}
+
+struct RClass*
+mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
+{
+ struct RClass *klass = RBASIC(obj)->c;
+
+ //if (!FL_TEST(klass, FL_SINGLETON))
+ //return klass;
+ if (klass->tt != MRB_TT_SCLASS)
+ return klass;
+ else {
+ //struct clone_method_data data;
+ /* copy singleton(unnamed) class */
+ //VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
+ struct RClass *clone = mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
+ //clone->super = objklass->super;
+
+ if ((mrb_type(obj) == MRB_TT_CLASS) ||
+ (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
+ clone->c = clone;
+ }
+ else {
+ clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
+ }
+
+ clone->super = klass->super;
+ if (klass->iv) {
+ //clone->iv = st_copy(klass->iv);
+ clone->iv = klass->iv;
+ }
+ clone->mt = kh_init(mt, mrb);
+ clone->tt = MRB_TT_SCLASS;
+ return clone;
+ }
+}
+
+static void
+init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
+{
+ //if (OBJ_FROZEN(dest)) {
+ // rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest));
+ //}
+ //RBASIC(dest)->flags &= ~(T_MASK|FL_EXIVAR);
+ //RBASIC(dest)->flags |= RBASIC(obj)->flags & (T_MASK|FL_EXIVAR|FL_TAINT);
+ //if (FL_TEST(obj, FL_EXIVAR)) {
+ // mrb_copy_generic_ivar(dest, obj);
+ //}
+ //mrb_gc_copy_finalizer(dest, obj);
+ switch (mrb_type(obj)) {
+ case MRB_TT_OBJECT:
+ case MRB_TT_CLASS:
+ case MRB_TT_MODULE:
+ if (ROBJECT(dest)->iv) {
+ //st_free_table(ROBJECT(dest)->iv);
+ ROBJECT(dest)->iv = 0;
+ }
+ if (ROBJECT(obj)->iv) {
+ //ROBJECT(dest)->iv = st_copy((st_table *)ROBJECT(obj)->iv);
+ ROBJECT(dest)->iv = ROBJECT(obj)->iv;
+ }
+ }
+ mrb_funcall(mrb, dest, "initialize_copy", 1, obj);
+}
+
+/* 15.3.1.3.8 */
+/*
+ * call-seq:
+ * obj.clone -> an_object
+ *
+ * Produces a shallow copy of <i>obj</i>---the instance variables of
+ * <i>obj</i> are copied, but not the objects they reference. Copies
+ * the frozen and tainted state of <i>obj</i>. See also the discussion
+ * under <code>Object#dup</code>.
+ *
+ * class Klass
+ * attr_accessor :str
+ * end
+ * s1 = Klass.new #=> #<Klass:0x401b3a38>
+ * s1.str = "Hello" #=> "Hello"
+ * s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello">
+ * s2.str[1,4] = "i" #=> "i"
+ * s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
+ * s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
+ *
+ * This method may have class-specific behavior. If so, that
+ * behavior will be documented under the #+initialize_copy+ method of
+ * the class.
+ *
+ * Some Class(True False Nil Symbol Fixnum Float) Object cannot clone.
+ */
+mrb_value
+mrb_obj_clone(mrb_state *mrb, mrb_value self)
+{
+ struct RObject *clone;
+
+ if (mrb_special_const_p(self)) {
+ mrb_raise(mrb, E_TYPE_ERROR, "can't clone %s", mrb_obj_classname(mrb, self));
+ }
+ clone = mrb_obj_alloc(mrb, self.tt, mrb_obj_class(mrb, self));
+ clone->c = mrb_singleton_class_clone(mrb, self);
+ //RBASIC(clone)->flags = (RBASIC(obj)->flags | FL_TEST(clone, FL_TAINT) | FL_TEST(clone, FL_UNTRUSTED)) & ~(FL_FREEZE|FL_FINALIZE);
+ init_copy(mrb, mrb_obj_value(clone), self);
+ //1-9-2 no bug mrb_funcall(mrb, clone, "initialize_clone", 1, self);
+ //RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;
+
+ return mrb_obj_value(clone);
+}
+
+/* 15.3.1.3.9 */
+/*
+ * call-seq:
+ * obj.dup -> an_object
+ *
+ * Produces a shallow copy of <i>obj</i>---the instance variables of
+ * <i>obj</i> are copied, but not the objects they reference.
+ * <code>dup</code> copies the tainted state of <i>obj</i>. See also
+ * the discussion under <code>Object#clone</code>. In general,
+ * <code>clone</code> and <code>dup</code> may have different semantics
+ * in descendant classes. While <code>clone</code> is used to duplicate
+ * an object, including its internal state, <code>dup</code> typically
+ * uses the class of the descendant object to create the new instance.
+ *
+ * This method may have class-specific behavior. If so, that
+ * behavior will be documented under the #+initialize_copy+ method of
+ * the class.
+ */
+
+mrb_value
+mrb_obj_dup(mrb_state *mrb, mrb_value obj)
+{
+ struct RBasic *p;
+ mrb_value dup;
+
+ if (mrb_special_const_p(obj)) {
+ mrb_raise(mrb, E_TYPE_ERROR, "can't dup %s", mrb_obj_classname(mrb, obj));
+ }
+ p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
+ //init_copy(dup, obj);
+ dup = mrb_obj_value(p);
+ mrb_funcall(mrb, dup, "initialize_copy", 1, obj);
+
+ return dup;
+}
+
+/* 15.3.1.2.3 */
+/* 15.3.1.3.12 */
+/*
+ * call-seq:
+ * eval(string [, binding [, filename [,lineno]]]) -> obj
+ *
+ * Evaluates the Ruby expression(s) in <em>string</em>. If
+ * <em>binding</em> is given, which must be a <code>Binding</code>
+ * object, the evaluation is performed in its context. If the
+ * optional <em>filename</em> and <em>lineno</em> parameters are
+ * present, they will be used when reporting syntax errors.
+ *
+ * def getBinding(str)
+ * return binding
+ * end
+ * str = "hello"
+ * eval "str + ' Fred'" #=> "hello Fred"
+ * eval "str + ' Fred'", getBinding("bye") #=> "bye Fred"
+ */
+mrb_value
+mrb_f_eval(int argc, mrb_value *argv, mrb_value self)
+{
+ return mrb_false_value(); /* dummy */
+}
+mrb_value
+mrb_f_eval_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_f_eval(argc, argv, self);
+}
+
+static mrb_value
+mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
+{
+ int i;
+
+ if (argc == 0) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
+ }
+ for (i = 0; i < argc; i++) {
+ //Check_Type(argv[i], T_MODULE);
+ mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
+ }
+ while (argc--) {
+ mrb_funcall(mrb, argv[argc], "extend_object", 1, obj);
+ mrb_funcall(mrb, argv[argc], "extended", 1, obj);
+ }
+ return obj;
+}
+
+/* 15.3.1.3.13 */
+/*
+ * call-seq:
+ * obj.extend(module, ...) -> obj
+ *
+ * Adds to _obj_ the instance methods from each module given as a
+ * parameter.
+ *
+ * module Mod
+ * def hello
+ * "Hello from Mod.\n"
+ * end
+ * end
+ *
+ * class Klass
+ * def hello
+ * "Hello from Klass.\n"
+ * end
+ * end
+ *
+ * k = Klass.new
+ * k.hello #=> "Hello from Klass.\n"
+ * k.extend(Mod) #=> #<Klass:0x401b3bc8>
+ * k.hello #=> "Hello from Mod.\n"
+ */
+mrb_value
+mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_extend(mrb, argc, argv, self);
+}
+
+/* 15.3.1.2.4 */
+/* 15.3.1.3.14 */
+/*
+ * call-seq:
+ * global_variables -> array
+ *
+ * Returns an array of the names of global variables.
+ *
+ * global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
+ */
+//mrb_value
+//mrb_f_global_variables(mrb_state *mrb, mrb_value self)
+
+/* 15.3.1.3.15 */
+mrb_value
+mrb_obj_hash(mrb_state *mrb, mrb_value self)
+{
+ return mrb_fixnum_value(mrb_obj_id(self));
+}
+
+/* 15.3.1.3.16 */
+mrb_value
+mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
+{
+ mrb_value orig;
+
+ mrb_get_args(mrb, "o", &orig);
+ if (mrb_obj_equal(mrb, self, orig)) return self;
+ if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) {
+ mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object");
+ }
+ return self;
+}
+
+/* 15.3.1.3.18 */
+/*
+ * call-seq:
+ * obj.instance_eval(string [, filename [, lineno]] ) -> obj
+ * obj.instance_eval {| | block } -> obj
+ *
+ * Evaluates a string containing Ruby source code, or the given block,
+ * within the context of the receiver (_obj_). In order to set the
+ * context, the variable +self+ is set to _obj_ while
+ * the code is executing, giving the code access to _obj_'s
+ * instance variables. In the version of <code>instance_eval</code>
+ * that takes a +String+, the optional second and third
+ * parameters supply a filename and starting line number that are used
+ * when reporting compilation errors.
+ *
+ * class KlassWithSecret
+ * def initialize
+ * @secret = 99
+ * end
+ * end
+ * k = KlassWithSecret.new
+ * k.instance_eval { @secret } #=> 99
+ */
+mrb_value
+mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+ mrb_value b, klass;
+
+ mrb_get_args(mrb, "&", &b);
+ return mrb_yield_with_self(mrb, b, 0, 0, self);
+}
+
+/* 15.3.1.3.19 */
+/*
+ * call-seq:
+ * obj.instance_of?(class) -> true or false
+ *
+ * Returns <code>true</code> if <i>obj</i> is an instance of the given
+ * class. See also <code>Object#kind_of?</code>.
+ */
+mrb_value
+rb_obj_is_instance_of(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ if (mrb_obj_is_instance_of(mrb, self, mrb_class_ptr(arg))){
+ return mrb_true_value();
+ }
+ else {
+ return mrb_false_value();
+ }
+}
+
+/* 15.3.1.3.20 */
+/*
+ * call-seq:
+ * obj.instance_variable_defined?(symbol) -> true or false
+ *
+ * Returns <code>true</code> if the given instance variable is
+ * defined in <i>obj</i>.
+ *
+ * class Fred
+ * def initialize(p1, p2)
+ * @a, @b = p1, p2
+ * end
+ * end
+ * fred = Fred.new('cat', 99)
+ * fred.instance_variable_defined?(:@a) #=> true
+ * fred.instance_variable_defined?("@b") #=> true
+ * fred.instance_variable_defined?("@c") #=> false
+ */
+mrb_value
+mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+ khiter_t k;
+ kh_iv_t *h = RCLASS_IV_TBL(self);
+
+ mrb_get_args(mrb, "o", &arg);
+ mrb_sym mid = mrb_to_id(mrb, arg);
+
+ //if (!mrb_is_instance_id(id)) {
+ // mrb_name_error(id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id));
+ //}
+ //return mrb_ivar_defined(self, id);
+ k = kh_get(iv, h, mid);
+ if (k != kh_end(h)) {
+ return mrb_true_value();
+ }
+ else {
+ return mrb_false_value();
+ }
+}
+
+/* 15.3.1.3.21 */
+/*
+ * call-seq:
+ * obj.instance_variable_get(symbol) -> obj
+ *
+ * Returns the value of the given instance variable, or nil if the
+ * instance variable is not set. The <code>@</code> part of the
+ * variable name should be included for regular instance
+ * variables. Throws a <code>NameError</code> exception if the
+ * supplied symbol is not valid as an instance variable name.
+ *
+ * class Fred
+ * def initialize(p1, p2)
+ * @a, @b = p1, p2
+ * end
+ * end
+ * fred = Fred.new('cat', 99)
+ * fred.instance_variable_get(:@a) #=> "cat"
+ * fred.instance_variable_get("@b") #=> 99
+ */
+mrb_value
+mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ mrb_sym id = mrb_to_id(mrb, arg);
+
+ //if (!mrb_is_instance_id(id)) {
+ // mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id));
+ //}
+ return mrb_iv_get(mrb, self, id);
+}
+
+/* 15.3.1.3.22 */
+/*
+ * call-seq:
+ * obj.instance_variable_set(symbol, obj) -> obj
+ *
+ * Sets the instance variable names by <i>symbol</i> to
+ * <i>object</i>, thereby frustrating the efforts of the class's
+ * author to attempt to provide proper encapsulation. The variable
+ * did not have to exist prior to this call.
+ *
+ * class Fred
+ * def initialize(p1, p2)
+ * @a, @b = p1, p2
+ * end
+ * end
+ * fred = Fred.new('cat', 99)
+ * fred.instance_variable_set(:@a, 'dog') #=> "dog"
+ * fred.instance_variable_set(:@c, 'cat') #=> "cat"
+ * fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
+ */
+mrb_value
+mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
+{
+ mrb_value key;
+ mrb_value val;
+
+ mrb_get_args(mrb, "oo", &key, &val);
+ mrb_sym id = mrb_to_id(mrb, key);
+
+ //if (!mrb_is_instance_id(id)) {
+ // mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id));
+ //}
+ mrb_iv_set(mrb, self, id, val);
+ return val;
+}
+
+/* 15.3.1.3.23 */
+/*
+ * call-seq:
+ * obj.instance_variables -> array
+ *
+ * Returns an array of instance variable names for the receiver. Note
+ * that simply defining an accessor does not create the corresponding
+ * instance variable.
+ *
+ * class Fred
+ * attr_accessor :a1
+ * def initialize
+ * @iv = 3
+ * end
+ * end
+ * Fred.new.instance_variables #=> [:@iv]
+ */
+mrb_value
+mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
+{
+ mrb_value ary;
+ kh_iv_t *h = RCLASS_IV_TBL(self);
+ int i;
+ const char* p;
+
+ ary = mrb_ary_new(mrb);
+ //if (mrb_is_instance_id(key)) {
+ // mrb_ary_push(mrb, ary, mrb_sym2name(mrb, key));
+ //}
+ for (i=0;i<kh_end(h);i++) {
+ if (kh_exist(h, i)) {
+ p = mrb_sym2name(mrb, kh_key(h,i));
+ if (*p == '@') {
+ if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
+ mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, p));
+ }
+ }
+ }
+ return ary;
+}
+
+/* 15.3.1.3.24 */
+/* 15.3.1.3.26 */
+/*
+ * call-seq:
+ * obj.is_a?(class) -> true or false
+ * obj.kind_of?(class) -> true or false
+ *
+ * Returns <code>true</code> if <i>class</i> is the class of
+ * <i>obj</i>, or if <i>class</i> is one of the superclasses of
+ * <i>obj</i> or modules included in <i>obj</i>.
+ *
+ * module M; end
+ * class A
+ * include M
+ * end
+ * class B < A; end
+ * class C < B; end
+ * b = B.new
+ * b.instance_of? A #=> false
+ * b.instance_of? B #=> true
+ * b.instance_of? C #=> false
+ * b.instance_of? M #=> false
+ * b.kind_of? A #=> true
+ * b.kind_of? B #=> true
+ * b.kind_of? C #=> false
+ * b.kind_of? M #=> true
+ */
+mrb_value
+mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value arg;
+
+ mrb_get_args(mrb, "o", &arg);
+ if (mrb_obj_is_kind_of(mrb, self, mrb_class_ptr(arg))) {
+ return mrb_true_value();
+ }
+ else {
+ return mrb_false_value();
+ }
+}
+
+/* 15.3.1.2.6 */
+/* 15.3.1.3.27 */
+/*
+ * call-seq:
+ * lambda { |...| block } -> a_proc
+ *
+ * Equivalent to <code>Proc.new</code>, except the resulting Proc objects
+ * check the number of parameters passed when called.
+ */
+mrb_value
+proc_lambda(mrb_state *mrb, mrb_value self)
+{
+ //return mrb_block_lambda();
+ return mrb_nil_value(); /* dummy */
+}
+
+/* 15.3.1.2.7 */
+/* 15.3.1.3.28 */
+/*
+ * call-seq:
+ * local_variables -> array
+ *
+ * Returns the names of the current local variables.
+ *
+ * fred = 1
+ * for i in 1..10
+ * # ...
+ * end
+ * local_variables #=> [:fred, :i]
+ */
+mrb_value
+mrb_f_local_variables(mrb_state *mrb, mrb_value self)
+{
+ mrb_value ary;
+
+ ary = mrb_ary_new(mrb);
+ return ary; /* dummy */
+}
+
+/* 15.3.1.2.8 */
+/* 15.3.1.3.29 */
+/*
+ * call-seq:
+ * loop { block }
+ * loop -> an_enumerator
+ *
+ * Repeatedly executes the block.
+ *
+ * If no block is given, an enumerator is returned instead.
+ *
+ * loop do
+ * print "Input: "
+ * line = gets
+ * break if !line or line =~ /^qQ/
+ * # ...
+ * end
+ *
+ * StopIteration raised in the block breaks the loop.
+ */
+mrb_value
+mrb_f_loop(mrb_state *mrb, mrb_value self)
+{
+ return mrb_nil_value(); /* dummy */
+}
+
+static void
+method_entry_loop(mrb_state *mrb, struct RClass* klass, mrb_value ary)
+{
+ int i;
+
+ khash_t(mt) *h = klass->mt;
+ for (i=0;i<kh_end(h);i++) {
+ if (kh_exist(h, i)) {
+ mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(h,i)));
+ }
+ }
+}
+
+static mrb_value
+class_instance_method_list(mrb_state *mrb, int argc, mrb_value *argv, struct RClass* klass, int obj)
+{
+ mrb_value ary;
+ int recur;
+ //st_table *list;
+ struct RClass* oldklass;
+
+ if (argc == 0) {
+ recur = TRUE;
+ }
+ else {
+ mrb_value r;
+ mrb_get_args(mrb, "o", &r);
+ recur = mrb_test(r);
+ }
+
+ //list = st_init_numtable();
+ ary = mrb_ary_new(mrb);
+ //for (; mod; mod = RCLASS_SUPER(mod)) {
+ oldklass = 0;
+ while (klass && (klass != oldklass)) {
+ //st_foreach(RCLASS_M_TBL(mod), method_entry, (st_data_t)list);
+ method_entry_loop(mrb, klass, ary);
+ if ((klass->tt == MRB_TT_ICLASS) ||
+ (klass->tt == MRB_TT_SCLASS)) {
+ }
+ else
+ {
+ if (!recur) break;
+ }
+ oldklass = klass;
+ klass = klass->super;
+ }
+ //st_foreach(list, func, ary);
+ //st_free_table(list);
+
+ return ary;
+}
+
+mrb_value
+mrb_obj_singleton_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
+{
+ mrb_value recur, ary;
+ //st_table *list;
+ struct RClass* klass;
+
+ if (argc == 0) {
+ recur = mrb_true_value();
+ }
+ else {
+ //mrb_scan_args(argc, argv, "01", &recur);
+ recur = argv[0];
+ }
+ klass = mrb_class(mrb, obj);
+ //list = st_init_numtable();
+ ary = mrb_ary_new(mrb);
+ if (klass && (klass->tt == MRB_TT_SCLASS)) {
+ //st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);
+ method_entry_loop(mrb, klass, ary);
+ klass = klass->super;
+ }
+ if (RTEST(recur)) {
+ while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
+ //st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);
+ method_entry_loop(mrb, klass, ary);
+ klass = klass->super;
+ }
+ }
+ //st_foreach(list, ins_methods_i, ary);
+ //st_free_table(list);
+
+ return ary;
+}
+
+mrb_value
+mrb_obj_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj, mrb_method_flag_t flag)
+{
+retry:
+ if (argc == 0) {
+ mrb_value args[1];
+
+ args[0] = mrb_true_value();
+ return class_instance_method_list(mrb, argc, argv, mrb_class(mrb, obj), 0);
+ }
+ else {
+ mrb_value recur;
+
+ //mrb_scan_args(argc, argv, "1", &recur);
+ recur = argv[0];
+ if (mrb_test(recur)) {
+ argc = 0;
+ goto retry;
+ }
+ return mrb_obj_singleton_methods(mrb, argc, argv, obj);
+ }
+}
+/* 15.3.1.3.31 */
+/*
+ * call-seq:
+ * obj.methods -> array
+ *
+ * Returns a list of the names of methods publicly accessible in
+ * <i>obj</i>. This will include all the methods accessible in
+ * <i>obj</i>'s ancestors.
+ *
+ * class Klass
+ * def kMethod()
+ * end
+ * end
+ * k = Klass.new
+ * k.methods[0..9] #=> [:kMethod, :freeze, :nil?, :is_a?,
+ * # :class, :instance_variable_set,
+ * # :methods, :extend, :__send__, :instance_eval]
+ * k.methods.length #=> 42
+ */
+mrb_value
+mrb_obj_methods_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_methods(mrb, argc, argv, self, 0); /* everything but private */
+}
+
+/* 15.3.1.3.32 */
+/*
+ * call_seq:
+ * nil.nil? -> true
+ * <anything_else>.nil? -> false
+ *
+ * Only the object <i>nil</i> responds <code>true</code> to <code>nil?</code>.
+ */
+mrb_value
+mrb_false(mrb_state *mrb, mrb_value self)
+{
+ return mrb_false_value();
+}
+
+/* 15.3.1.2.10 */
+/* 15.3.1.3.35 */
+/*
+ * call-seq:
+ * print(obj, ...) -> nil
+ *
+ * Prints each object in turn to <code>$stdout</code>. If the output
+ * field separator (<code>$,</code>) is not +nil+, its
+ * contents will appear between each field. If the output record
+ * separator (<code>$\\</code>) is not +nil+, it will be
+ * appended to the output. If no arguments are given, prints
+ * <code>$_</code>. Objects that aren't strings will be converted by
+ * calling their <code>to_s</code> method.
+ *
+ * print "cat", [1,2,3], 99, "\n"
+ * $, = ", "
+ * $\ = "\n"
+ * print "cat", [1,2,3], 99
+ *
+ * <em>produces:</em>
+ *
+ * cat12399
+ * cat, 1, 2, 3, 99
+ */
+
+/* 15.3.1.3.36 */
+/*
+ * call-seq:
+ * obj.private_methods(all=true) -> array
+ *
+ * Returns the list of private methods accessible to <i>obj</i>. If
+ * the <i>all</i> parameter is set to <code>false</code>, only those methods
+ * in the receiver will be listed.
+ */
+mrb_value
+mrb_obj_private_methods(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_methods(mrb, argc, argv, self, NOEX_PRIVATE); /* private attribute not define */
+}
+
+/* 15.3.1.3.37 */
+/*
+ * call-seq:
+ * obj.protected_methods(all=true) -> array
+ *
+ * Returns the list of protected methods accessible to <i>obj</i>. If
+ * the <i>all</i> parameter is set to <code>false</code>, only those methods
+ * in the receiver will be listed.
+ */
+mrb_value
+mrb_obj_protected_methods(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_methods(mrb, argc, argv, self, NOEX_PROTECTED); /* protected attribute not define */
+}
+
+/* 15.3.1.3.38 */
+/*
+ * call-seq:
+ * obj.public_methods(all=true) -> array
+ *
+ * Returns the list of public methods accessible to <i>obj</i>. If
+ * the <i>all</i> parameter is set to <code>false</code>, only those methods
+ * in the receiver will be listed.
+ */
+mrb_value
+mrb_obj_public_methods(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_methods(mrb, argc, argv, self, NOEX_PUBLIC); /* public attribute not define */
+}
+
+/* 15.3.1.2.11 */
+/* 15.3.1.3.39 */
+/*
+ * call-seq:
+ * puts(obj, ...) -> nil
+ *
+ * Equivalent to
+ *
+ * $stdout.puts(obj, ...)
+ */
+
+static mrb_value
+get_errinfo(mrb_state *mrb)
+{
+ //return get_thread_errinfo(GET_THREAD());
+ return mrb_str_new_cstr(mrb, "error!!"); /* dummy */
+}
+
+/* 15.3.1.2.12 */
+/* 15.3.1.3.40 */
+/*
+ * call-seq:
+ * raise
+ * raise(string)
+ * raise(exception [, string [, array]])
+ * fail
+ * fail(string)
+ * fail(exception [, string [, array]])
+ *
+ * With no arguments, raises the exception in <code>$!</code> or raises
+ * a <code>RuntimeError</code> if <code>$!</code> is +nil+.
+ * With a single +String+ argument, raises a
+ * +RuntimeError+ with the string as a message. Otherwise,
+ * the first parameter should be the name of an +Exception+
+ * class (or an object that returns an +Exception+ object when sent
+ * an +exception+ message). The optional second parameter sets the
+ * message associated with the exception, and the third parameter is an
+ * array of callback information. Exceptions are caught by the
+ * +rescue+ clause of <code>begin...end</code> blocks.
+ *
+ * raise "Failed to create socket"
+ * raise ArgumentError, "No parameters", caller
+ */
+mrb_value
+mrb_f_raise(mrb_state *mrb, mrb_value self)
+{
+ mrb_value err;
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ if (argc == 0) {
+ err = get_errinfo(mrb);
+ if (!mrb_nil_p(err)) {
+ argc = 1;
+ argv[0] = err;
+ }
+ }
+ mrb_exc_raise(mrb, mrb_make_exception(mrb, argc, argv));
+ return mrb_nil_value(); /* not reached */
+}
+
+/* 15.3.1.3.41 */
+/*
+ * call-seq:
+ * obj.remove_instance_variable(symbol) -> obj
+ *
+ * Removes the named instance variable from <i>obj</i>, returning that
+ * variable's value.
+ *
+ * class Dummy
+ * attr_reader :var
+ * def initialize
+ * @var = 99
+ * end
+ * def remove
+ * remove_instance_variable(:@var)
+ * end
+ * end
+ * d = Dummy.new
+ * d.var #=> 99
+ * d.remove #=> 99
+ * d.var #=> nil
+ */
+mrb_value
+mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self)
+{
+ mrb_sym sym;
+ mrb_value name;
+ khash_t(iv) *h;
+ khiter_t k;
+ mrb_value val;
+ mrb_value Qundef = mrb_undef_value();
+
+ mrb_get_args(mrb, "o", &name);
+ sym = mrb_to_id(mrb, name);
+ //if (OBJ_FROZEN(obj)) mrb_error_frozen("object");
+ //if (!mrb_is_instance_id(id)) {
+ // mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id));
+ //}
+ switch (mrb_type(self)) {
+ case MRB_TT_OBJECT:
+ case MRB_TT_CLASS:
+ case MRB_TT_MODULE:
+ if (!mrb_obj_ptr(self)->iv) break;
+ h = mrb_obj_ptr(self)->iv;
+ k = kh_get(iv, h, sym);
+ if (k != kh_end(h)) {
+ val = kh_value(h, k);
+ if (!mrb_obj_equal(mrb, val, Qundef)) {
+ kh_value(h, k) = Qundef;
+ return val;
+ }
+ }
+ break;
+ //default:
+ // if (mrb_special_const_p(obj)) {
+ // v = val;
+ // if (generic_ivar_remove(obj, (st_data_t)id, &v)) {
+ // return (VALUE)v;
+ // }
+ // }
+ // break;
+ }
+ mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym));
+ return mrb_nil_value(); /* not reached */
+}
+
+/* 15.3.1.2.13 */
+/* 15.3.1.3.42 */
+/*
+ * call-seq:
+ * require(string) -> true or false
+ *
+ * Ruby tries to load the library named _string_, returning
+ * +true+ if successful. If the filename does not resolve to
+ * an absolute path, it will be searched for in the directories listed
+ * in <code>$:</code>. If the file has the extension ``.rb'', it is
+ * loaded as a source file; if the extension is ``.so'', ``.o'', or
+ * ``.dll'', or whatever the default shared library extension is on
+ * the current platform, Ruby loads the shared library as a Ruby
+ * extension. Otherwise, Ruby tries adding ``.rb'', ``.so'', and so on
+ * to the name. The name of the loaded feature is added to the array in
+ * <code>$"</code>. A feature will not be loaded if its name already
+ * appears in <code>$"</code>. The file name is converted to an absolute
+ * path, so ``<code>require 'a'; require './a'</code>'' will not load
+ * <code>a.rb</code> twice.
+ *
+ * require "my-library.rb"
+ * require "db-driver"
+ */
+mrb_value
+mrb_f_require(mrb_state *mrb, mrb_value self)
+{
+ mrb_value fname;
+
+ mrb_get_args(mrb, "o", &fname);
+ return mrb_nil_value(); /* dummy */
+}
+
+
+static inline int
+basic_obj_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym id, int pub)
+{
+ return mrb_respond_to(mrb, obj, id);
+ //return TRUE;
+}
+/* 15.3.1.3.43 */
+/*
+ * call-seq:
+ * obj.respond_to?(symbol, include_private=false) -> true or false
+ *
+ * Returns +true+ if _obj_ responds to the given
+ * method. Private methods are included in the search only if the
+ * optional second parameter evaluates to +true+.
+ *
+ * If the method is not implemented,
+ * as Process.fork on Windows, File.lchmod on GNU/Linux, etc.,
+ * false is returned.
+ *
+ * If the method is not defined, <code>respond_to_missing?</code>
+ * method is called and the result is returned.
+ */
+mrb_value
+obj_respond_to(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+ mrb_value mid, priv;
+ mrb_sym id;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ //mrb_scan_args(argc, argv, "11", &mid, &priv);
+ mid = argv[0];
+ if (argc > 1) priv = argv[1];
+ else priv = mrb_nil_value();
+ id = mrb_to_id(mrb, mid);
+ if (basic_obj_respond_to(mrb, self, id, !RTEST(priv)))
+ return mrb_true_value();
+ return mrb_false_value();
+}
+
+/* 15.3.1.3.45 */
+/*
+ * call-seq:
+ * obj.singleton_methods(all=true) -> array
+ *
+ * Returns an array of the names of singleton methods for <i>obj</i>.
+ * If the optional <i>all</i> parameter is true, the list will include
+ * methods in modules included in <i>obj</i>.
+ * Only public and protected singleton methods are returned.
+ *
+ * module Other
+ * def three() end
+ * end
+ *
+ * class Single
+ * def Single.four() end
+ * end
+ *
+ * a = Single.new
+ *
+ * def a.one()
+ * end
+ *
+ * class << a
+ * include Other
+ * def two()
+ * end
+ * end
+ *
+ * Single.singleton_methods #=> [:four]
+ * a.singleton_methods(false) #=> [:two, :one]
+ * a.singleton_methods #=> [:two, :one, :three]
+ */
+mrb_value
+mrb_obj_singleton_methods_m(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ int argc;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+ return mrb_obj_singleton_methods(mrb, argc, argv, self);
+}
+
+mrb_value mrb_f_sprintf(mrb_state *mrb, mrb_value obj); /* in sprintf.c */
+
+void
+mrb_init_kernel(mrb_state *mrb)
+{
+ struct RClass *krn;
+
+ krn = mrb->kernel_module = mrb_define_module(mrb, "Kernel");
+ mrb_define_class_method(mrb, krn, "'", mrb_f_spawn_m, ARGS_ANY()); /* 15.3.1.2.1 */
+ mrb_define_class_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.2 */
+ mrb_define_class_method(mrb, krn, "eval", mrb_f_eval_m, ARGS_ANY()); /* 15.3.1.2.3 */
+ mrb_define_class_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.2.4 */
+ mrb_define_class_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.5 */
+ mrb_define_class_method(mrb, krn, "lambda", proc_lambda, ARGS_NONE()); /* 15.3.1.2.6 */
+ mrb_define_class_method(mrb, krn, "local_variables", mrb_f_local_variables, ARGS_NONE()); /* 15.3.1.2.7 */
+ mrb_define_class_method(mrb, krn, "loop", mrb_f_loop, ARGS_NONE()); /* 15.3.1.2.8 */
+; /* 15.3.1.2.11 */
+ mrb_define_class_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.2.12 */
+ mrb_define_class_method(mrb, krn, "require", mrb_f_require, ARGS_REQ(1)); /* 15.3.1.2.13 */
+
+ mrb_define_method(mrb, krn, "singleton_class", mrb_singleton_class, ARGS_NONE());
+
+ mrb_define_method(mrb, krn, "==", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.1 */
+ mrb_define_method(mrb, krn, "!=", mrb_obj_not_equal_m, ARGS_REQ(1));
+ mrb_define_method(mrb, krn, "===", mrb_equal_m, ARGS_REQ(1)); /* 15.3.1.3.2 */
+ mrb_define_method(mrb, krn, "__id__", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.3 */
+ mrb_define_method(mrb, krn, "__send__", mrb_f_send_m, ARGS_ANY()); /* 15.3.1.3.4 */
+ mrb_define_method(mrb, krn, "'", mrb_f_spawn_m, ARGS_ANY()); /* 15.3.1.3.5 *//* "spawn"->"'" */
+ mrb_define_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.6 */
+ mrb_define_method(mrb, krn, "class", mrb_obj_class_m, ARGS_NONE()); /* 15.3.1.3.7 */
+ mrb_define_method(mrb, krn, "clone", mrb_obj_clone, ARGS_NONE()); /* 15.3.1.3.8 */
+ mrb_define_method(mrb, krn, "dup", mrb_obj_dup, ARGS_NONE()); /* 15.3.1.3.9 */
+ mrb_define_method(mrb, krn, "eql?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.10 */
+ mrb_define_method(mrb, krn, "equal?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.11 */
+ mrb_define_method(mrb, krn, "eval", mrb_f_eval_m, ARGS_ANY()); /* 15.3.1.3.12 */
+ mrb_define_method(mrb, krn, "extend", mrb_obj_extend_m, ARGS_ANY()); /* 15.3.1.3.13 */
+ mrb_define_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.3.14 */
+ mrb_define_method(mrb, krn, "hash", mrb_obj_hash, ARGS_NONE()); /* 15.3.1.3.15 */
+ mrb_define_method(mrb, krn, "initialize_copy", mrb_obj_init_copy, ARGS_REQ(1)); /* 15.3.1.3.16 */
+ mrb_define_method(mrb, krn, "inspect", mrb_obj_inspect, ARGS_NONE()); /* 15.3.1.3.17 */
+ mrb_define_method(mrb, krn, "instance_eval", mrb_obj_instance_eval, ARGS_ANY()); /* 15.3.1.3.18 */
+ mrb_define_method(mrb, krn, "instance_of?", rb_obj_is_instance_of, ARGS_REQ(1)); /* 15.3.1.3.19 */
+ mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined, ARGS_REQ(1)); /* 15.3.1.3.20 */
+ mrb_define_method(mrb, krn, "instance_variable_get", mrb_obj_ivar_get, ARGS_REQ(1)); /* 15.3.1.3.21 */
+ mrb_define_method(mrb, krn, "instance_variable_set", mrb_obj_ivar_set, ARGS_REQ(2)); /* 15.3.1.3.22 */
+ mrb_define_method(mrb, krn, "instance_variables", mrb_obj_instance_variables, ARGS_NONE()); /* 15.3.1.3.23 */
+ mrb_define_method(mrb, krn, "is_a?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.24 */
+ mrb_define_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.25 */
+ mrb_define_method(mrb, krn, "kind_of?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.26 */
+ mrb_define_method(mrb, krn, "lambda", proc_lambda, ARGS_NONE()); /* 15.3.1.3.27 */
+ mrb_define_method(mrb, krn, "local_variables", mrb_f_local_variables, ARGS_NONE()); /* 15.3.1.3.28 */
+ mrb_define_method(mrb, krn, "loop", mrb_f_loop, ARGS_NONE()); /* 15.3.1.3.29 */
+ mrb_define_method(mrb, krn, "methods", mrb_obj_methods_m, ARGS_ANY()); /* 15.3.1.3.31 */
+ mrb_define_method(mrb, krn, "nil?", mrb_false, ARGS_NONE()); /* 15.3.1.3.32 */
+ mrb_define_method(mrb, krn, "object_id", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.33 */
+ mrb_define_method(mrb, krn, "private_methods", mrb_obj_private_methods, ARGS_ANY()); /* 15.3.1.3.36 */
+ mrb_define_method(mrb, krn, "protected_methods", mrb_obj_protected_methods, ARGS_ANY()); /* 15.3.1.3.37 */
+ mrb_define_method(mrb, krn, "public_methods", mrb_obj_public_methods, ARGS_ANY()); /* 15.3.1.3.38 */
+ mrb_define_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.3.40 */
+ mrb_define_method(mrb, krn, "remove_instance_variable", mrb_obj_remove_instance_variable,ARGS_REQ(1)); /* 15.3.1.3.41 */
+ mrb_define_method(mrb, krn, "require", mrb_f_require, ARGS_REQ(1)); /* 15.3.1.3.42 */
+ mrb_define_method(mrb, krn, "respond_to?", obj_respond_to, ARGS_ANY()); /* 15.3.1.3.43 */
+ mrb_define_method(mrb, krn, "send", mrb_f_send_m, ARGS_ANY()); /* 15.3.1.3.44 */
+ mrb_define_method(mrb, krn, "singleton_methods", mrb_obj_singleton_methods_m, ARGS_ANY()); /* 15.3.1.3.45 */
+ mrb_define_method(mrb, krn, "to_s", mrb_any_to_s, ARGS_NONE()); /* 15.3.1.3.46 */
+
+ mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
+ mrb_define_method(mrb, krn, "format", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
+
+ mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-15 01:58:06 +0000