/*

** mruby - An embeddable Ruby implementation

**

** Copyright (c) mruby developers 2010-

**

** Permission is hereby granted, free of charge, to any person obtaining

** a copy of this software and associated documentation files (the

** "Software"), to deal in the Software without restriction, including

** without limitation the rights to use, copy, modify, merge, publish,

** distribute, sublicense, and/or sell copies of the Software, and to

** permit persons to whom the Software is furnished to do so, subject to

** the following conditions:

**

** The above copyright notice and this permission notice shall be

** included in all copies or substantial portions of the Software.

**

** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

**

** [ MIT license: https://www.opensource.org/licenses/mit-license.php ]

*/

/**

* @file mruby.h

*/

#ifndef MRUBY_H

#define MRUBY_H

#ifdef __cplusplus

#define __STDC_LIMIT_MACROS

#define __STDC_CONSTANT_MACROS

#define __STDC_FORMAT_MACROS

#endif

#include <stdarg.h>

#include <stdint.h>

#include <stddef.h>

#include <limits.h>

#ifdef __cplusplus

#ifndef UINTPTR_MAX

#error Must be placed `#include <mruby.h>` before `#include <stdint.h>`

#endif

#ifndef SIZE_MAX

#ifdef __SIZE_MAX__

#define SIZE_MAX __SIZE_MAX__

#else

#define SIZE_MAX std::numeric_limits<size_t>::max()

#endif

#endif

#endif

#ifdef _MSC_VER

# define __func__ __FUNCTION__

#endif

#ifdef MRB_DEBUG

#include <assert.h>

#define mrb_assert(p) assert(p)

#define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))

#else

#define mrb_assert(p) ((void)0)

#define mrb_assert_int_fit(t1,n,t2,max) ((void)0)

#endif

#if (defined __cplusplus && __cplusplus >= 201703L)

# define mrb_static_assert(...) static_assert(__VA_ARGS__)

# define mrb_static_assert1(exp) static_assert(exp)

# define mrb_static_assert2(exp, str) static_assert(exp, str)

#elif (defined __cplusplus && __cplusplus >= 201103L) || \

(defined _MSC_VER) || \

(defined __GXX_EXPERIMENTAL_CXX0X__) /* for old G++/Clang++ */

# define mrb_static_assert2(exp, str) static_assert(exp, str)

#elif defined __STDC_VERSION__ && \

((__STDC_VERSION__ >= 201112L) || \

(defined __GNUC__ && __GNUC__ * 100 + __GNUC_MINOR__ >= 406))

# define mrb_static_assert2(exp, str) _Static_assert(exp, str)

#else

# /* alternative implementation of static_assert() */

# define _mrb_static_assert_cat0(a, b) a##b

# define _mrb_static_assert_cat(a, b) _mrb_static_assert_cat0(a, b)

# ifdef __COUNTER__

# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __COUNTER__)

# else

# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __LINE__)

# endif

# define mrb_static_assert2(exp, str) \

struct _mrb_static_assert_id(_mrb_static_assert_) { char x[(exp) ? 1 : -1]; }

#endif

#ifndef mrb_static_assert

# define mrb_static_assert1(exp) mrb_static_assert2(exp, #exp)

# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */

# define mrb_static_assert_selector(a, b, name, ...) name

/**

* The `mrb_static_assert()` macro function takes one or two arguments.

*

* !!!c

* mrb_static_assert(expect_condition);

* mrb_static_assert(expect_condition, error_message);

*/

# define mrb_static_assert(...) \

mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__))

#endif

#define mrb_static_assert_powerof2(num) mrb_static_assert((num) > 0 && (num) == ((num) & -(num)), "need power of 2 for " #num)

#include "mrbconf.h"

#include <mruby/common.h>

#include <mruby/value.h>

#include <mruby/gc.h>

#include <mruby/version.h>

#ifndef MRB_NO_FLOAT

#include <math.h>

#include <float.h>

#ifndef FLT_EPSILON

