/*

** 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 */

  uint8_t scheduler_lock;           /* Lock counter for synchronous execution */

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

  void *sym_pool;

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

}

Unexecuted instantiation: mruby_fuzzer.c:mrb_class_new_instance

Unexecuted instantiation: state.c:mrb_class_new_instance

Unexecuted instantiation: debug.c:mrb_class_new_instance

Unexecuted instantiation: class.c:mrb_class_new_instance

Unexecuted instantiation: init.c:mrb_class_new_instance

Unexecuted instantiation: etc.c:mrb_class_new_instance

Unexecuted instantiation: array.c:mrb_class_new_instance

Unexecuted instantiation: version.c:mrb_class_new_instance

Unexecuted instantiation: y.tab.c:mrb_class_new_instance

Unexecuted instantiation: rational.c:mrb_class_new_instance

Unexecuted instantiation: complex.c:mrb_class_new_instance

Unexecuted instantiation: mrblib.c:mrb_class_new_instance

Unexecuted instantiation: gem_init.c:mrb_class_new_instance

Unexecuted instantiation: bigint.c:mrb_class_new_instance

Unexecuted instantiation: mempool.c:mrb_class_new_instance

Unexecuted instantiation: variable.c:mrb_class_new_instance

Unexecuted instantiation: allocf.c:mrb_class_new_instance

Unexecuted instantiation: symbol.c:mrb_class_new_instance

Unexecuted instantiation: object.c:mrb_class_new_instance

Unexecuted instantiation: numeric.c:mrb_class_new_instance

Unexecuted instantiation: gc.c:mrb_class_new_instance

Unexecuted instantiation: error.c:mrb_class_new_instance

Unexecuted instantiation: load.c:mrb_class_new_instance

Unexecuted instantiation: enum.c:mrb_class_new_instance

Unexecuted instantiation: vm.c:mrb_class_new_instance

Unexecuted instantiation: string.c:mrb_class_new_instance

Unexecuted instantiation: proc.c:mrb_class_new_instance

Unexecuted instantiation: readfloat.c:mrb_class_new_instance

Unexecuted instantiation: hash.c:mrb_class_new_instance

Unexecuted instantiation: codedump.c:mrb_class_new_instance

Unexecuted instantiation: range.c:mrb_class_new_instance

Unexecuted instantiation: kernel.c:mrb_class_new_instance

Unexecuted instantiation: readint.c:mrb_class_new_instance

Unexecuted instantiation: backtrace.c:mrb_class_new_instance

Unexecuted instantiation: codegen.c:mrb_class_new_instance

Unexecuted instantiation: set.c:mrb_class_new_instance

Unexecuted instantiation: fmt_fp.c:mrb_class_new_instance

Unexecuted instantiation: numeric_ext.c:mrb_class_new_instance

Unexecuted instantiation: hash_ext.c:mrb_class_new_instance

Unexecuted instantiation: mruby_objectspace.c:mrb_class_new_instance

Unexecuted instantiation: fiber.c:mrb_class_new_instance

Unexecuted instantiation: catch.c:mrb_class_new_instance

Unexecuted instantiation: pack.c:mrb_class_new_instance

Unexecuted instantiation: sprintf.c:mrb_class_new_instance

Unexecuted instantiation: time.c:mrb_class_new_instance

Unexecuted instantiation: struct.c:mrb_class_new_instance

Unexecuted instantiation: data.c:mrb_class_new_instance

Unexecuted instantiation: random.c:mrb_class_new_instance

Unexecuted instantiation: mruby_io_gem.c:mrb_class_new_instance

Unexecuted instantiation: socket.c:mrb_class_new_instance

Unexecuted instantiation: errno.c:mrb_class_new_instance

Unexecuted instantiation: dir.c:mrb_class_new_instance

Unexecuted instantiation: math.c:mrb_class_new_instance

Unexecuted instantiation: metaprog.c:mrb_class_new_instance

Unexecuted instantiation: method.c:mrb_class_new_instance

Unexecuted instantiation: eval.c:mrb_class_new_instance

Unexecuted instantiation: binding.c:mrb_class_new_instance

Unexecuted instantiation: proc_binding.c:mrb_class_new_instance

Unexecuted instantiation: io_hal.c:mrb_class_new_instance

Unexecuted instantiation: socket_hal.c:mrb_class_new_instance

Unexecuted instantiation: dir_hal.c:mrb_class_new_instance

Unexecuted instantiation: exception.c:mrb_class_new_instance

Unexecuted instantiation: file.c:mrb_class_new_instance

Unexecuted instantiation: file_test.c:mrb_class_new_instance

Unexecuted instantiation: io.c:mrb_class_new_instance

Unexecuted instantiation: mruby_proto_fuzzer.cpp:mrb_class_new_instance(mrb_state*, long, mrb_value const*, RClass*)

/**

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

 *

 *

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

 */

typedef struct mrb_kwargs mrb_kwargs;

struct mrb_kwargs

{

  mrb_int num;                  /* number of keyword arguments */

  mrb_int required;             /* number of required keyword arguments */

  const mrb_sym *table;         /* C array of symbols for keyword names */

  mrb_value *values;            /* keyword argument values */

  mrb_value *rest;              /* keyword rest (dict) */

};

