Header: mruby.h

Overview

mruby C API entry point

Function Summary collapse

Define Summary

#define MRUBY_H 

    
      
#define __STDC_LIMIT_MACROS
        
      

      

    
      
#define __STDC_CONSTANT_MACROS
        
      

      

    
      
#define __STDC_FORMAT_MACROS
        
      

      

    
      
#define SIZE_MAX
        
      

      

    
      
#define __func__
        
      

      

    
      
#define mrb_assert
        
      

      

    
      
#define mrb_assert_int_fit
        
      

      

    
      
#define mrb_static_assert
        

  

    

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



 mrb_static_assert(expect_condition);
 mrb_static_assert(expect_condition, error_message);




  





  





      

      

    
      
#define mrb_static_assert1
        
      

      

    
      
#define mrb_static_assert2
        

  

    

for old G+/Clang+



  





  





      

      

    
      
#define _mrb_static_assert_cat0
        
      

      

    
      
#define _mrb_static_assert_cat
        
      

      

    
      
#define _mrb_static_assert_id
        
      

      

    
      
#define mrb_static_assert_expand
        
      

      

    
      
#define mrb_static_assert_selector
        
      

      

    
      
#define mrb_static_assert_powerof2
        
      

      

    
      
#define FLT_EPSILON
        
      

      

    
      
#define DBL_EPSILON
        
      

      

    
      
#define LDBL_EPSILON
        
      

      

    
      
#define MRB_FLOAT_EPSILON
        
      

      

    
      
#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE
        
      

      

    
      
#define MRB_METHOD_CACHE_SIZE
        

  

    

cache size needs to be power of 2



  





  





      

      

    
      
#define mrb_exc_get
        
      

      

    
      
#define MRB_ARGS_REQ
        

  

    

Function requires n arguments.



  





  





      

      

    
      
#define MRB_ARGS_OPT
        

  

    

Function takes n optional arguments



  





  





      

      

    
      
#define MRB_ARGS_ARG
        

  

    

Function takes n1 mandatory arguments and n2 optional arguments



  





  





      

      

    
      
#define MRB_ARGS_REST
        

  

    

rest argument



  





  





      

      

    
      
#define MRB_ARGS_POST
        

  

    

required arguments after rest



  





  





      

      

    
      
#define MRB_ARGS_KEY
        

  

    

keyword arguments (n of keys, kdict)



  





  





      

      

    
      
#define MRB_ARGS_BLOCK
        

  

    

Function takes a block argument



  





  





      

      

    
      
#define MRB_ARGS_ANY
        

  

    

Function accepts any number of arguments



  





  





      

      

    
      
#define MRB_ARGS_NONE
        

  

    

Function accepts no arguments



  





  





      

      

    
      
#define mrb_strlen_lit
        

  

    

strlen for character string literals (use with caution or strlen instead) Adjacent string literals are concatenated in C/C++ in translation phase 6. If lit is not one, the compiler will report a syntax error: MSVC: “error C2143: syntax error : missing ‘)’ before ‘string’” GCC: “error: expected ‘)’ before string constant”



  





  





      

      

    
      
#define mrb_intern_lit
        
      

      

    
      
#define mrb_sym2name
        
      

      

    
      
#define mrb_sym2name_len
        
      

      

    
      
#define mrb_sym2str
        
      

      

    
      
#define MRB_OBJ_ALLOC
        

  

    

Allocates a Ruby object that matches the constant literal defined in enum mrb_vtype and returns a pointer to the corresponding C type.



  





  

Returns:


    
  
    
  • 
      
      
        
      
      
      
        
        
    

    Reference to the newly created object
    

    
      
    
    • 
  







      

      

    
      
#define mrb_str_new_lit
        
      

      

    
      
#define mrb_str_new_frozen
        
      

      

    
      
#define mrb_str_new_cstr_frozen
        
      

      

    
      
#define mrb_str_new_static_frozen
        
      

      

    
      
#define mrb_str_new_lit_frozen
        
      

      

    
      
#define mrb_locale_free
        
      

      

    
      
#define mrb_utf8_free
        
      

      

    
      
#define mrb_utf8_from_locale
        
      

      

    
      
#define mrb_locale_from_utf8
        
      

      

    
      
#define mrb_toplevel_run_keep
        

  

    

compatibility macros



  





  





      

      

    
      
#define mrb_toplevel_run
        
      

      

    
      
#define mrb_context_run
        
      

      

    
      
#define mrb_as_float
        
      

      

    
      
#define mrb_to_float
        

  

    

obsolete: use mrb_ensure_float_type() instead



  





  





      

      

    
      
#define mrb_gc_arena_save
        
      

      

    
      