#define FLT_EPSILON (1.19209290e-07f)

#endif

#ifndef DBL_EPSILON

#define DBL_EPSILON ((double)2.22044604925031308085e-16L)

#endif

#ifndef LDBL_EPSILON

#define LDBL_EPSILON (1.08420217248550443401e-19L)

#endif

#ifdef MRB_USE_FLOAT32

#define MRB_FLOAT_EPSILON FLT_EPSILON

#else

#define MRB_FLOAT_EPSILON DBL_EPSILON

#endif

#endif

/**

* mruby C API entry point

*/

MRB_BEGIN_DECL

typedef uint8_t mrb_code;

/**

* \class mrb_aspec

*

* Specifies the number of arguments a function takes

*

* Example: `MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1)` for a method that expects 2..3 arguments

*/

typedef uint32_t mrb_aspec;

typedef struct mrb_irep mrb_irep;

struct mrb_state;

#ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE

#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5

#endif

typedef struct {

uint8_t n:4; /* (15=*) c=n|nk<<4 */

uint8_t nk:4; /* (15=*) */

uint8_t cci; /* called from C function */

uint8_t vis; /* 5(ZERO):1(separate module):2(method visibility) */

/* under 3-bit flags are copied to env, and after that, env takes precedence */

mrb_sym mid;

const struct RProc *proc;

struct RProc *blk;

mrb_value *stack;

const mrb_code *pc; /* current address on iseq of this proc */

union {

struct REnv *env;

struct RClass *target_class;

const void *keep_context; /* if NULL, it means that the fiber has switched; for internal use */

} u;

} mrb_callinfo;

enum mrb_fiber_state {

MRB_FIBER_CREATED = 0,

MRB_FIBER_RUNNING,

MRB_FIBER_RESUMED,

MRB_FIBER_SUSPENDED,

MRB_FIBER_TRANSFERRED,

MRB_FIBER_TERMINATED,

};

/* Task context status aliases */

#define MRB_TASK_CREATED MRB_FIBER_CREATED

#define MRB_TASK_STOPPED MRB_FIBER_TERMINATED

struct mrb_context {

struct mrb_context *prev;

mrb_value *stbase, *stend; /* stack of virtual machine */

mrb_callinfo *ci;

mrb_callinfo *cibase, *ciend;

enum mrb_fiber_state status : 4;

mrb_bool vmexec : 1;

struct RFiber *fib;

};

#ifdef MRB_METHOD_CACHE_SIZE

# undef MRB_NO_METHOD_CACHE

mrb_static_assert_powerof2(MRB_METHOD_CACHE_SIZE);

#else

/* default method cache size: 256 */

/* cache size needs to be power of 2 */

# define MRB_METHOD_CACHE_SIZE (1<<8)

#endif

/**

* Function pointer type for a function callable by mruby.

*

* The arguments to the function are stored on the mrb_state. To get them see mrb_get_args

*

* @param mrb The mruby state

* @param self The self object

* @return [mrb_value] The function's return value

*/

typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self);

typedef struct {

uint32_t flags; /* compatible with mt keys in class.c */

union {

const struct RProc *proc;

mrb_func_t func;

} as;

} mrb_method_t;

#ifndef MRB_NO_METHOD_CACHE

struct mrb_cache_entry {

struct RClass *c, *c0;

/* mrb_sym mid; // mid is stored in mrb_method_t::flags */

mrb_method_t m;

};

#endif

struct mrb_jmpbuf;

typedef void (*mrb_atexit_func)(struct mrb_state*);

#ifdef MRB_USE_TASK_SCHEDULER

struct mrb_task;

typedef struct mrb_task_state {

struct mrb_task *queues[4]; /* Task queues (dormant, ready, waiting, suspended) */

volatile uint32_t tick; /* Current tick count */

volatile uint32_t wakeup_tick; /* Next wakeup tick */

volatile mrb_bool switching; /* Context switch pending flag */

struct mrb_task *main_task; /* Main task wrapper for root context */

} mrb_task_state;