/**

 * Retrieve arguments from mrb_state.

 *

 * @param mrb The current mruby state.

 * @param format is a list of format specifiers

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

 * @return the number of arguments retrieved.

 * @see mrb_args_format

 * @see mrb_kwargs

 */

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

/**

 * Array version of mrb_get_args()

 *

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

 */

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

MRB_INLINE mrb_sym

mrb_get_mid(mrb_state *mrb) /* get method symbol */

{

  return mrb->c->ci->mid;

}

Unexecuted instantiation: mruby_fuzzer.c:mrb_get_mid

Unexecuted instantiation: state.c:mrb_get_mid

Unexecuted instantiation: debug.c:mrb_get_mid

Unexecuted instantiation: class.c:mrb_get_mid

Unexecuted instantiation: init.c:mrb_get_mid

Unexecuted instantiation: etc.c:mrb_get_mid

Unexecuted instantiation: array.c:mrb_get_mid

Unexecuted instantiation: version.c:mrb_get_mid

Unexecuted instantiation: y.tab.c:mrb_get_mid

Unexecuted instantiation: rational.c:mrb_get_mid

Unexecuted instantiation: complex.c:mrb_get_mid

Unexecuted instantiation: mrblib.c:mrb_get_mid

Unexecuted instantiation: gem_init.c:mrb_get_mid

Unexecuted instantiation: bigint.c:mrb_get_mid

Unexecuted instantiation: mempool.c:mrb_get_mid

Unexecuted instantiation: variable.c:mrb_get_mid

Unexecuted instantiation: allocf.c:mrb_get_mid

Unexecuted instantiation: symbol.c:mrb_get_mid

Unexecuted instantiation: object.c:mrb_get_mid

Unexecuted instantiation: numeric.c:mrb_get_mid

Unexecuted instantiation: gc.c:mrb_get_mid

Unexecuted instantiation: error.c:mrb_get_mid

Unexecuted instantiation: load.c:mrb_get_mid

Unexecuted instantiation: enum.c:mrb_get_mid

Unexecuted instantiation: vm.c:mrb_get_mid

Unexecuted instantiation: string.c:mrb_get_mid

Unexecuted instantiation: proc.c:mrb_get_mid

Unexecuted instantiation: readfloat.c:mrb_get_mid

Unexecuted instantiation: hash.c:mrb_get_mid

Unexecuted instantiation: codedump.c:mrb_get_mid

Unexecuted instantiation: range.c:mrb_get_mid

Unexecuted instantiation: kernel.c:mrb_get_mid

Unexecuted instantiation: readint.c:mrb_get_mid

Unexecuted instantiation: backtrace.c:mrb_get_mid

Unexecuted instantiation: codegen.c:mrb_get_mid

Unexecuted instantiation: set.c:mrb_get_mid

Unexecuted instantiation: fmt_fp.c:mrb_get_mid

Unexecuted instantiation: numeric_ext.c:mrb_get_mid

Unexecuted instantiation: hash_ext.c:mrb_get_mid

Unexecuted instantiation: mruby_objectspace.c:mrb_get_mid

Unexecuted instantiation: fiber.c:mrb_get_mid

Unexecuted instantiation: catch.c:mrb_get_mid

Unexecuted instantiation: pack.c:mrb_get_mid

Unexecuted instantiation: sprintf.c:mrb_get_mid

Unexecuted instantiation: time.c:mrb_get_mid

Unexecuted instantiation: struct.c:mrb_get_mid

Unexecuted instantiation: data.c:mrb_get_mid

Unexecuted instantiation: random.c:mrb_get_mid

Unexecuted instantiation: mruby_io_gem.c:mrb_get_mid

Unexecuted instantiation: socket.c:mrb_get_mid

Unexecuted instantiation: errno.c:mrb_get_mid

Unexecuted instantiation: dir.c:mrb_get_mid

Unexecuted instantiation: math.c:mrb_get_mid

Unexecuted instantiation: metaprog.c:mrb_get_mid

Unexecuted instantiation: method.c:mrb_get_mid

Unexecuted instantiation: eval.c:mrb_get_mid

Unexecuted instantiation: binding.c:mrb_get_mid

Unexecuted instantiation: proc_binding.c:mrb_get_mid

Unexecuted instantiation: io_hal.c:mrb_get_mid

Unexecuted instantiation: socket_hal.c:mrb_get_mid

Unexecuted instantiation: dir_hal.c:mrb_get_mid

Unexecuted instantiation: exception.c:mrb_get_mid

Unexecuted instantiation: file.c:mrb_get_mid

Unexecuted instantiation: file_test.c:mrb_get_mid

Unexecuted instantiation: io.c:mrb_get_mid

Unexecuted instantiation: mruby_proto_fuzzer.cpp:mrb_get_mid(mrb_state*)

/**

 * Retrieve number of arguments from mrb_state.

 *

 * Correctly handles *splat arguments.

 */

MRB_API mrb_int mrb_get_argc(mrb_state *mrb);

/**

 * Retrieve an array of arguments from mrb_state.

 *

 * Correctly handles *splat arguments.

 */

MRB_API const mrb_value *mrb_get_argv(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_API mrb_value mrb_get_arg1(mrb_state *mrb);

/**

 * Check if a block argument is given from mrb_state.