#define mrb_gc_arena_restore
        
      

      

    
      
#define mrb_gc_mark_value
        
      

      

    
      
#define mrb_field_write_barrier_value
        
      

      

    
      
#define mrb_convert_type
        
      

      

    
      
#define mrb_check_convert_type
        
      

      

    
      
#define ISASCII
        
      

      

    
      
#define ISPRINT
        
      

      

    
      
#define ISSPACE
        
      

      

    
      
#define ISLOWER
        
      

      

    
      
#define ISALPHA
        
      

      

    
      
#define ISDIGIT
        
      

      

    
      
#define ISXDIGIT
        
      

      

    
      
#define ISALNUM
        
      

      

    
      
#define ISBLANK
        
      

      

    
      
#define TOUPPER
        
      

      

    
      
#define TOLOWER
        
      

      

    
      
#define MRB_ERROR_SYM
        

  

    

macros to get typical exception objects note: + those E_* macros requires mrb_state* variable named mrb. + exception objects obtained from those macros are local to mrb



  





  





      

      

    
      
#define E_EXCEPTION
        
      

      

    
      
#define E_STANDARD_ERROR
        
      

      

    
      
#define E_RUNTIME_ERROR
        
      

      

    
      
#define E_TYPE_ERROR
        
      

      

    
      
#define E_ZERODIV_ERROR
        
      

      

    
      
#define E_ARGUMENT_ERROR
        
      

      

    
      
#define E_INDEX_ERROR
        
      

      

    
      
#define E_RANGE_ERROR
        
      

      

    
      
#define E_NAME_ERROR
        
      

      

    
      
#define E_NOMETHOD_ERROR
        
      

      

    
      
#define E_SCRIPT_ERROR
        
      

      

    
      
#define E_SYNTAX_ERROR
        
      

      

    
      
#define E_LOCALJUMP_ERROR
        
      

      

    
      
#define E_REGEXP_ERROR
        
      

      

    
      
#define E_FROZEN_ERROR
        
      

      

    
      
#define E_NOTIMP_ERROR
        
      

      

    
      
#define E_KEY_ERROR
        
      

      

    
      
#define E_FLOATDOMAIN_ERROR
        
      

      

    
      
#define mrb_string_type
        

  

    

obsolete: use mrb_ensure_string_type() instead



  





  





      

      

    
      
#define mrb_to_str
        
      

      

    
      
#define mrb_str_to_str
        

  

    

obsolete: use mrb_obj_as_string() instead



  





  





      

      

    
      
#define mrb_as_int
        
      

      

    
      
#define mrb_to_integer
        

  

    

obsolete: use mrb_ensure_int_type() instead



  





  





      

      

    
      
#define mrb_to_int
        
      

      

    
      
#define mrb_int
        

  

    

obsolete function(s); will be removed



  





  





      

      

    
      
#define E_FIBER_ERROR
        

  

    

FiberError reference



Implemented in mruby-fiber



  





  





      

      

    
      
#define memcpy
        
      

      

    
      
#define memset
        
      

      

    
      
#define mrb_int_hash_func
        
      

      

    
  



  
Typedef Summary

  

    
      
typedef mrb_code
        

  

    

mruby C API entry point



  





  





      

      

    
      
typedef mrb_aspec
        

  

    

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 mrb_irep
        
      

      

    
      
typedef mrb_args_format
        

  

    

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 *, mruby.h.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







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







  





  

  
See Also:

  





      

      

    
      
typedef mrb_kwargs
        

  

    

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); }


 // def method(str, x:, y: 2, z: "default string", **opts)

 mrb_value str, kw_rest;
 uint32_t kw_num = 3;
 uint32_t kw_required = 1;
 // Note that `#include <mruby/presym.h>` is required beforehand because `MRB_SYM()` is used.
 // If the usage of `MRB_SYM()` is not desired, replace it with `mrb_intern_lit()`.
 mrb_sym kw_names[] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
 mrb_value kw_values[kw_num];
 mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest };

 mrb_get_args(mrb, "S:", &str, &kwargs);
 // or: mrb_get_args(mrb, ":S", &kwargs, &str);
 if (mrb_undef_p(kw_values[1])) { kw_values[1] = mrb_fixnum_value(2); }
 if (mrb_undef_p(kw_values[2])) { kw_values[2] = mrb_str_new_cstr(mrb, "default string"); }




  





  





      

      

    
  




  
Function Details


  
    

  

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

  




  

    

Defines a new class.



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



 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);
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the defined class.
    

    
      
    
    • 
  
    
  • 
      
        super
      
      
        
      
      
      
        —
        
    

    The new class parent.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    Reference to the newly defined class.
    

    
      
    
    • 
  



  