#endif

typedef struct mrb_state {

struct mrb_jmpbuf *jmp;

struct mrb_context *c;

struct mrb_context *root_c;

struct iv_tbl *globals; /* global variable table */

struct RObject *exc; /* exception */

struct RObject *top_self;

struct RClass *object_class; /* Object class */

struct RClass *class_class;

struct RClass *module_class;

struct RClass *proc_class;

struct RClass *string_class;

struct RClass *array_class;

struct RClass *hash_class;

struct RClass *range_class;

#ifndef MRB_NO_FLOAT

struct RClass *float_class;

#endif

struct RClass *integer_class;

struct RClass *true_class;

struct RClass *false_class;

struct RClass *nil_class;

struct RClass *symbol_class;

struct RClass *kernel_module;

mrb_gc gc;

mrb_bool bootstrapping;

#ifndef MRB_NO_METHOD_CACHE

struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE];

#endif

mrb_sym symidx;

const char **symtbl;

size_t symcapa;

struct mrb_sym_hash_table *symhash;

#ifndef MRB_USE_ALL_SYMBOLS

char symbuf[8]; /* buffer for small symbol names */

#endif

#ifdef MRB_USE_DEBUG_HOOK

void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);

void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);

#endif

#ifdef MRB_BYTECODE_DECODE_OPTION

mrb_code (*bytecode_decoder)(struct mrb_state* mrb, mrb_code code);

#endif

struct RClass *eException_class;

struct RClass *eStandardError_class;

struct RObject *nomem_err; /* pre-allocated NoMemoryError */

struct RObject *stack_err; /* pre-allocated SystemStackError */

#ifdef MRB_GC_FIXED_ARENA

struct RObject *arena_err; /* pre-allocated arena overflow error */

#endif

void *ud; /* auxiliary data */

#ifdef MRB_FIXED_STATE_ATEXIT_STACK

mrb_atexit_func atexit_stack[MRB_FIXED_STATE_ATEXIT_STACK_SIZE];

#else

mrb_atexit_func *atexit_stack;

#endif

uint16_t atexit_stack_len;

#ifdef MRB_USE_TASK_SCHEDULER

mrb_task_state task; /* Task scheduler state */

#endif

} mrb_state;

/**

* Defines a new class.

*

* If you're creating a gem it may look something like this:

*

* !!!c

* void mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_class;

* example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class);

* }

*

* void mrb_example_gem_final(mrb_state* mrb) {

* //free(TheAnimals);

* }

*

* @param mrb The current mruby state.

* @param name The name of the defined class.

* @param super The new class parent.

* @return [struct RClass *] Reference to the newly defined class.

* @see mrb_define_class_under

*/

MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super);

MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super);

/**

* Defines a new module.

*

* @param mrb The current mruby state.

* @param name The name of the module.

* @return [struct RClass *] Reference to the newly defined module.

*/

MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name);

MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name);

/**

* Returns the singleton class of an object.

*

* Raises a `TypeError` exception for immediate values.

*/

MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val);

/**

* Returns the singleton class of an object.

*

* Returns `NULL` for immediate values,

*/

MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val);

/**

* Include a module in another class or module.

* Equivalent to:

*

* module B

* include A

* end

* @param mrb The current mruby state.

* @param cla A reference to module or a class.

* @param included A reference to the module to be included.

*/

MRB_API void mrb_include_module(mrb_state *mrb, struct RClass *cla, struct RClass *included);

/**

* Prepends a module in another class or module.

*

* Equivalent to:

* module B

* prepend A

* end

* @param mrb The current mruby state.

* @param cla A reference to module or a class.

* @param prepended A reference to the module to be prepended.

*/

MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClass *prepended);

