mruby 3.3.0
mruby is the lightweight implementation of the Ruby language
Loading...
Searching...
No Matches
mruby.h
Go to the documentation of this file.
1/*
2** mruby - An embeddable Ruby implementation
3**
4** Copyright (c) mruby developers 2010-
5**
6** Permission is hereby granted, free of charge, to any person obtaining
7** a copy of this software and associated documentation files (the
8** "Software"), to deal in the Software without restriction, including
9** without limitation the rights to use, copy, modify, merge, publish,
10** distribute, sublicense, and/or sell copies of the Software, and to
11** permit persons to whom the Software is furnished to do so, subject to
12** the following conditions:
13**
14** The above copyright notice and this permission notice shall be
15** included in all copies or substantial portions of the Software.
16**
17** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
21** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24**
25** [ MIT license: https://www.opensource.org/licenses/mit-license.php ]
26*/
27
32#ifndef MRUBY_H
33#define MRUBY_H
34
35#ifdef __cplusplus
36#define __STDC_LIMIT_MACROS
37#define __STDC_CONSTANT_MACROS
38#define __STDC_FORMAT_MACROS
39#endif
40
41#include <stdarg.h>
42#include <stdint.h>
43#include <stddef.h>
44#include <limits.h>
45
46#ifdef __cplusplus
47#ifndef UINTPTR_MAX
48#error Must be placed `#include <mruby.h>` before `#include <stdint.h>`
49#endif
50#ifndef SIZE_MAX
51#ifdef __SIZE_MAX__
52#define SIZE_MAX __SIZE_MAX__
53#else
54#define SIZE_MAX std::numeric_limits<size_t>::max()
55#endif
56#endif
57#endif
58
59#ifdef _MSC_VER
60# define __func__ __FUNCTION__
61#endif
62
63#ifdef MRB_DEBUG
64#include <assert.h>
65#define mrb_assert(p) assert(p)
66#define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
67#else
68#define mrb_assert(p) ((void)0)
69#define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
70#endif
71
72#if (defined __cplusplus && __cplusplus >= 201703L)
73# define mrb_static_assert(...) static_assert(__VA_ARGS__)
74# define mrb_static_assert1(exp) static_assert(exp)
75# define mrb_static_assert2(exp, str) static_assert(exp, str)
76#elif (defined __cplusplus && __cplusplus >= 201103L) || \
77 (defined _MSC_VER) || \
78 (defined __GXX_EXPERIMENTAL_CXX0X__) /* for old G++/Clang++ */
79# define mrb_static_assert2(exp, str) static_assert(exp, str)
80#elif defined __STDC_VERSION__ && \
81 ((__STDC_VERSION__ >= 201112L) || \
82 (defined __GNUC__ && __GNUC__ * 100 + __GNUC_MINOR__ >= 406))
83# define mrb_static_assert2(exp, str) _Static_assert(exp, str)
84#else
85# /* alternative implementation of static_assert() */
86# define _mrb_static_assert_cat0(a, b) a##b
87# define _mrb_static_assert_cat(a, b) _mrb_static_assert_cat0(a, b)
88# ifdef __COUNTER__
89# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __COUNTER__)
90# else
91# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __LINE__)
92# endif
93# define mrb_static_assert2(exp, str) \
94 struct _mrb_static_assert_id(_mrb_static_assert_) { char x[(exp) ? 1 : -1]; }
95#endif
96
97#ifndef mrb_static_assert
98# define mrb_static_assert1(exp) mrb_static_assert2(exp, #exp)
99# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */
100# define mrb_static_assert_selector(a, b, name, ...) name
108# define mrb_static_assert(...) \
109 mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__))
110#endif
111
112#define mrb_static_assert_powerof2(num) mrb_static_assert((num) > 0 && (num) == ((num) & -(num)), "need power of 2 for " #num)
113
114#include "mrbconf.h"
115
116#include <mruby/common.h>
117#include <mruby/value.h>
118#include <mruby/gc.h>
119#include <mruby/version.h>
120
121#ifndef MRB_NO_FLOAT
122#include <math.h>
123#include <float.h>
124#ifndef FLT_EPSILON
125#define FLT_EPSILON (1.19209290e-07f)
126#endif
127#ifndef DBL_EPSILON
128#define DBL_EPSILON ((double)2.22044604925031308085e-16L)
129#endif
130#ifndef LDBL_EPSILON
131#define LDBL_EPSILON (1.08420217248550443401e-19L)
132#endif
133
134#ifdef MRB_USE_FLOAT32
135#define MRB_FLOAT_EPSILON FLT_EPSILON
136#else
137#define MRB_FLOAT_EPSILON DBL_EPSILON
138#endif
139#endif
140
145
146typedef uint8_t mrb_code;
147
155typedef uint32_t mrb_aspec;
156
157typedef struct mrb_irep mrb_irep;
158struct mrb_state;
159
169typedef void* (*mrb_allocf) (struct mrb_state *mrb, void *ptr, size_t size, void *ud);
170
171#ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE
172#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
173#endif
174
175typedef struct {
176 uint8_t n:4; /* (15=*) c=n|nk<<4 */
177 uint8_t nk:4; /* (15=*) */
178 uint8_t cci; /* called from C function */
179 mrb_sym mid;
180 const struct RProc *proc;
181 struct RProc *blk;
182 mrb_value *stack;
183 const mrb_code *pc; /* current address on iseq of this proc */
184 union {
185 struct REnv *env;
186 struct RClass *target_class;
187 } u;
189
190enum mrb_fiber_state {
191 MRB_FIBER_CREATED = 0,
192 MRB_FIBER_RUNNING,
193 MRB_FIBER_RESUMED,
194 MRB_FIBER_SUSPENDED,
195 MRB_FIBER_TRANSFERRED,
196 MRB_FIBER_TERMINATED,
197};
198
200 struct mrb_context *prev;
201
202 mrb_value *stbase, *stend; /* stack of virtual machine */
203
204 mrb_callinfo *ci;
205 mrb_callinfo *cibase, *ciend;
206
207 enum mrb_fiber_state status : 4;
208 mrb_bool vmexec : 1;
209 struct RFiber *fib;
210};
211
212#ifdef MRB_METHOD_CACHE_SIZE
213# undef MRB_NO_METHOD_CACHE
214mrb_static_assert_powerof2(MRB_METHOD_CACHE_SIZE);
215#else
216/* default method cache size: 256 */
217/* cache size needs to be power of 2 */
218# define MRB_METHOD_CACHE_SIZE (1<<8)
219#endif
220
230typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self);
231
232#ifndef MRB_USE_METHOD_T_STRUCT
233typedef uintptr_t mrb_method_t;
234#else
235typedef struct {
236 uint8_t flags;
237 union {
238 struct RProc *proc;
239 mrb_func_t func;
240 };
241} mrb_method_t;
242#endif
243
244#ifndef MRB_NO_METHOD_CACHE
246 struct RClass *c, *c0;
247 mrb_sym mid;
248 mrb_method_t m;
249};
250#endif
251
252struct mrb_jmpbuf;
253
254typedef void (*mrb_atexit_func)(struct mrb_state*);
255
256typedef struct mrb_state {
257 struct mrb_jmpbuf *jmp;
258
259 mrb_allocf allocf; /* memory allocation function */
260 void *allocf_ud; /* auxiliary data of allocf */
261
262 struct mrb_context *c;
263 struct mrb_context *root_c;
264 struct iv_tbl *globals; /* global variable table */
265
266 struct RObject *exc; /* exception */
267
268 struct RObject *top_self;
269 struct RClass *object_class; /* Object class */
270 struct RClass *class_class;
271 struct RClass *module_class;
272 struct RClass *proc_class;
273 struct RClass *string_class;
274 struct RClass *array_class;
275 struct RClass *hash_class;
276 struct RClass *range_class;
277
278#ifndef MRB_NO_FLOAT
279 struct RClass *float_class;
280#endif
281 struct RClass *integer_class;
282 struct RClass *true_class;
283 struct RClass *false_class;
284 struct RClass *nil_class;
285 struct RClass *symbol_class;
286 struct RClass *kernel_module;
287
288 mrb_gc gc;
289
290#ifndef MRB_NO_METHOD_CACHE
291 struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE];
292#endif
293
294 mrb_sym symidx;
295 const char **symtbl;
296 uint8_t *symlink;
297 uint8_t *symflags;
298 mrb_sym symhash[256];
299 size_t symcapa;
300#ifndef MRB_USE_ALL_SYMBOLS
301 char symbuf[8]; /* buffer for small symbol names */
302#endif
303
304#ifdef MRB_USE_DEBUG_HOOK
305 void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
306 void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
307#endif
308
309#ifdef MRB_BYTECODE_DECODE_OPTION
310 mrb_code (*bytecode_decoder)(struct mrb_state* mrb, mrb_code code);
311#endif
312
313 struct RClass *eException_class;
314 struct RClass *eStandardError_class;
315 struct RObject *nomem_err; /* pre-allocated NoMemoryError */
316 struct RObject *stack_err; /* pre-allocated SystemStackError */
317#ifdef MRB_GC_FIXED_ARENA
318 struct RObject *arena_err; /* pre-allocated arena overflow error */
319#endif
320
321 void *ud; /* auxiliary data */
322
323#ifdef MRB_FIXED_STATE_ATEXIT_STACK
324 mrb_atexit_func atexit_stack[MRB_FIXED_STATE_ATEXIT_STACK_SIZE];
325#else
326 mrb_atexit_func *atexit_stack;
327#endif
328 uint16_t atexit_stack_len;
329} mrb_state;
330
352MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super);
353MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super);
354
362MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name);
363MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name);
364
371
378
390MRB_API void mrb_include_module(mrb_state *mrb, struct RClass *cla, struct RClass *included);
391
403MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClass *prepended);
404
429MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);
430MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
431
457MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
458MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
459
465MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
466MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
467
493MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
494MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
495
522MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val);
523MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val);
524
573MRB_API void mrb_undef_method(mrb_state *mrb, struct RClass *cla, const char *name);
574MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);
575
613MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name);
614MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name);
615
644MRB_API mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);
645
647MRB_INLINE mrb_value mrb_class_new_instance(mrb_state *mrb, mrb_int argc, const mrb_value *argv, struct RClass *c)
648{
649 return mrb_obj_new(mrb,c,argc,argv);
650}
651
671MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
672
688
715MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
716MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name);
717
724MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name);
725MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name);
726
733MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name);
734#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))
735
765MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);
766MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
767
775MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
776MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
777
784MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
785MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name);
786
794MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
795MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
796
797/* a function to raise NotImplementedError with current method name */
798MRB_API void mrb_notimplement(mrb_state*);
799/* a function to be replacement of unimplemented method */
800MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value);
801
812
854
865MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
866MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super);
867
868MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
869MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
870
877#define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18)
878
885#define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13)
886
895#define MRB_ARGS_ARG(n1,n2) (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
896
898#define MRB_ARGS_REST() ((mrb_aspec)(1 << 12))
899
901#define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7)
902
904#define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
905
909#define MRB_ARGS_BLOCK() ((mrb_aspec)1)
910
914#define MRB_ARGS_ANY() MRB_ARGS_REST()
915
919#define MRB_ARGS_NONE() ((mrb_aspec)0)
920
958typedef const char *mrb_args_format;
959
1006typedef struct mrb_kwargs mrb_kwargs;
1007
1009{
1010 mrb_int num; /* number of keyword arguments */
1011 mrb_int required; /* number of required keyword arguments */
1012 const mrb_sym *table; /* C array of symbols for keyword names */
1013 mrb_value *values; /* keyword argument values */
1014 mrb_value *rest; /* keyword rest (dict) */
1015};
1016
1027MRB_API mrb_int mrb_get_args(mrb_state *mrb, mrb_args_format format, ...);
1028
1034MRB_API mrb_int mrb_get_args_a(mrb_state *mrb, mrb_args_format format, void** ptr);
1035
1037mrb_get_mid(mrb_state *mrb) /* get method symbol */
1038{
1039 return mrb->c->ci->mid;
1040}
1041
1047MRB_API mrb_int mrb_get_argc(mrb_state *mrb);
1048
1055
1063
1068
1069/* `strlen` for character string literals (use with caution or `strlen` instead)
1070 Adjacent string literals are concatenated in C/C++ in translation phase 6.
1071 If `lit` is not one, the compiler will report a syntax error:
1072 MSVC: "error C2143: syntax error : missing ')' before 'string'"
1073 GCC: "error: expected ')' before string constant"
1074*/
1075#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
1076
1108MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...);
1109MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...);
1138MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv);
1142MRB_API 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);
1161MRB_API mrb_sym mrb_intern_cstr(mrb_state *mrb, const char* str);
1162MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
1163MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
1164#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
1165MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
1166/* mrb_intern_check series functions returns 0 if the symbol is not defined */
1167MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*);
1168MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t);
1169MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value);
1170/* mrb_check_intern series functions returns nil if the symbol is not defined */
1171/* otherwise returns mrb_value */
1172MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
1173MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
1174MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
1175MRB_API const char *mrb_sym_name(mrb_state*,mrb_sym);
1176MRB_API const char *mrb_sym_name_len(mrb_state*,mrb_sym,mrb_int*);
1177MRB_API const char *mrb_sym_dump(mrb_state*,mrb_sym);
1178MRB_API mrb_value mrb_sym_str(mrb_state*,mrb_sym);
1179#define mrb_sym2name(mrb,sym) mrb_sym_name(mrb,sym)
1180#define mrb_sym2name_len(mrb,sym,len) mrb_sym_name_len(mrb,sym,len)
1181#define mrb_sym2str(mrb,sym) mrb_sym_str(mrb,sym)
1182
1183MRB_API void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */
1184MRB_API void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
1185MRB_API void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */
1186MRB_API void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */
1187MRB_API void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memory available */
1188MRB_API struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
1189MRB_API void mrb_free(mrb_state*, void*);
1190
1200#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
1201
1202MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, mrb_int len);
1203
1208MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len);
1209#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
1210
1211MRB_API mrb_value mrb_obj_freeze(mrb_state*, mrb_value);
1212#define mrb_str_new_frozen(mrb,p,len) mrb_obj_freeze(mrb,mrb_str_new(mrb,p,len))
1213#define mrb_str_new_cstr_frozen(mrb,p) mrb_obj_freeze(mrb,mrb_str_new_cstr(mrb,p))
1214#define mrb_str_new_static_frozen(mrb,p,len) mrb_obj_freeze(mrb,mrb_str_new_static(mrb,p,len))
1215#define mrb_str_new_lit_frozen(mrb,lit) mrb_obj_freeze(mrb,mrb_str_new_lit(mrb,lit))
1216
1217#ifdef _WIN32
1218MRB_API char* mrb_utf8_from_locale(const char *p, int len);
1219MRB_API char* mrb_locale_from_utf8(const char *p, int len);
1220#define mrb_locale_free(p) free(p)
1221#define mrb_utf8_free(p) free(p)
1222#else
1223#define mrb_utf8_from_locale(p, l) ((char*)(p))
1224#define mrb_locale_from_utf8(p, l) ((char*)(p))
1225#define mrb_locale_free(p)
1226#define mrb_utf8_free(p)
1227#endif
1228
1236
1249
1263
1270MRB_API void mrb_close(mrb_state *mrb);
1271
1277MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
1278
1279MRB_API mrb_value mrb_top_self(mrb_state *mrb);
1280MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
1281MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
1282MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq);
1283/* compatibility macros */
1284#define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k))
1285#define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0)
1286#define mrb_context_run(m,p,s,k) mrb_vm_run((m),(p),(s),(k))
1287
1288MRB_API void mrb_p(mrb_state*, mrb_value);
1289MRB_API mrb_int mrb_obj_id(mrb_value obj);
1290MRB_API mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
1291
1292MRB_API mrb_bool mrb_obj_eq(mrb_state *mrb, mrb_value a, mrb_value b);
1293MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b);
1294MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
1295#ifndef MRB_NO_FLOAT
1296MRB_API mrb_value mrb_ensure_float_type(mrb_state *mrb, mrb_value val);
1297#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
1298/* obsolete: use mrb_ensure_float_type() instead */
1299#define mrb_to_float(mrb, val) mrb_ensure_float_type(mrb, val)
1300#endif
1301MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
1302MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
1303/* mrb_cmp(mrb, obj1, obj2): 1:0:-1; -2 for error */
1304MRB_API mrb_int mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
1305
1306#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
1307#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
1308
1309MRB_API void mrb_garbage_collect(mrb_state*);
1310MRB_API void mrb_full_gc(mrb_state*);
1311MRB_API void mrb_incremental_gc(mrb_state*);
1312MRB_API void mrb_gc_mark(mrb_state*,struct RBasic*);
1313#define mrb_gc_mark_value(mrb,val) do {\
1314 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
1315} while (0)
1316MRB_API void mrb_field_write_barrier(mrb_state*, struct RBasic*, struct RBasic*);
1317#define mrb_field_write_barrier_value(mrb, obj, val) do{\
1318 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
1319} while (0)
1320MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
1321
1322MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
1323#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method))
1324MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
1325#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method))
1326
1327MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
1328MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
1329MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
1330MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
1331MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
1332MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
1333MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
1334
1335#ifndef ISPRINT
1336#define ISASCII(c) ((unsigned)(c) <= 0x7f)
1337#define ISPRINT(c) (((unsigned)(c) - 0x20) < 0x5f)
1338#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
1339#define ISUPPER(c) (((unsigned)(c) - 'A') < 26)
1340#define ISLOWER(c) (((unsigned)(c) - 'a') < 26)
1341#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
1342#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
1343#define ISXDIGIT(c) (ISDIGIT(c) || ((unsigned)(c) | 0x20) - 'a' < 6)
1344#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
1345#define ISBLANK(c) ((c) == ' ' || (c) == '\t')
1346#define ISCNTRL(c) ((unsigned)(c) < 0x20 || (c) == 0x7f)
1347#define TOUPPER(c) (ISLOWER(c) ? ((c) & 0x5f) : (c))
1348#define TOLOWER(c) (ISUPPER(c) ? ((c) | 0x20) : (c))
1349#endif
1350
1351MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len);
1352MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
1353
1354MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
1355MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
1356MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
1357MRB_API mrb_noreturn void mrb_frozen_error(mrb_state *mrb, void *frozen_obj);
1358MRB_API mrb_noreturn void mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max);
1359MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
1360MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *mesg);
1361MRB_API void mrb_print_backtrace(mrb_state *mrb);
1362MRB_API void mrb_print_error(mrb_state *mrb);
1363/* function for `raisef` formatting */
1364MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap);
1365
1366/* macros to get typical exception objects
1367 note:
1368 + those E_* macros requires mrb_state* variable named mrb.
1369 + exception objects obtained from those macros are local to mrb
1370*/
1371#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym)
1372#define E_EXCEPTION mrb->eException_class
1373#define E_STANDARD_ERROR mrb->eStandardError_class
1374#define E_RUNTIME_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
1375#define E_TYPE_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
1376#define E_ZERODIV_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ZeroDivisionError))
1377#define E_ARGUMENT_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
1378#define E_INDEX_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError))
1379#define E_RANGE_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError))
1380#define E_NAME_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NameError))
1381#define E_NOMETHOD_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NoMethodError))
1382#define E_SCRIPT_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ScriptError))
1383#define E_SYNTAX_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(SyntaxError))
1384#define E_LOCALJUMP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(LocalJumpError))
1385#define E_REGEXP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RegexpError))
1386#define E_FROZEN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FrozenError))
1387#define E_NOTIMP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NotImplementedError))
1388#define E_KEY_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(KeyError))
1389#ifndef MRB_NO_FLOAT
1390# define E_FLOATDOMAIN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FloatDomainError))
1391#endif
1392
1393MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
1394MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
1395MRB_API 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);
1396
1397/* continue execution to the proc */
1398/* this function should always be called as the last function of a method */
1399/* e.g. return mrb_yield_cont(mrb, proc, self, argc, argv); */
1400mrb_value mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb_value *argv);
1401
1402/* mrb_gc_protect() leaves the object in the arena */
1403MRB_API void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
1404/* mrb_gc_register() keeps the object from GC. */
1405MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj);
1406/* mrb_gc_unregister() removes the object from GC root. */
1407MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj);
1408
1409/* type conversion/check functions */
1410MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self);
1411MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
1412MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash);
1413MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
1414MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str);
1415MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
1416/* obsolete: use mrb_ensure_string_type() instead */
1417#define mrb_string_type(mrb, str) mrb_ensure_string_type(mrb,str)
1418#define mrb_to_str(mrb, str) mrb_ensure_string_type(mrb,str)
1419/* obsolete: use mrb_obj_as_string() instead */
1420#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str)
1421/* check if val is an integer (including Bigint) */
1422MRB_API mrb_value mrb_ensure_integer_type(mrb_state *mrb, mrb_value val);
1423/* check if val fit in mrb_int */
1424MRB_API mrb_value mrb_ensure_int_type(mrb_state *mrb, mrb_value val);
1425#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
1426/* obsolete: use mrb_ensure_int_type() instead */
1427#define mrb_to_integer(mrb, val) mrb_ensure_int_type(mrb, val)
1428#define mrb_to_int(mrb, val) mrb_ensure_int_type(mrb, val)
1429
1430/* string type checking (contrary to the name, it doesn't convert) */
1431MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
1432MRB_API void mrb_check_frozen(mrb_state *mrb, void *);
1433MRB_API void mrb_check_frozen_value(mrb_state *mrb, mrb_value v);
1434MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b);
1435MRB_API void mrb_define_alias_id(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
1436MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
1437MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
1438
1439MRB_API mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
1440
1441MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
1442MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
1443MRB_API mrb_bool mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func);
1444
1445/* obsolete function(s); will be removed */
1446#define mrb_int(mrb, val) mrb_as_int(mrb, val)
1447
1454
1462MRB_API mrb_value mrb_fiber_resume(mrb_state *mrb, mrb_value fib, mrb_int argc, const mrb_value *argv);
1463
1478MRB_API mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
1479
1486
1492#define E_FIBER_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FiberError))
1493MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
1494
1495/* memory pool implementation */
1496typedef struct mrb_pool mrb_pool;
1497MRB_API struct mrb_pool* mrb_pool_open(mrb_state*);
1498MRB_API void mrb_pool_close(struct mrb_pool*);
1499MRB_API void* mrb_pool_alloc(struct mrb_pool*, size_t);
1500MRB_API void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
1501MRB_API mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
1502/* temporary memory allocation, only effective while GC arena is kept */
1503MRB_API void* mrb_alloca(mrb_state *mrb, size_t);
1504
1505MRB_API void mrb_state_atexit(mrb_state *mrb, mrb_atexit_func func);
1506
1507MRB_API void mrb_show_version(mrb_state *mrb);
1508MRB_API void mrb_show_copyright(mrb_state *mrb);
1509
1510MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
1511
1512#ifdef MRB_PRESYM_SCANNING
1513# include <mruby/presym/scanning.h>
1514#endif
1515
1516#if 0
1517/* memcpy and memset does not work with gdb reverse-next on my box */
1518/* use naive memcpy and memset instead */
1519#undef memcpy
1520#undef memset
1521static void*
1522mrbmemcpy(void *dst, const void *src, size_t n)
1523{
1524 char *d = (char*)dst;
1525 const char *s = (const char*)src;
1526 while (n--)
1527 *d++ = *s++;
1528 return d;
1529}
1530#define memcpy(a,b,c) mrbmemcpy(a,b,c)
1531
1532static void*
1533mrbmemset(void *s, int c, size_t n)
1534{
1535 char *t = (char*)s;
1536 while (n--)
1537 *t++ = c;
1538 return s;
1539}
1540#define memset(a,b,c) mrbmemset(a,b,c)
1541#endif
1542
1544
1545#endif /* MRUBY_H */
Specifies the number of arguments a function takes.
mruby Boolean.
mruby Symbol.
mruby common platform definition"
#define MRB_INLINE
Declare a function as always inlined.
Definition common.h:68
#define MRB_END_DECL
End declarations in C mode.
Definition common.h:28
#define MRB_BEGIN_DECL
Start declarations in C mode.
Definition common.h:26
#define MRB_API
Declare a public mruby API function.
Definition common.h:79
#define mrb_noreturn
Shared compiler macros.
Definition common.h:50
garbage collector for mruby
mrb_state * mrb_open_core(mrb_allocf f, void *ud)
Create new mrb_state with just the mruby core.
Definition state.c:39
void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClass *prepended)
Prepends a module in another class or module.
Definition class.c:1528
mrb_value mrb_fiber_new(mrb_state *mrb, const struct RProc *proc)
Create a new Fiber from proc object.
mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib)
Check if a Fiber is alive.
mrb_int mrb_get_argc(mrb_state *mrb)
Retrieve number of arguments from mrb_state.
Definition class.c:856
void *(* mrb_allocf)(struct mrb_state *mrb, void *ptr, size_t size, void *ud)
Function pointer type of custom allocator used in.
Definition mruby.h:169
void * mrb_default_allocf(mrb_state *, void *, size_t, void *)
The default allocation function.
Definition allocf.c:19
mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv)
Yield a Fiber.
mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc,...)
Call existing ruby functions.
Definition vm.c:495
struct RClass * mrb_module_new(mrb_state *mrb)
Creates a new module, Module.
Definition class.c:2221
mrb_state * mrb_open_allocf(mrb_allocf f, void *ud)
Create new mrb_state with custom allocators.
Definition state.c:78
struct RClass * mrb_define_module(mrb_state *mrb, const char *name)
Defines a new module.
Definition class.c:483
mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj)
Duplicate an object.
Definition class.c:2867
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.
Definition vm.c:726
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.
Definition class.c:1992
void mrb_define_const(mrb_state *mrb, struct RClass *cla, const char *name, mrb_value val)
Defines a constant.
Definition variable.c:871
const mrb_value * mrb_get_argv(mrb_state *mrb)
Retrieve an array of arguments from mrb_state.
Definition class.c:869
void mrb_undef_method(mrb_state *mrb, struct RClass *cla, const char *name)
Undefines a method.
Definition class.c:2348
uint8_t mrb_code
mruby C API entry point
Definition mruby.h:146
mrb_int mrb_get_args_a(mrb_state *mrb, mrb_args_format format, void **ptr)
Array version of mrb_get_args()
Definition class.c:1376
void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b)
Definition class.c:2277
mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name)
Returns an mrb_bool.
Definition class.c:643
mrb_value mrb_get_arg1(mrb_state *mrb)
Retrieve the first and only argument from mrb_state.
Definition class.c:882
mrb_value mrb_fiber_resume(mrb_state *mrb, mrb_value fib, mrb_int argc, const mrb_value *argv)
Resume a Fiber.
struct RClass * mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
Defines a new class.
Definition class.c:560
mrb_int mrb_get_args(mrb_state *mrb, mrb_args_format format,...)
Retrieve arguments from mrb_state.
Definition class.c:1366
mrb_state * mrb_open(void)
Creates new mrb_state.
Definition state.c:62
void mrb_include_module(mrb_state *mrb, struct RClass *cla, struct RClass *included)
Include a module in another class or module.
Definition class.c:1487
struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
Gets a child class.
Definition class.c:657
struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super)
Creates a new instance of Class, Class.
Definition class.c:2200
mrb_bool mrb_block_given_p(mrb_state *mrb)
Check if a block argument is given from mrb_state.
Definition class.c:905
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.
Definition class.c:1736
void mrb_close(mrb_state *mrb)
Closes and frees a mrb_state.
Definition state.c:179
mrb_value mrb_str_new_cstr(mrb_state *, const char *)
Turns a C string into a Ruby string value.
Definition string.c:190
static mrb_value mrb_class_new_instance(mrb_state *mrb, mrb_int argc, const mrb_value *argv, struct RClass *c)
Definition mruby.h:647
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.
Definition class.c:1703
mrb_bool mrb_class_defined(mrb_state *mrb, const char *name)
Returns an mrb_bool.
Definition class.c:629
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.
Definition class.c:820
struct RClass * mrb_exc_get_id(mrb_state *mrb, mrb_sym name)
Gets a exception class.
Definition class.c:681
mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val)
Returns the singleton class of an object.
Definition class.c:1692
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.
Definition class.c:755
struct RClass * mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val)
Returns the singleton class of an object.
Definition class.c:1664
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.
Definition vm.c:656
struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
Gets a module defined under another module.
Definition class.c:700
const char * mrb_args_format
Format specifiers for {mrb_get_args} function.
Definition mruby.h:958
mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass *c, mrb_sym mid)
Returns true if obj responds to the given method.
Definition class.c:2111
void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name)
Undefine a class method.
Definition class.c:2360
struct RClass * mrb_module_get(mrb_state *mrb, const char *name)
Gets a module.
Definition class.c:712
struct RClass * mrb_class_get(mrb_state *mrb, const char *name)
Gets a class.
Definition class.c:669
struct RClass * mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super)
Definition class.c:740
mrb_sym mrb_intern_cstr(mrb_state *mrb, const char *str)
Create a symbol from C string.
Definition symbol.c:250
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.
Definition class.c:1717
mrb_value(* mrb_func_t)(struct mrb_state *mrb, mrb_value self)
Function pointer type for a function callable by mruby.
Definition mruby.h:230
Definition object.h:19
Class class.
Definition class.h:17
Proc class.
Definition proc.h:18
Definition object.h:38
Definition object.h:30
Definition proc.h:42
Definition variable.c:17
Definition mruby.h:245
Definition mruby.h:175
Definition mruby.h:199
Definition gc.h:48
Definition irep.h:55
Definition throw.h:57
Definition mruby.h:1009
Definition pool.c:45
Definition mruby.h:256
Definition boxing_nan.h:40
mruby value definitions
mruby version definition