See Also:

  








  
    

  

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

  






  
    

  

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

  




  

    

Defines a new module.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the module.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    Reference to the newly defined module.
    

    
      
    
    • 
  










  
    

  

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

  






  
    

  

  mrb_value mrb_singleton_class(mrb_state * mrb, mrb_value val)

  




  

    

Returns the singleton class of an object.



Raises a TypeError exception for immediate values.



  





  








  
    

  

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

  




  

    

Returns the singleton class of an object.



Returns NULL for immediate values,



  





  








  
    

  

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

  




  

    

Include a module in another class or module. Equivalent to:



module B include A end



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    A reference to module or a class.
    

    
      
    
    • 
  
    
  • 
      
        included
      
      
        
      
      
      
        —
        
    

    A reference to the module to be included.
    

    
      
    
    • 
  











  
    

  

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

  




  

    

Prepends a module in another class or module.



Equivalent to: module B prepend A end



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    A reference to module or a class.
    

    
      
    
    • 
  
    
  • 
      
        prepended
      
      
        
      
      
      
        —
        
    

    A reference to the module to be prepended.
    

    
      
    
    • 
  











  
    

  

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

  




  

    

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());
}




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    The class pointer where the method will be defined.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the method being defined.
    

    
      
    
    • 
  
    
  • 
      
        func
      
      
        
      
      
      
        —
        
    

    The function pointer to the method definition.
    

    
      
    
    • 
  
    
  • 
      
        aspec
      
      
        
      
      
      
        —
        
    

    The method parameters declaration.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  






  
    

  

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

  






  
    

  

  void mrb_define_class_method(mrb_state * mrb, struct RClass * cla, const char * name, mrb_func_t fun, 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());
}




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    The class where the class method will be defined.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the class method being defined.
    

    
      
    
    • 
  
    
  • 
      
        fun
      
      
        
      
      
      
        —
        
    

    The function pointer to the class method definition.
    

    
      
    
    • 
  
    
  • 
      
        aspec
      
      
        
      
      
      
        —
        
    

    The method parameters declaration.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  




  

    

Defines a singleton method



  





  

  
See Also:

  








  
    

  

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

  






  
    

  

  void mrb_define_module_function(mrb_state * mrb, struct RClass * cla, const char * 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());
  }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    The module where the module function will be defined.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the module function being defined.
    

    
      
    
    • 
  
    
  • 
      
        fun
      
      
        
      
      
      
        —
        
    

    The function pointer to the module function definition.
    

    
      
    
    • 
  
    
  • 
      
        aspec
      
      
        
      
      
      
        —
        
    

    The method parameters declaration.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  




  

    

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){
    }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    A class or module the constant is defined in.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the constant being defined.
    

    
      
    
    • 
  
    
  • 
      
        val
      
      
        
      
      
      
        —
        
    

    The value for the constant.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  




  

    

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){
}




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cla
      
      
        
      
      
      
        —
        
    

    The class the method will be undefined from.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the method to be undefined.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  




  

    

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){
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The mruby state reference.
    

    
      
    
    • 
  
    
  • 
      
        cls
      
      
        
      
      
      
        —
        
    

    A class the class method will be undefined from.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the class method to be undefined.
    

    
      
    
    • 
  











  
    

  

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

  






  
    

  

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

  




  

    

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
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        c
      
      
        
      
      
      
        —
        
    

    Reference to the class of the new object.
    

    
      
    
    • 
  
    
  • 
      
        argc
      
      
        
      
      
      
        —
        
    

    Number of arguments in argv
    

    
      
    
    • 
  
    
  • 
      
        argv
      
      
        
      
      
      
        —
        
    

    Array of mrb_value to initialize the object
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (mrb_value)
      
      
      
        —
        
    

    The newly initialized object
    

    
      
    
    • 
  










  
    

  

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

  




  

    

  





  

  
See Also:

  








  
    

  

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

  




  

    

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
  }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        super
      
      
        
      
      
      
        —
        
    

    The super class or parent.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    Reference to the new class.
    

    
      
    
    • 
  










  
    

  

  struct RClass * mrb_module_new(mrb_state * mrb)

  




  

    

Creates a new module, Module.



Example: void mrb_example_gem_init(mrb_state* mrb) { struct RClass *example_module;



   example_module = mrb_module_new(mrb);
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    Reference to the new module.
    

    
      
    
    • 
  










  
    

  

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

  




  

    

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");
  }
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    A string representing the name of the class.
    

    
      
    
    • 
  




Returns:










  
    

  

  mrb_bool mrb_class_defined_id(mrb_state * mrb, mrb_sym name)

  






  
    

  

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

  




  

    