/**

* Defines a global function in Ruby.

*

* If you're creating a gem it may look something like this

*

* Example:

*

* mrb_value example_method(mrb_state* mrb, mrb_value self)

* {

* puts("Executing example command!");

* return self;

* }

*

* void mrb_example_gem_init(mrb_state* mrb)

* {

* mrb_define_method(mrb, mrb->kernel_module, "example_method", example_method, MRB_ARGS_NONE());

* }

*

* @param mrb The mruby state reference.

* @param cla The class pointer where the method will be defined.

* @param name The name of the method being defined.

* @param func The function pointer to the method definition.

* @param aspec The method parameters declaration.

*/

MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);

MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);

MRB_API void mrb_define_private_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);

MRB_API void mrb_define_private_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);

/**

* Defines a class method.

*

* Example:

*

* # Ruby style

* class Foo

* def Foo.bar

* end

* end

* // C style

* mrb_value bar_method(mrb_state* mrb, mrb_value self){

* return mrb_nil_value();

* }

* void mrb_example_gem_init(mrb_state* mrb){

* struct RClass *foo;

* foo = mrb_define_class(mrb, "Foo", mrb->object_class);

* mrb_define_class_method(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());

* }

* @param mrb The mruby state reference.

* @param cla The class where the class method will be defined.

* @param name The name of the class method being defined.

* @param fun The function pointer to the class method definition.

* @param aspec The method parameters declaration.

*/

MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);

MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);

/**

* Defines a singleton method

*

* @see mrb_define_class_method

*/

MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);

MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);

/**

* Defines a module function.

*

* Example:

*

* # Ruby style

* module Foo

* def Foo.bar

* end

* end

* // C style

* mrb_value bar_method(mrb_state* mrb, mrb_value self){

* return mrb_nil_value();

* }

* void mrb_example_gem_init(mrb_state* mrb){

* struct RClass *foo;

* foo = mrb_define_module(mrb, "Foo");

* mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE());

* }

* @param mrb The mruby state reference.

* @param cla The module where the module function will be defined.

* @param name The name of the module function being defined.

* @param fun The function pointer to the module function definition.

* @param aspec The method parameters declaration.

*/

MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);

MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);

/**

* Defines a constant.

*

* Example:

*

* # Ruby style

* class ExampleClass

* AGE = 22

* end

* // C style

* #include <stdio.h>

* #include <mruby.h>

*

* void

* mrb_example_gem_init(mrb_state* mrb){

* mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22));

* }

*

* mrb_value

* mrb_example_gem_final(mrb_state* mrb){

* }

* @param mrb The mruby state reference.

* @param cla A class or module the constant is defined in.

* @param name The name of the constant being defined.

* @param val The value for the constant.

*/

MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val);

MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val);

/**

* Undefines a method.

*

* Example:

*

* # Ruby style

*

* class ExampleClassA

* def example_method

* "example"

* end

* end

* ExampleClassA.new.example_method # => example

*

* class ExampleClassB < ExampleClassA

* undef_method :example_method

* end

*

* ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError)

*

* // C style

* #include <stdio.h>

* #include <mruby.h>

*

* mrb_value

* mrb_example_method(mrb_state *mrb){

* return mrb_str_new_lit(mrb, "example");

* }

*

* void

* mrb_example_gem_init(mrb_state* mrb){

* struct RClass *example_class_a;

* struct RClass *example_class_b;

* struct RClass *example_class_c;

*

* example_class_a = mrb_define_class(mrb, "ExampleClassA", mrb->object_class);

* mrb_define_method(mrb, example_class_a, "example_method", mrb_example_method, MRB_ARGS_NONE());

* example_class_b = mrb_define_class(mrb, "ExampleClassB", example_class_a);

* example_class_c = mrb_define_class(mrb, "ExampleClassC", example_class_b);

* mrb_undef_method(mrb, example_class_c, "example_method");

* }

*

* mrb_example_gem_final(mrb_state* mrb){

* }

* @param mrb The mruby state reference.

* @param cla The class the method will be undefined from.

* @param name The name of the method to be undefined.

*/

MRB_API void mrb_undef_method(mrb_state *mrb, struct RClass *cla, const char *name);

MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);

/**

* Undefine a class method.

* Example:

*

* # Ruby style

* class ExampleClass

* def self.example_method

* "example"

* end

* end

*

* ExampleClass.example_method

*

* // C style

* #include <stdio.h>

* #include <mruby.h>

*

* mrb_value

* mrb_example_method(mrb_state *mrb){

* return mrb_str_new_lit(mrb, "example");

* }

*

* void

* mrb_example_gem_init(mrb_state* mrb){

* struct RClass *example_class;

* example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);

* mrb_define_class_method(mrb, example_class, "example_method", mrb_example_method, MRB_ARGS_NONE());

* mrb_undef_class_method(mrb, example_class, "example_method");

* }

*

* void

* mrb_example_gem_final(mrb_state* mrb){

* }

* @param mrb The mruby state reference.

* @param cls A class the class method will be undefined from.

* @param name The name of the class method to be undefined.

*/

MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name);

MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name);

/**

* Initialize a new object instance of c class.

*

* Example:

*

* # Ruby style

* class ExampleClass

* end

*

* p ExampleClass # => #<ExampleClass:0x9958588>

* // C style

* #include <stdio.h>

* #include <mruby.h>

*

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_class;

* mrb_value obj;

* example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); # => class ExampleClass; end

* obj = mrb_obj_new(mrb, example_class, 0, NULL); # => ExampleClass.new

* mrb_p(mrb, obj); // => Kernel#p

* }

* @param mrb The current mruby state.

* @param c Reference to the class of the new object.

* @param argc Number of arguments in argv

* @param argv Array of mrb_value to initialize the object

* @return [mrb_value] The newly initialized object

*/

MRB_API mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);

/** @see mrb_obj_new */

MRB_INLINE mrb_value mrb_class_new_instance(mrb_state *mrb, mrb_int argc, const mrb_value *argv, struct RClass *c)

{

return mrb_obj_new(mrb,c,argc,argv);

}

/**

* Creates a new instance of Class, Class.

*

* Example:

*

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_class;

*

* mrb_value obj;

* example_class = mrb_class_new(mrb, mrb->object_class);

* obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#<Class:0x9a945b8>:0x9a94588>

* mrb_p(mrb, obj); // => Kernel#p

* }

*

* @param mrb The current mruby state.

* @param super The super class or parent.

* @return [struct RClass *] Reference to the new class.

*/

MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);

/**

* Creates a new module, Module.

*

* Example:

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_module;

*

* example_module = mrb_module_new(mrb);

* }

*

* @param mrb The current mruby state.

* @return [struct RClass *] Reference to the new module.

*/

MRB_API struct RClass * mrb_module_new(mrb_state *mrb);

/**

* Returns an mrb_bool. True if class was defined, and false if the class was not defined.

*

* Example:

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_class;

* mrb_bool cd;

*

* example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);

* cd = mrb_class_defined(mrb, "ExampleClass");

*

* // If mrb_class_defined returns TRUE then puts "True"

* // If mrb_class_defined returns FALSE then puts "False"

* if (cd) {

* puts("True");

* }

* else {

* puts("False");

* }

* }

*

* @param mrb The current mruby state.

* @param name A string representing the name of the class.

* @return [mrb_bool] A boolean value.

*/

MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);

MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name);

/**

* Gets a class.

* @param mrb The current mruby state.

* @param name The name of the class.

* @return [struct RClass *] A reference to the class.

*/

MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name);

MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name);

/**

* Gets a exception class.

* @param mrb The current mruby state.

* @param name The name of the class.

* @return [struct RClass *] A reference to the class.

*/

MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name);

#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))