Gets a class.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the class.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    A reference to the class.
    

    
      
    
    • 
  










  
    

  

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

  






  
    

  

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

  




  

    

Gets a exception class.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the class.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    A reference to the class.
    

    
      
    
    • 
  










  
    

  

  mrb_bool mrb_class_defined_under(mrb_state * mrb, struct RClass * outer, const char * 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");
  }
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        outer
      
      
        
      
      
      
        —
        
    

    The name of the outer class.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    A string representing the name of the inner class.
    

    
      
    
    • 
  




Returns:










  
    

  

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

  






  
    

  

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

  




  

    

Gets a child class.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        outer
      
      
        
      
      
      
        —
        
    

    The name of the parent class.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the class.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    A reference to the class.
    

    
      
    
    • 
  










  
    

  

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

  






  
    

  

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

  




  

    

Gets a module.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the module.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    A reference to the module.
    

    
      
    
    • 
  










  
    

  

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

  






  
    

  

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

  




  

    

Gets a module defined under another module.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        outer
      
      
        
      
      
      
        —
        
    

    The name of the outer module.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the module.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    A reference to the module.
    

    
      
    
    • 
  










  
    

  

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

  






  
    

  

  void mrb_notimplement(mrb_state* )

  




  

    

a function to raise NotImplementedError with current method name



  





  








  
    

  

  mrb_value mrb_notimplement_m(mrb_state* , mrb_value )

  




  

    

a function to be replacement of unimplemented method



  





  








  
    

  

  mrb_value mrb_obj_itself(mrb_state* , mrb_value )

  




  

    

just return it self



  





  








  
    

  

  mrb_value mrb_obj_dup(mrb_state * mrb, mrb_value obj)

  




  

    

Duplicate an object.



Equivalent to: Object#dup



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        obj
      
      
        
      
      
      
        —
        
    

    Object to be duplicate.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (mrb_value)
      
      
      
        —
        
    

    The newly duplicated object.
    

    
      
    
    • 
  










  
    

  

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

  




  

    

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");
   }
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        c
      
      
        
      
      
      
        —
        
    

    A reference to a class.
    

    
      
    
    • 
  
    
  • 
      
        mid
      
      
        
      
      
      
        —
        
    

    A symbol referencing a method id.
    

    
      
    
    • 
  




Returns:










  
    

  

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

  




  

    

Defines a new class under a given module



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        outer
      
      
        
      
      
      
        —
        
    

    Reference to the module under which the new class will be defined
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the defined class
    

    
      
    
    • 
  
    
  • 
      
        super
      
      
        
      
      
      
        —
        
    

    The new class parent
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (struct RClass *)
      
      
      
        —
        
    

    Reference to the newly defined class
    

    
      
    
    • 
  



  
See Also:

  








  
    

  

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

  






  
    

  

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

  






  
    

  

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

  






  
    

  

  mrb_int mrb_get_args(mrb_state * mrb, mrb_args_format format, ... )

  




  

    

Retrieve arguments from mrb_state.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        format
      
      
        
      
      
      
        —
        
    

    is a list of format specifiers
    

    
      
    
    • 
  
    
  • 
      
        ...
      
      
        
      
      
      
        —
        
    

    The passing variadic arguments must be a pointer of retrieving type.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        
      
      
      
        
        
    

    the number of arguments retrieved.
    

    
      
    
    • 
  



  
See Also:

  








  
    

  

  mrb_int mrb_get_args_a(mrb_state * mrb, mrb_args_format format, void* , ptr )

  




  

    

Array version of mrb_get_args()



  





  
Parameters:


    
  
    
  • 
      
        ptr
      
      
        
      
      
      
        —
        
    

    Array of void*, in the same order as the varargs version.
    

    
      
    
    • 
  











  
    

  

  mrb_sym mrb_get_mid(mrb_state * mrb)

  




  

    

get method symbol



  





  








  
    

  

  mrb_int mrb_get_argc(mrb_state * mrb)

  




  

    

Retrieve number of arguments from mrb_state.



Correctly handles *splat arguments.



  





  








  
    

  

  mrb_value mrb_get_arg1(mrb_state * mrb)

  




  

    

Retrieve the first and only argument from mrb_state. Raises ArgumentError unless the number of arguments is exactly one.



Correctly handles *splat arguments.



  





  








  
    

  

  mrb_bool mrb_block_given_p(mrb_state * mrb)

  




  

    

Check if a block argument is given from mrb_state.



  





  








  
    

  

  mrb_value mrb_funcall(mrb_state * mrb, mrb_value val, const char * name, mrb_int argc, ... )

  




  

    

Call existing ruby functions.



Example:



 #include <stdio.h>
 #include <mruby.h>
 #include <mruby/compile.h>

 int
 main()
 {
   mrb_int i = 99;
   mrb_state *mrb = mrb_open();

   if (!mrb) { }
   FILE *fp = fopen("test.rb","r");
   mrb_value obj = mrb_load_file(mrb,fp);
   mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
   mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i));
   fclose(fp);
   mrb_close(mrb);
 }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        val
      
      
        
      
      
      
        —
        
    

    A reference to an mruby value.
    

    
      
    
    • 
  
    
  • 
      
        name
      
      
        
      
      
      
        —
        
    

    The name of the method.
    

    
      
    
    • 
  
    
  • 
      
        argc
      
      
        
      
      
      
        —
        
    

    The number of arguments the method has.
    

    
      
    
    • 
  
    
  • 
      
        ...
      
      
        
      
      
      
        —
        
    

    Variadic values(not type safe!).
    

    
      
    
    • 
  




Returns:










  
    

  

  mrb_value mrb_funcall_id(mrb_state * mrb, mrb_value val, mrb_sym mid, mrb_int argc, ... )

  






  
    

  

  mrb_value mrb_funcall_argv(mrb_state * mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value * argv)

  




  

    

Call existing ruby functions. This is basically the type safe version of mrb_funcall.



 #include <stdio.h>
 #include <mruby.h>
 #include <mruby/compile.h>
 int
 main()
 {
   mrb_state *mrb = mrb_open();
   mrb_value obj = mrb_fixnum_value(1);

   if (!mrb) { }

   FILE *fp = fopen("test.rb","r");
   mrb_value obj = mrb_load_file(mrb,fp);
   mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb.
   fclose(fp);
   mrb_close(mrb);
  }




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        val
      
      
        
      
      
      
        —
        
    

    A reference to an mruby value.
    

    
      
    
    • 
  
    
  • 
      
        name_sym
      
      
        
      
      
      
        —
        
    

    The symbol representing the method.
    

    
      
    
    • 
  
    
  • 
      
        argc
      
      
        
      
      
      
        —
        
    

    The number of arguments the method has.
    

    
      
    
    • 
  
    
  • 
      
        obj
      
      
        
      
      
      
        —
        
    

    Pointer to the object.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (mrb_value)
      
      
      
        —
        
    

    mrb_value mruby function value.
    

    
      
    
    • 
  



  
See Also:

  








  
    

  

  mrb_value mrb_funcall_with_block(mrb_state * mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value * argv, mrb_value block)

  




  

    

Call existing ruby functions with a block.



  





  








  
    

  

  mrb_sym mrb_intern_cstr(mrb_state * mrb, const char* str)

  




  

    

Create a symbol from C string. But usually it’s better to use MRB_SYM, MRB_OPSYM, MRB_CVSYM, MRB_IVSYM, MRB_GVSYM, MRB_SYM_B, MRB_SYM_Q, MRB_SYM_E macros.



Example:



# Ruby style:
:pizza # => :pizza

// C style:
mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); //  => :pizza
mrb_sym sym2 = MRB_SYM(pizza);               //  => :pizza
mrb_sym sym3 = MRB_SYM_Q(pizza);             //  => :pizza?




  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        str
      
      
        
      
      
      
        —
        
    

    The string to be symbolized
    

    
      
    
    • 
  




Returns:










  
    

  

  mrb_sym mrb_intern(mrb_state* , const char* , size_t )

  






  
    

  

  mrb_sym mrb_intern_static(mrb_state* , const char* , size_t )

  






  
    

  

  mrb_sym mrb_intern_str(mrb_state* , mrb_value )

  






  
    

  

  mrb_sym mrb_intern_check_cstr(mrb_state* , const char* )

  




  

    

mrb_intern_check series functions returns 0 if the symbol is not defined



  





  








  
    

  

  mrb_sym mrb_intern_check(mrb_state* , const char* , size_t )

  






  
    

  

  mrb_sym mrb_intern_check_str(mrb_state* , mrb_value )

  






  
    

  

  mrb_value mrb_check_intern_cstr(mrb_state* , const char* )

  




  

    

otherwise returns mrb_value



  





  








  
    

  

  mrb_value mrb_check_intern(mrb_state* , const char* , size_t )

  






  
    

  

  mrb_value mrb_check_intern_str(mrb_state* , mrb_value )

  






  
    

  

  mrb_value mrb_sym_str(mrb_state* , mrb_sym )

  






  
    

  

  void * mrb_malloc(mrb_state* , size_t )

  




  

    