/**

* Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined.

*

* Example:

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_outer, *example_inner;

* mrb_bool cd;

*

* example_outer = mrb_define_module(mrb, "ExampleOuter");

*

* example_inner = mrb_define_class_under(mrb, example_outer, "ExampleInner", mrb->object_class);

* cd = mrb_class_defined_under(mrb, example_outer, "ExampleInner");

*

* // If mrb_class_defined_under returns TRUE then puts "True"

* // If mrb_class_defined_under returns FALSE then puts "False"

* if (cd) {

* puts("True");

* }

* else {

* puts("False");

* }

* }

*

* @param mrb The current mruby state.

* @param outer The name of the outer class.

* @param name A string representing the name of the inner class.

* @return [mrb_bool] A boolean value.

*/

MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);

MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);

/**

* Gets a child class.

* @param mrb The current mruby state.

* @param outer The name of the parent class.

* @param name The name of the class.

* @return [struct RClass *] A reference to the class.

*/

MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);

MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);

/**

* Gets a module.

* @param mrb The current mruby state.

* @param name The name of the module.

* @return [struct RClass *] A reference to the module.

*/

MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);

MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name);

/**

* Gets a module defined under another module.

* @param mrb The current mruby state.

* @param outer The name of the outer module.

* @param name The name of the module.

* @return [struct RClass *] A reference to the module.

*/

MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);

MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);

/* a function to raise NotImplementedError with current method name */

MRB_API void mrb_notimplement(mrb_state*);

/* a function to be replacement of unimplemented method */

MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value);

/* just return it self */

MRB_API mrb_value mrb_obj_itself(mrb_state*, mrb_value);

/**

* Duplicate an object.

*

* Equivalent to:

* Object#dup

* @param mrb The current mruby state.

* @param obj Object to be duplicate.

* @return [mrb_value] The newly duplicated object.

*/

MRB_API mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);

/**

* Returns true if obj responds to the given method. If the method was defined for that

* class it returns true, it returns false otherwise.

*

* Example:

* # Ruby style

* class ExampleClass

* def example_method

* end

* end

*

* ExampleClass.new.respond_to?(:example_method) # => true

*

* // C style

* void

* mrb_example_gem_init(mrb_state* mrb) {

* struct RClass *example_class;

* mrb_sym mid;

* mrb_bool obj_resp;

*

* example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class);

* mrb_define_method(mrb, example_class, "example_method", exampleMethod, MRB_ARGS_NONE());

* mid = mrb_intern_str(mrb, mrb_str_new_lit(mrb, "example_method" ));

* obj_resp = mrb_obj_respond_to(mrb, example_class, mid); // => TRUE (true in Ruby world)

*

* // If mrb_obj_respond_to returns TRUE then puts "True"

* // If mrb_obj_respond_to returns FALSE then puts "False"

* if (obj_resp) {

* puts("True");

* }

* else {

* puts("False");

* }

* }

*

* @param mrb The current mruby state.

* @param c A reference to a class.

* @param mid A symbol referencing a method id.

* @return [mrb_bool] A boolean value.

*/

MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid);

/**

* Defines a new class under a given module

*

* @param mrb The current mruby state.

* @param outer Reference to the module under which the new class will be defined

* @param name The name of the defined class

* @param super The new class parent

* @return [struct RClass *] Reference to the newly defined class

* @see mrb_define_class

*/

MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);

MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super);

MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);

MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);

/**

* Function requires n arguments.

*

* @param n

* The number of required arguments.

*/

#define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18)

/**

* Function takes n optional arguments

*

* @param n

* The number of optional arguments.

*/

#define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13)

/**

* Function takes n1 mandatory arguments and n2 optional arguments

*

* @param n1

* The number of required arguments.

* @param n2

* The number of optional arguments.

*/

#define MRB_ARGS_ARG(n1,n2) (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))

/** rest argument */

#define MRB_ARGS_REST() ((mrb_aspec)(1 << 12))

/** required arguments after rest */

#define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7)

/** keyword arguments (n of keys, kdict) */

#define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))

/**

* Function takes a block argument

*/

#define MRB_ARGS_BLOCK() ((mrb_aspec)1)

/**

* Function accepts any number of arguments

*/

#define MRB_ARGS_ANY() MRB_ARGS_REST()