raise RuntimeError if no mem



  





  








  
    

  

  void * mrb_calloc(mrb_state* , size_t , size_t )

  




  

    

ditto



  





  








  
    

  

  void * mrb_realloc(mrb_state* , void* , size_t )

  




  

    

ditto



  





  








  
    

  

  void * mrb_realloc_simple(mrb_state* , void* , size_t )

  




  

    

return NULL if no memory available



  





  








  
    

  

  void * mrb_malloc_simple(mrb_state* , size_t )

  




  

    

return NULL if no memory available



  





  








  
    

  

  struct RBasic * mrb_obj_alloc(mrb_state* , enum mrb_vtype, struct RClass* )

  




  

    

return NULL if no memory available



  





  








  
    

  

  void mrb_free(mrb_state* , void* )

  






  
    

  

  mrb_value mrb_str_new(mrb_state * mrb, const char * p, mrb_int len)

  






  
    

  

  mrb_value mrb_str_new_cstr(mrb_state* , const char* )

  




  

    

Turns a C string into a Ruby string value.



  





  








  
    

  

  mrb_value mrb_str_new_static(mrb_state * mrb, const char * p, mrb_int len)

  






  
    

  

  mrb_value mrb_obj_freeze(mrb_state* , mrb_value )

  






  
    

  

  mrb_state* mrb_open(void)

  




  

    

Creates new mrb_state.



  





  

Returns:


    
  
    
  • 
      
      
        
      
      
      
        
        
    

    Pointer to the newly created mrb_state.
    

    
      
    
    • 
  










  
    

  

  mrb_state* mrb_open_allocf(mrb_allocf f, void * ud)

  




  

    

Create new mrb_state with custom allocators.



  





  
Parameters:


    
  
    
  • 
      
        f
      
      
        
      
      
      
        —
        
    

    Reference to the allocation function.
    

    
      
    
    • 
  
    
  • 
      
        ud
      
      
        
      
      
      
        —
        
    

    User data will be passed to custom allocator f. If user data isn’t required just pass NULL.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        
      
      
      
        
        
    

    Pointer to the newly created mrb_state.
    

    
      
    
    • 
  










  
    

  

  mrb_state* mrb_open_core(mrb_allocf f, void * ud)

  




  

    

Create new mrb_state with just the mruby core



  





  
Parameters:


    
  
    
  • 
      
        f
      
      
        
      
      
      
        —
        
    

    Reference to the allocation function. Use mrb_default_allocf for the default
    

    
      
    
    • 
  
    
  • 
      
        ud
      
      
        
      
      
      
        —
        
    

    User data will be passed to custom allocator f. If user data isn’t required just pass NULL.
    

    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        
      
      
      
        
        
    

    Pointer to the newly created mrb_state.
    

    
      
    
    • 
  










  
    

  

  void mrb_close(mrb_state * mrb)

  




  

    

Closes and frees a mrb_state.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    Pointer to the mrb_state to be closed.
    

    
      
    
    • 
  











  
    

  

  void* mrb_default_allocf(mrb_state* , void* , size_t , void* )

  




  

    

The default allocation function.



  





  

  
See Also:

  
    
    
      
  • mruby.h.mrb_allocf
    • 
    
  









  
    

  

  mrb_value mrb_top_self(mrb_state * mrb)

  






  
    

  

  mrb_value mrb_top_run(mrb_state * mrb, const struct RProc * proc, mrb_value self, mrb_int stack_keep)

  




  

    
  

    Note:
    


When called from a C function defined as a method, the current stack is destroyed. If you want to use arguments obtained by mrb_get_args() or other methods after mrb_top_run(), you must protect them by mrb_gc_protect() or other ways before this function. Or consider using mrb_yield() family functions.



  




Enter the mruby VM and execute the proc.



  





  
Parameters:


    
  
    
  • 
      
        mrb
      
      
        
      
      
      
        —
        
    

    The current mruby state.
    

    
      
    
    • 
  
    
  • 
      
        proc
      
      
        
      
      
      
        —
        
    

    An object containing irep. If supplied an object containing anything other than irep, it will probably crash.
    

    
      
    
    • 
  
    
  • 
      
        self
      
      
        
      
      
      
        —
        
    

    self on the execution context of proc.
    

    
      
    
    • 
  
    
  • 
      
        stack_keep
      
      
        
      
      
      
        —
        
    

    Specifies the number of values to hold from the stack top. Values on the stack outside this range will be initialized to nil.
    

    
      
    
    • 
  











  
    

  

  mrb_value mrb_vm_run(mrb_state * mrb, const struct RProc * proc, mrb_value self, mrb_int stack_keep)

  






  
    

  

  mrb_value mrb_vm_exec(mrb_state * mrb, const struct RProc * proc, const mrb_code * iseq)

  






  
    

  

  void mrb_p(mrb_state* , mrb_value )

  






  
    

  

  mrb_int mrb_obj_id(mrb_value obj)

  






  
    

  

  mrb_sym mrb_obj_to_sym(mrb_state * mrb, mrb_value name)

  






  
    

  

  mrb_bool mrb_obj_eq(mrb_state * mrb, mrb_value a, mrb_value b)

  






  
    

  

  mrb_bool mrb_obj_equal(mrb_state * mrb, mrb_value a, mrb_value b)

  






  
    

  

  mrb_bool mrb_equal(mrb_state * mrb, mrb_value obj1, mrb_value obj2)

  






  
    

  

  mrb_value mrb_ensure_float_type(mrb_state * mrb, mrb_value val)

  






  
    

  

  mrb_value mrb_inspect(mrb_state * mrb, mrb_value obj)

  






  
    

  

  mrb_bool mrb_eql(mrb_state * mrb, mrb_value obj1, mrb_value obj2)

  






  
    

  

  mrb_int mrb_cmp(mrb_state * mrb, mrb_value obj1, mrb_value obj2)

  




  

    

mrb_cmp(mrb, obj1, obj2): 1:0:-1; -2 for error



  





  








  
    

  

  void mrb_garbage_collect(mrb_state* )

  






  
    

  

  void mrb_full_gc(mrb_state* )

  






  
    

  

  void mrb_incremental_gc(mrb_state* )

  






  
    

  

  void mrb_gc_mark(mrb_state* , struct RBasic* )

  






  
    

  

  void mrb_field_write_barrier(mrb_state* , struct RBasic* , struct RBasic* )

  






  
    

  

  void mrb_write_barrier(mrb_state * , struct RBasic* )

  






  
    

  

  mrb_value mrb_type_convert(mrb_state * mrb, mrb_value val, enum mrb_vtype, type , mrb_sym method)

  






  
    

  

  mrb_value mrb_type_convert_check(mrb_state * mrb, mrb_value val, enum mrb_vtype, type , mrb_sym method)

  






  
    

  

  mrb_value mrb_any_to_s(mrb_state * mrb, mrb_value obj)

  






  
    

  

  struct RClass* mrb_obj_class(mrb_state * mrb, mrb_value obj)

  






  
    

  

  mrb_value mrb_class_path(mrb_state * mrb, struct RClass * c)

  






  
    

  

  mrb_bool mrb_obj_is_kind_of(mrb_state * mrb, mrb_value obj, struct RClass * c)

  






  
    

  

  mrb_value mrb_obj_inspect(mrb_state * mrb, mrb_value self)

  






  
    

  

  mrb_value mrb_obj_clone(mrb_state * mrb, mrb_value self)

  






  
    

  

  mrb_value mrb_exc_new(mrb_state * mrb, struct RClass * c, const char * ptr, mrb_int len)

  






  
    

  

  mrb_noreturn mrb_exc_raise(mrb_state * mrb, mrb_value exc)

  






  
    

  

  mrb_noreturn mrb_raise(mrb_state * mrb, struct RClass * c, const char * msg)

  






  
    

  

  mrb_noreturn mrb_raisef(mrb_state * mrb, struct RClass * c, const char * fmt, ... )

  






  
    

  

  mrb_noreturn mrb_name_error(mrb_state * mrb, mrb_sym id, const char * fmt, ... )

  






  
    

  

  mrb_noreturn mrb_frozen_error(mrb_state * mrb, void * frozen_obj)

  






  
    

  

  mrb_noreturn mrb_argnum_error(mrb_state * mrb, mrb_int argc, int min, int max)

  






  
    

  

  void mrb_warn(mrb_state * mrb, const char * fmt, ... )

  






  
    

  

  mrb_noreturn mrb_bug(mrb_state * mrb, const char * mesg)

  






  
    

  

  void mrb_print_backtrace(mrb_state * mrb)

  






  
    

  

  void mrb_print_error(mrb_state * mrb)

  






  
    

  

  mrb_value mrb_vformat(mrb_state * mrb, const char * format, va_list ap)

  




  

    

function for raisef formatting



  





  








  
    

  

  mrb_value mrb_yield(mrb_state * mrb, mrb_value b, mrb_value arg)

  






  
    

  

  mrb_value mrb_yield_argv(mrb_state * mrb, mrb_value b, mrb_int argc, const mrb_value * argv)

  






  
    

  

  mrb_value mrb_yield_with_class(mrb_state * mrb, mrb_value b, mrb_int argc, const mrb_value * argv, mrb_value self, struct RClass * c)

  






  
    

  

  void mrb_gc_protect(mrb_state * mrb, mrb_value obj)

  




  

    