/**

* Function accepts no arguments

*/

#define MRB_ARGS_NONE() ((mrb_aspec)0)

/**

* Format specifiers for {mrb_get_args} function

*

* Must be a C string composed of the following format specifiers:

*

* | char | Ruby type | C types | Notes |

* |:----:|----------------|-------------------|----------------------------------------------------|

* | `o` | {Object} | {mrb_value} | Could be used to retrieve any type of argument |

* | `C` | {Class}/{Module} | {mrb_value} | when `!` follows, the value may be `nil` |

* | `S` | {String} | {mrb_value} | when `!` follows, the value may be `nil` |

* | `A` | {Array} | {mrb_value} | when `!` follows, the value may be `nil` |

* | `H` | {Hash} | {mrb_value} | when `!` follows, the value may be `nil` |

* | `s` | {String} | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` |

* | `z` | {String} | const char * | `NULL` terminated string; `z!` gives `NULL` for `nil` |

* | `a` | {Array} | const {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` |

* | `c` | {Class}/{Module} | strcut RClass * | `c!` gives `NULL` for `nil` |

* | `f` | {Integer}/{Float} | {mrb_float} | |

* | `i` | {Integer}/{Float} | {mrb_int} | |

* | `b` | boolean | {mrb_bool} | |

* | `n` | {String}/{Symbol} | {mrb_sym} | |

* | `d` | data | void *, {mrb_data_type} const | 2nd argument will be used to check data type so it won't be modified; when `!` follows, the value may be `nil` |

* | `I` | inline struct | void *, struct RClass | `I!` gives `NULL` for `nil` |

* | `&` | block | {mrb_value} | &! raises exception if no block given. |

* | `*` | rest arguments | const {mrb_value} *, {mrb_int} | Receive the rest of arguments as an array; `*!` avoid copy of the stack. |

* | `\|` | optional | | After this spec following specs would be optional. |

* | `?` | optional given | {mrb_bool} | `TRUE` if preceding argument is given. Used to check optional argument is given. |

* | `:` | keyword args | {mrb_kwargs} const | Get keyword arguments. @see mrb_kwargs |

*

* @see mrb_get_args

*

* Immediately after format specifiers it can add format modifiers:

*

* | char | Notes |

* |:----:|-----------------------------------------------------------------------------------------|

* | `!` | Switch to the alternate mode; The behaviour changes depending on the format specifier |

* | `+` | Request a not frozen object; However, except nil value |

*/

typedef const char *mrb_args_format;

/**

* Get keyword arguments by `mrb_get_args()` with `:` specifier.

*

* `mrb_kwargs::num` indicates that the total number of keyword values.

*

* `mrb_kwargs::required` indicates that the specified number of keywords starting from the beginning of the `mrb_sym` array are required.

*

* `mrb_kwargs::table` accepts a `mrb_sym` array of C.

*

* `mrb_kwargs::values` is an object array of C, and the keyword argument corresponding to the `mrb_sym` array is assigned.

* Note that `undef` is assigned if there is no keyword argument corresponding over `mrb_kwargs::required` to `mrb_kwargs::num`.

*

* `mrb_kwargs::rest` is the remaining keyword argument that can be accepted as `**rest` in Ruby.

* If `NULL` is specified, `ArgumentError` is raised when there is an undefined keyword.

*

* Examples:

*

* // def method(a: 1, b: 2)

*

* mrb_int kw_num = 2;

* mrb_int kw_required = 0;

* mrb_sym kw_names[] = { mrb_intern_lit(mrb, "a"), mrb_intern_lit(mrb, "b") };

* mrb_value kw_values[kw_num];

* mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL };

*

* mrb_get_args(mrb, ":", &kwargs);

* if (mrb_undef_p(kw_values[0])) { kw_values[0] = mrb_fixnum_value(1); }

* if (mrb_undef_p(kw_values[1])) { kw_values[1] = mrb_fixnum_value(2); }

*