mrb_gc_protect() leaves the object in the arena



  





  








  
    

  

  void mrb_gc_register(mrb_state * mrb, mrb_value obj)

  




  

    

mrb_gc_register() keeps the object from GC.



  





  








  
    

  

  void mrb_gc_unregister(mrb_state * mrb, mrb_value obj)

  




  

    

mrb_gc_unregister() removes the object from GC root.



  





  








  
    

  

  mrb_value mrb_ensure_array_type(mrb_state * mrb, mrb_value self)

  




  

    

type conversion/check functions



  





  








  
    

  

  mrb_value mrb_check_array_type(mrb_state * mrb, mrb_value self)

  






  
    

  

  mrb_value mrb_ensure_hash_type(mrb_state * mrb, mrb_value hash)

  






  
    

  

  mrb_value mrb_check_hash_type(mrb_state * mrb, mrb_value hash)

  






  
    

  

  mrb_value mrb_ensure_string_type(mrb_state * mrb, mrb_value str)

  






  
    

  

  mrb_value mrb_check_string_type(mrb_state * mrb, mrb_value str)

  






  
    

  

  mrb_value mrb_ensure_integer_type(mrb_state * mrb, mrb_value val)

  




  

    

check if val is an integer (including Bigint)



  





  








  
    

  

  mrb_value mrb_ensure_int_type(mrb_state * mrb, mrb_value val)

  




  

    

check if val fit in mrb_int



  





  








  
    

  

  void mrb_check_type(mrb_state * mrb, mrb_value x, enum mrb_vtype, t )

  




  

    

string type checking (contrary to the name, it doesn’t convert)



  





  








  
    

  

  void mrb_check_frozen(mrb_state * mrb, void * )

  






  
    

  

  void mrb_check_frozen_value(mrb_state * mrb, mrb_value v)

  






  
    

  

  void mrb_define_alias(mrb_state * mrb, struct RClass * c, const char * a, const char * b)

  






  
    

  

  void mrb_define_alias_id(mrb_state * mrb, struct RClass * c, mrb_sym a, mrb_sym b)

  






  
    

  

  void mrb_define_global_const(mrb_state * mrb, const char * name, mrb_value val)

  






  
    

  

  mrb_value mrb_attr_get(mrb_state * mrb, mrb_value obj, mrb_sym id)

  






  
    

  

  mrb_bool mrb_respond_to(mrb_state * mrb, mrb_value obj, mrb_sym mid)

  






  
    

  

  mrb_bool mrb_obj_is_instance_of(mrb_state * mrb, mrb_value obj, const struct RClass* c)

  






  
    

  

  mrb_bool mrb_func_basic_p(mrb_state * mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)

  






  
    

  

  mrb_value mrb_fiber_new(mrb_state * mrb, const struct RProc * proc)

  




  

    

Create a new Fiber from proc object



Implemented in mruby-fiber



  





  








  
    

  

  mrb_value mrb_fiber_resume(mrb_state * mrb, mrb_value fib, mrb_int argc, const mrb_value * argv)

  




  

    

Resume a Fiber



Implemented in mruby-fiber



Switches to the specified fiber and executes. Like the Fiber#resume method.



  





  








  
    

  

  mrb_value mrb_fiber_yield(mrb_state * mrb, mrb_int argc, const mrb_value * argv)

  




  

    
  

    Note:
    


This function is only available from inside a function defined as a method by, for example, mrb_define_method(). Also, the work following mrb_fiber_yield() cannot be performed, and the return value of mrb_fiber_yield() must be returned as is.



return mrb_fiber_yield(mrb, argc, argv);




  




Yield a Fiber



Implemented in mruby-fiber



Passes control to the caller fiber of the running fiber. Like the Fiber.yield method.



  





  








  
    

  

  mrb_value mrb_fiber_alive_p(mrb_state * mrb, mrb_value fib)

  




  

    

Check if a Fiber is alive



Implemented in mruby-fiber



  





  








  
    

  

  void mrb_stack_extend(mrb_state* , mrb_int )

  






  
    

  

  void* mrb_alloca(mrb_state * mrb, size_t )

  




  

    

temporary memory allocation, only effective while GC arena is kept



  





  








  
    

  

  void mrb_state_atexit(mrb_state * mrb, mrb_atexit_func func)

  






  
    

  

  void mrb_show_version(mrb_state * mrb)

  






  
    

  

  void mrb_show_copyright(mrb_state * mrb)

  






  
    

  

  mrb_value mrb_format(mrb_state * mrb, const char * format, ... )