sabme ua / mruby-mbed

mbed I/F binding for mruby

Dependents:   mruby_mbed_web mirb_mbed

mbed-mruby

How to use

Class

include/mruby.h@1:8ccd1d494a4b, 2015-04-13 (annotated)

Committer:
mzta
Date:
Mon Apr 13 05:20:15 2015 +0000
Revision:
1:8ccd1d494a4b
Parent:
0:158c61bb030f 
- code refactoring.; - add SPI, SPISlave, I2C class to mruby-mbed (Incomplete).

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mzta 0:158c61bb030f 1 /*
mzta 0:158c61bb030f 2 ** mruby - An embeddable Ruby implementation
mzta 0:158c61bb030f 3 **
mzta 0:158c61bb030f 4 ** Copyright (c) mruby developers 2010-2014
mzta 0:158c61bb030f 5 **
mzta 0:158c61bb030f 6 ** Permission is hereby granted, free of charge, to any person obtaining
mzta 0:158c61bb030f 7 ** a copy of this software and associated documentation files (the
mzta 0:158c61bb030f 8 ** "Software"), to deal in the Software without restriction, including
mzta 0:158c61bb030f 9 ** without limitation the rights to use, copy, modify, merge, publish,
mzta 0:158c61bb030f 10 ** distribute, sublicense, and/or sell copies of the Software, and to
mzta 0:158c61bb030f 11 ** permit persons to whom the Software is furnished to do so, subject to
mzta 0:158c61bb030f 12 ** the following conditions:
mzta 0:158c61bb030f 13 **
mzta 0:158c61bb030f 14 ** The above copyright notice and this permission notice shall be
mzta 0:158c61bb030f 15 ** included in all copies or substantial portions of the Software.
mzta 0:158c61bb030f 16 **
mzta 0:158c61bb030f 17 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
mzta 0:158c61bb030f 18 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
mzta 0:158c61bb030f 19 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
mzta 0:158c61bb030f 20 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
mzta 0:158c61bb030f 21 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
mzta 0:158c61bb030f 22 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
mzta 0:158c61bb030f 23 ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
mzta 0:158c61bb030f 24 **
mzta 0:158c61bb030f 25 ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
mzta 0:158c61bb030f 26 */
mzta 0:158c61bb030f 27
mzta 0:158c61bb030f 28 #ifndef MRUBY_H
mzta 0:158c61bb030f 29 #define MRUBY_H
mzta 0:158c61bb030f 30
mzta 0:158c61bb030f 31 #if defined(__cplusplus)
mzta 0:158c61bb030f 32 extern "C" {
mzta 0:158c61bb030f 33 #endif
mzta 0:158c61bb030f 34
mzta 0:158c61bb030f 35 #include <stdint.h>
mzta 0:158c61bb030f 36 #include <stddef.h>
mzta 0:158c61bb030f 37 #include <limits.h>
mzta 0:158c61bb030f 38
mzta 0:158c61bb030f 39 #include "mrbconf.h"
mzta 0:158c61bb030f 40 #include "mruby/value.h"
mzta 0:158c61bb030f 41 #include "mruby/version.h"
mzta 0:158c61bb030f 42
mzta 0:158c61bb030f 43 typedef uint32_t mrb_code;
mzta 0:158c61bb030f 44 typedef uint32_t mrb_aspec;
mzta 0:158c61bb030f 45
mzta 0:158c61bb030f 46 struct mrb_irep;
mzta 0:158c61bb030f 47 struct mrb_state;
mzta 0:158c61bb030f 48
mzta 0:158c61bb030f 49 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
mzta 0:158c61bb030f 50
mzta 0:158c61bb030f 51 #ifndef MRB_GC_ARENA_SIZE
mzta 0:158c61bb030f 52 #define MRB_GC_ARENA_SIZE 100
mzta 0:158c61bb030f 53 #endif
mzta 0:158c61bb030f 54
mzta 0:158c61bb030f 55 #ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE
mzta 0:158c61bb030f 56 #define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
mzta 0:158c61bb030f 57 #endif
mzta 0:158c61bb030f 58
mzta 0:158c61bb030f 59 typedef struct {
mzta 0:158c61bb030f 60 mrb_sym mid;
mzta 0:158c61bb030f 61 struct RProc *proc;
mzta 0:158c61bb030f 62 mrb_value *stackent;
mzta 0:158c61bb030f 63 int nregs;
mzta 0:158c61bb030f 64 int ridx;
mzta 0:158c61bb030f 65 int eidx;
mzta 0:158c61bb030f 66 struct REnv *env;
mzta 0:158c61bb030f 67 mrb_code *pc; /* return address */
mzta 0:158c61bb030f 68 mrb_code *err; /* error position */
mzta 0:158c61bb030f 69 int argc;
mzta 0:158c61bb030f 70 int acc;
mzta 0:158c61bb030f 71 struct RClass *target_class;
mzta 0:158c61bb030f 72 } mrb_callinfo;
mzta 0:158c61bb030f 73
mzta 0:158c61bb030f 74 enum mrb_fiber_state {
mzta 0:158c61bb030f 75 MRB_FIBER_CREATED = 0,
mzta 0:158c61bb030f 76 MRB_FIBER_RUNNING,
mzta 0:158c61bb030f 77 MRB_FIBER_RESUMING,
mzta 0:158c61bb030f 78 MRB_FIBER_SUSPENDED,
mzta 0:158c61bb030f 79 MRB_FIBER_TRANSFERRED,
mzta 0:158c61bb030f 80 MRB_FIBER_TERMINATED,
mzta 0:158c61bb030f 81 };
mzta 0:158c61bb030f 82
mzta 0:158c61bb030f 83 struct mrb_context {
mzta 0:158c61bb030f 84 struct mrb_context *prev;
mzta 0:158c61bb030f 85
mzta 0:158c61bb030f 86 mrb_value *stack; /* stack of virtual machine */
mzta 0:158c61bb030f 87 mrb_value *stbase, *stend;
mzta 0:158c61bb030f 88
mzta 0:158c61bb030f 89 mrb_callinfo *ci;
mzta 0:158c61bb030f 90 mrb_callinfo *cibase, *ciend;
mzta 0:158c61bb030f 91
mzta 0:158c61bb030f 92 mrb_code **rescue; /* exception handler stack */
mzta 0:158c61bb030f 93 int rsize;
mzta 0:158c61bb030f 94 struct RProc **ensure; /* ensure handler stack */
mzta 0:158c61bb030f 95 int esize;
mzta 0:158c61bb030f 96
mzta 0:158c61bb030f 97 enum mrb_fiber_state status;
mzta 0:158c61bb030f 98 struct RFiber *fib;
mzta 0:158c61bb030f 99 };
mzta 0:158c61bb030f 100
mzta 0:158c61bb030f 101 enum gc_state {
mzta 0:158c61bb030f 102 GC_STATE_ROOT = 0,
mzta 0:158c61bb030f 103 GC_STATE_MARK,
mzta 0:158c61bb030f 104 GC_STATE_SWEEP
mzta 0:158c61bb030f 105 };
mzta 0:158c61bb030f 106
mzta 0:158c61bb030f 107 struct mrb_jmpbuf;
mzta 0:158c61bb030f 108
mzta 0:158c61bb030f 109 typedef void (*mrb_atexit_func)(struct mrb_state*);
mzta 0:158c61bb030f 110
mzta 0:158c61bb030f 111 typedef struct mrb_state {
mzta 0:158c61bb030f 112 struct mrb_jmpbuf *jmp;
mzta 0:158c61bb030f 113
mzta 0:158c61bb030f 114 mrb_allocf allocf; /* memory allocation function */
mzta 0:158c61bb030f 115 void *allocf_ud; /* auxiliary data of allocf */
mzta 0:158c61bb030f 116
mzta 0:158c61bb030f 117 struct mrb_context *c;
mzta 0:158c61bb030f 118 struct mrb_context *root_c;
mzta 0:158c61bb030f 119
mzta 0:158c61bb030f 120 struct RObject *exc; /* exception */
mzta 0:158c61bb030f 121 struct iv_tbl *globals; /* global variable table */
mzta 0:158c61bb030f 122
mzta 0:158c61bb030f 123 struct RObject *top_self;
mzta 0:158c61bb030f 124 struct RClass *object_class; /* Object class */
mzta 0:158c61bb030f 125 struct RClass *class_class;
mzta 0:158c61bb030f 126 struct RClass *module_class;
mzta 0:158c61bb030f 127 struct RClass *proc_class;
mzta 0:158c61bb030f 128 struct RClass *string_class;
mzta 0:158c61bb030f 129 struct RClass *array_class;
mzta 0:158c61bb030f 130 struct RClass *hash_class;
mzta 0:158c61bb030f 131
mzta 0:158c61bb030f 132 struct RClass *float_class;
mzta 0:158c61bb030f 133 struct RClass *fixnum_class;
mzta 0:158c61bb030f 134 struct RClass *true_class;
mzta 0:158c61bb030f 135 struct RClass *false_class;
mzta 0:158c61bb030f 136 struct RClass *nil_class;
mzta 0:158c61bb030f 137 struct RClass *symbol_class;
mzta 0:158c61bb030f 138 struct RClass *kernel_module;
mzta 0:158c61bb030f 139
mzta 0:158c61bb030f 140 struct heap_page *heaps; /* heaps for GC */
mzta 0:158c61bb030f 141 struct heap_page *sweeps;
mzta 0:158c61bb030f 142 struct heap_page *free_heaps;
mzta 0:158c61bb030f 143 size_t live; /* count of live objects */
mzta 0:158c61bb030f 144 #ifdef MRB_GC_FIXED_ARENA
mzta 0:158c61bb030f 145 struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
mzta 0:158c61bb030f 146 #else
mzta 0:158c61bb030f 147 struct RBasic **arena; /* GC protection array */
mzta 0:158c61bb030f 148 int arena_capa;
mzta 0:158c61bb030f 149 #endif
mzta 0:158c61bb030f 150 int arena_idx;
mzta 0:158c61bb030f 151
mzta 0:158c61bb030f 152 enum gc_state gc_state; /* state of gc */
mzta 0:158c61bb030f 153 int current_white_part; /* make white object by white_part */
mzta 0:158c61bb030f 154 struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
mzta 0:158c61bb030f 155 struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
mzta 0:158c61bb030f 156 size_t gc_live_after_mark;
mzta 0:158c61bb030f 157 size_t gc_threshold;
mzta 0:158c61bb030f 158 int gc_interval_ratio;
mzta 0:158c61bb030f 159 int gc_step_ratio;
mzta 0:158c61bb030f 160 mrb_bool gc_disabled:1;
mzta 0:158c61bb030f 161 mrb_bool gc_full:1;
mzta 0:158c61bb030f 162 mrb_bool is_generational_gc_mode:1;
mzta 0:158c61bb030f 163 mrb_bool out_of_memory:1;
mzta 0:158c61bb030f 164 size_t majorgc_old_threshold;
mzta 0:158c61bb030f 165 struct alloca_header *mems;
mzta 0:158c61bb030f 166
mzta 0:158c61bb030f 167 mrb_sym symidx;
mzta 0:158c61bb030f 168 struct kh_n2s *name2sym; /* symbol hash */
mzta 0:158c61bb030f 169 struct symbol_name *symtbl; /* symbol table */
mzta 0:158c61bb030f 170 size_t symcapa;
mzta 0:158c61bb030f 171
mzta 0:158c61bb030f 172 #ifdef ENABLE_DEBUG
mzta 0:158c61bb030f 173 void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
mzta 0:158c61bb030f 174 void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
mzta 0:158c61bb030f 175 #endif
mzta 0:158c61bb030f 176
mzta 0:158c61bb030f 177 struct RClass *eException_class;
mzta 0:158c61bb030f 178 struct RClass *eStandardError_class;
mzta 0:158c61bb030f 179 struct RObject *nomem_err; /* pre-allocated NoMemoryError */
mzta 0:158c61bb030f 180
mzta 0:158c61bb030f 181 void *ud; /* auxiliary data */
mzta 0:158c61bb030f 182
mzta 0:158c61bb030f 183 #ifdef MRB_FIXED_STATE_ATEXIT_STACK
mzta 0:158c61bb030f 184 mrb_atexit_func atexit_stack[MRB_FIXED_STATE_ATEXIT_STACK_SIZE];
mzta 0:158c61bb030f 185 #else
mzta 0:158c61bb030f 186 mrb_atexit_func *atexit_stack;
mzta 0:158c61bb030f 187 #endif
mzta 0:158c61bb030f 188 mrb_int atexit_stack_len;
mzta 0:158c61bb030f 189 } mrb_state;
mzta 0:158c61bb030f 190
mzta 0:158c61bb030f 191 #if __STDC_VERSION__ >= 201112L
mzta 0:158c61bb030f 192 # define mrb_noreturn _Noreturn
mzta 0:158c61bb030f 193 #elif defined __GNUC__ && !defined __STRICT_ANSI__
mzta 0:158c61bb030f 194 # define mrb_noreturn __attribute__((noreturn))
mzta 0:158c61bb030f 195 #elif defined _MSC_VER
mzta 0:158c61bb030f 196 # define mrb_noreturn __declspec(noreturn)
mzta 0:158c61bb030f 197 #else
mzta 0:158c61bb030f 198 # define mrb_noreturn
mzta 0:158c61bb030f 199 #endif
mzta 0:158c61bb030f 200
mzta 0:158c61bb030f 201 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
mzta 0:158c61bb030f 202 MRB_API struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*);
mzta 0:158c61bb030f 203 MRB_API struct RClass *mrb_define_module(mrb_state *, const char*);
mzta 0:158c61bb030f 204 MRB_API mrb_value mrb_singleton_class(mrb_state*, mrb_value);
mzta 0:158c61bb030f 205 MRB_API void mrb_include_module(mrb_state*, struct RClass*, struct RClass*);
mzta 0:158c61bb030f 206
mzta 0:158c61bb030f 207 MRB_API void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
mzta 0:158c61bb030f 208 MRB_API void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, mrb_aspec);
mzta 0:158c61bb030f 209 MRB_API void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_func_t, mrb_aspec);
mzta 0:158c61bb030f 210 MRB_API void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
mzta 0:158c61bb030f 211 MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
mzta 0:158c61bb030f 212 MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*);
mzta 0:158c61bb030f 213 MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
mzta 0:158c61bb030f 214 MRB_API mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);
mzta 0:158c61bb030f 215 #define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv)
mzta 0:158c61bb030f 216 MRB_API mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
mzta 0:158c61bb030f 217 MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
mzta 0:158c61bb030f 218 MRB_API struct RClass * mrb_module_new(mrb_state *mrb);
mzta 0:158c61bb030f 219 MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
mzta 0:158c61bb030f 220 MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
mzta 0:158c61bb030f 221 MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
mzta 0:158c61bb030f 222 MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
mzta 0:158c61bb030f 223 MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
mzta 0:158c61bb030f 224 MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value);
mzta 0:158c61bb030f 225
mzta 0:158c61bb030f 226 MRB_API mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 227 MRB_API mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
mzta 0:158c61bb030f 228 MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid);
mzta 0:158c61bb030f 229 MRB_API struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
mzta 0:158c61bb030f 230 MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
mzta 0:158c61bb030f 231
mzta 0:158c61bb030f 232 /* required arguments */
mzta 0:158c61bb030f 233 #define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18)
mzta 0:158c61bb030f 234 /* optional arguments */
mzta 0:158c61bb030f 235 #define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13)
mzta 0:158c61bb030f 236 /* mandatory and optinal arguments */
mzta 0:158c61bb030f 237 #define MRB_ARGS_ARG(n1,n2) (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
mzta 0:158c61bb030f 238
mzta 0:158c61bb030f 239 /* rest argument */
mzta 0:158c61bb030f 240 #define MRB_ARGS_REST() ((mrb_aspec)(1 << 12))
mzta 0:158c61bb030f 241 /* required arguments after rest */
mzta 0:158c61bb030f 242 #define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7)
mzta 0:158c61bb030f 243 /* keyword arguments (n of keys, kdict) */
mzta 0:158c61bb030f 244 #define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
mzta 0:158c61bb030f 245 /* block argument */
mzta 0:158c61bb030f 246 #define MRB_ARGS_BLOCK() ((mrb_aspec)1)
mzta 0:158c61bb030f 247
mzta 0:158c61bb030f 248 /* accept any number of arguments */
mzta 0:158c61bb030f 249 #define MRB_ARGS_ANY() MRB_ARGS_REST()
mzta 0:158c61bb030f 250 /* accept no arguments */
mzta 0:158c61bb030f 251 #define MRB_ARGS_NONE() ((mrb_aspec)0)
mzta 0:158c61bb030f 252
mzta 0:158c61bb030f 253 /* compatibility macros; will be removed */
mzta 0:158c61bb030f 254 #define ARGS_REQ(n) MRB_ARGS_REQ(n)
mzta 0:158c61bb030f 255 #define ARGS_OPT(n) MRB_ARGS_OPT(n)
mzta 0:158c61bb030f 256 #define ARGS_REST() MRB_ARGS_REST()
mzta 0:158c61bb030f 257 #define ARGS_POST(n) MRB_ARGS_POST()
mzta 0:158c61bb030f 258 #define ARGS_KEY(n1,n2) MRB_ARGS_KEY(n1,n2)
mzta 0:158c61bb030f 259 #define ARGS_BLOCK() MRB_ARGS_BLOCK()
mzta 0:158c61bb030f 260 #define ARGS_ANY() MRB_ARGS_ANY()
mzta 0:158c61bb030f 261 #define ARGS_NONE() MRB_ARGS_NONE()
mzta 0:158c61bb030f 262
mzta 0:158c61bb030f 263 MRB_API mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
mzta 0:158c61bb030f 264
mzta 0:158c61bb030f 265 /* `strlen` for character string literals (use with caution or `strlen` instead)
mzta 0:158c61bb030f 266 Adjacent string literals are concatenated in C/C++ in translation phase 6.
mzta 0:158c61bb030f 267 If `lit` is not one, the compiler will report a syntax error:
mzta 0:158c61bb030f 268 MSVC: "error C2143: syntax error : missing ')' before 'string'"
mzta 0:158c61bb030f 269 GCC: "error: expected ')' before string constant"
mzta 0:158c61bb030f 270 */
mzta 0:158c61bb030f 271 #define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
mzta 0:158c61bb030f 272
mzta 0:158c61bb030f 273 MRB_API mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
mzta 0:158c61bb030f 274 MRB_API mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*);
mzta 0:158c61bb030f 275 MRB_API mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value);
mzta 0:158c61bb030f 276 MRB_API mrb_sym mrb_intern_cstr(mrb_state*,const char*);
mzta 0:158c61bb030f 277 MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
mzta 0:158c61bb030f 278 MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
mzta 0:158c61bb030f 279 #define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
mzta 0:158c61bb030f 280 MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
mzta 0:158c61bb030f 281 MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
mzta 0:158c61bb030f 282 MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
mzta 0:158c61bb030f 283 MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
mzta 0:158c61bb030f 284 MRB_API const char *mrb_sym2name(mrb_state*,mrb_sym);
mzta 0:158c61bb030f 285 MRB_API const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*);
mzta 0:158c61bb030f 286 MRB_API mrb_value mrb_sym2str(mrb_state*,mrb_sym);
mzta 0:158c61bb030f 287
mzta 0:158c61bb030f 288 MRB_API void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */
mzta 0:158c61bb030f 289 MRB_API void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
mzta 0:158c61bb030f 290 MRB_API void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */
mzta 0:158c61bb030f 291 MRB_API void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */
mzta 0:158c61bb030f 292 MRB_API void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memory available */
mzta 0:158c61bb030f 293 MRB_API struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
mzta 0:158c61bb030f 294 MRB_API void mrb_free(mrb_state*, void*);
mzta 0:158c61bb030f 295
mzta 0:158c61bb030f 296 MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
mzta 0:158c61bb030f 297 MRB_API mrb_value mrb_str_new_cstr(mrb_state*, const char*);
mzta 0:158c61bb030f 298 MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
mzta 0:158c61bb030f 299 #define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
mzta 0:158c61bb030f 300
mzta 0:158c61bb030f 301 MRB_API mrb_state* mrb_open(void);
mzta 0:158c61bb030f 302 MRB_API mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
mzta 0:158c61bb030f 303 MRB_API mrb_state* mrb_open_core(mrb_allocf, void *ud);
mzta 0:158c61bb030f 304 MRB_API void mrb_close(mrb_state*);
mzta 0:158c61bb030f 305
mzta 0:158c61bb030f 306 MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
mzta 0:158c61bb030f 307
mzta 0:158c61bb030f 308 MRB_API mrb_value mrb_top_self(mrb_state *);
mzta 0:158c61bb030f 309 MRB_API mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
mzta 0:158c61bb030f 310 MRB_API mrb_value mrb_toplevel_run(mrb_state*, struct RProc*);
mzta 0:158c61bb030f 311 MRB_API mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
mzta 0:158c61bb030f 312
mzta 0:158c61bb030f 313 MRB_API void mrb_p(mrb_state*, mrb_value);
mzta 0:158c61bb030f 314 MRB_API mrb_int mrb_obj_id(mrb_value obj);
mzta 0:158c61bb030f 315 MRB_API mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
mzta 0:158c61bb030f 316
mzta 0:158c61bb030f 317 MRB_API mrb_bool mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
mzta 0:158c61bb030f 318 MRB_API mrb_bool mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
mzta 0:158c61bb030f 319 MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
mzta 0:158c61bb030f 320 MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, int base);
mzta 0:158c61bb030f 321 MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
mzta 0:158c61bb030f 322 MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
mzta 0:158c61bb030f 323 MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 324 MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
mzta 0:158c61bb030f 325
mzta 0:158c61bb030f 326 MRB_API void mrb_garbage_collect(mrb_state*);
mzta 0:158c61bb030f 327 MRB_API void mrb_full_gc(mrb_state*);
mzta 0:158c61bb030f 328 MRB_API void mrb_incremental_gc(mrb_state *);
mzta 0:158c61bb030f 329 MRB_API int mrb_gc_arena_save(mrb_state*);
mzta 0:158c61bb030f 330 MRB_API void mrb_gc_arena_restore(mrb_state*,int);
mzta 0:158c61bb030f 331 MRB_API void mrb_gc_mark(mrb_state*,struct RBasic*);
mzta 0:158c61bb030f 332 #define mrb_gc_mark_value(mrb,val) do {\
mzta 0:158c61bb030f 333 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
mzta 0:158c61bb030f 334 } while (0)
mzta 0:158c61bb030f 335 MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
mzta 0:158c61bb030f 336 #define mrb_field_write_barrier_value(mrb, obj, val) do{\
mzta 0:158c61bb030f 337 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
mzta 0:158c61bb030f 338 } while (0)
mzta 0:158c61bb030f 339 MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
mzta 0:158c61bb030f 340
mzta 0:158c61bb030f 341 MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
mzta 0:158c61bb030f 342 MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 343 MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 344 MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 345 MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
mzta 0:158c61bb030f 346 MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
mzta 0:158c61bb030f 347 MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
mzta 0:158c61bb030f 348 MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
mzta 0:158c61bb030f 349 MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
mzta 0:158c61bb030f 350
mzta 0:158c61bb030f 351 /* need to include <ctype.h> to use these macros */
mzta 0:158c61bb030f 352 #ifndef ISPRINT
mzta 0:158c61bb030f 353 #define ISASCII(c) (!(((int)(unsigned char)(c)) & ~0x7f))
mzta 0:158c61bb030f 354 #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c)))
mzta 0:158c61bb030f 355 #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c)))
mzta 0:158c61bb030f 356 #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c)))
mzta 0:158c61bb030f 357 #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c)))
mzta 0:158c61bb030f 358 #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c)))
mzta 0:158c61bb030f 359 #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c)))
mzta 0:158c61bb030f 360 #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c)))
mzta 0:158c61bb030f 361 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
mzta 0:158c61bb030f 362 #define ISBLANK(c) (ISASCII(c) && isblank((int)(unsigned char)(c)))
mzta 0:158c61bb030f 363 #define ISCNTRL(c) (ISASCII(c) && iscntrl((int)(unsigned char)(c)))
mzta 0:158c61bb030f 364 #define TOUPPER(c) (ISASCII(c) ? toupper((int)(unsigned char)(c)) : (c))
mzta 0:158c61bb030f 365 #define TOLOWER(c) (ISASCII(c) ? tolower((int)(unsigned char)(c)) : (c))
mzta 0:158c61bb030f 366 #endif
mzta 0:158c61bb030f 367
mzta 0:158c61bb030f 368 MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
mzta 0:158c61bb030f 369 MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
mzta 0:158c61bb030f 370
mzta 0:158c61bb030f 371 MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
mzta 0:158c61bb030f 372 MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
mzta 0:158c61bb030f 373 MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
mzta 0:158c61bb030f 374 MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
mzta 0:158c61bb030f 375 MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...);
mzta 0:158c61bb030f 376 MRB_API void mrb_print_backtrace(mrb_state *mrb);
mzta 0:158c61bb030f 377 MRB_API void mrb_print_error(mrb_state *mrb);
mzta 0:158c61bb030f 378
mzta 0:158c61bb030f 379 /* macros to get typical exception objects
mzta 0:158c61bb030f 380 note:
mzta 0:158c61bb030f 381 + those E_* macros requires mrb_state* variable named mrb.
mzta 0:158c61bb030f 382 + exception objects obtained from those macros are local to mrb
mzta 0:158c61bb030f 383 */
mzta 0:158c61bb030f 384 #define E_RUNTIME_ERROR (mrb_class_get(mrb, "RuntimeError"))
mzta 0:158c61bb030f 385 #define E_TYPE_ERROR (mrb_class_get(mrb, "TypeError"))
mzta 0:158c61bb030f 386 #define E_ARGUMENT_ERROR (mrb_class_get(mrb, "ArgumentError"))
mzta 0:158c61bb030f 387 #define E_INDEX_ERROR (mrb_class_get(mrb, "IndexError"))
mzta 0:158c61bb030f 388 #define E_RANGE_ERROR (mrb_class_get(mrb, "RangeError"))
mzta 0:158c61bb030f 389 #define E_NAME_ERROR (mrb_class_get(mrb, "NameError"))
mzta 0:158c61bb030f 390 #define E_NOMETHOD_ERROR (mrb_class_get(mrb, "NoMethodError"))
mzta 0:158c61bb030f 391 #define E_SCRIPT_ERROR (mrb_class_get(mrb, "ScriptError"))
mzta 0:158c61bb030f 392 #define E_SYNTAX_ERROR (mrb_class_get(mrb, "SyntaxError"))
mzta 0:158c61bb030f 393 #define E_LOCALJUMP_ERROR (mrb_class_get(mrb, "LocalJumpError"))
mzta 0:158c61bb030f 394 #define E_REGEXP_ERROR (mrb_class_get(mrb, "RegexpError"))
mzta 0:158c61bb030f 395 #define E_SYSSTACK_ERROR (mrb_class_get(mrb, "SystemStackError"))
mzta 0:158c61bb030f 396
mzta 0:158c61bb030f 397 #define E_NOTIMP_ERROR (mrb_class_get(mrb, "NotImplementedError"))
mzta 0:158c61bb030f 398 #define E_FLOATDOMAIN_ERROR (mrb_class_get(mrb, "FloatDomainError"))
mzta 0:158c61bb030f 399
mzta 0:158c61bb030f 400 #define E_KEY_ERROR (mrb_class_get(mrb, "KeyError"))
mzta 0:158c61bb030f 401
mzta 0:158c61bb030f 402 MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
mzta 0:158c61bb030f 403 MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
mzta 0:158c61bb030f 404 MRB_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);
mzta 0:158c61bb030f 405
mzta 0:158c61bb030f 406 MRB_API void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
mzta 0:158c61bb030f 407 MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
mzta 0:158c61bb030f 408 #define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
mzta 0:158c61bb030f 409 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
mzta 0:158c61bb030f 410
mzta 0:158c61bb030f 411 typedef enum call_type {
mzta 0:158c61bb030f 412 CALL_PUBLIC,
mzta 0:158c61bb030f 413 CALL_FCALL,
mzta 0:158c61bb030f 414 CALL_VCALL,
mzta 0:158c61bb030f 415 CALL_TYPE_MAX
mzta 0:158c61bb030f 416 } call_type;
mzta 0:158c61bb030f 417
mzta 0:158c61bb030f 418 MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2);
mzta 0:158c61bb030f 419 MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
mzta 0:158c61bb030f 420 MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
mzta 0:158c61bb030f 421
mzta 0:158c61bb030f 422 MRB_API mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
mzta 0:158c61bb030f 423
mzta 0:158c61bb030f 424 MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
mzta 0:158c61bb030f 425 MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
mzta 0:158c61bb030f 426
mzta 0:158c61bb030f 427 /* fiber functions (you need to link mruby-fiber mrbgem to use) */
mzta 0:158c61bb030f 428 MRB_API mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
mzta 0:158c61bb030f 429 #define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
mzta 0:158c61bb030f 430
mzta 0:158c61bb030f 431 /* memory pool implementation */
mzta 0:158c61bb030f 432 typedef struct mrb_pool mrb_pool;
mzta 0:158c61bb030f 433 MRB_API struct mrb_pool* mrb_pool_open(mrb_state*);
mzta 0:158c61bb030f 434 MRB_API void mrb_pool_close(struct mrb_pool*);
mzta 0:158c61bb030f 435 MRB_API void* mrb_pool_alloc(struct mrb_pool*, size_t);
mzta 0:158c61bb030f 436 MRB_API void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
mzta 0:158c61bb030f 437 MRB_API mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
mzta 0:158c61bb030f 438 MRB_API void* mrb_alloca(mrb_state *mrb, size_t);
mzta 0:158c61bb030f 439
mzta 0:158c61bb030f 440 MRB_API void mrb_state_atexit(mrb_state *mrb, mrb_atexit_func func);
mzta 0:158c61bb030f 441
mzta 0:158c61bb030f 442 #ifdef MRB_DEBUG
mzta 0:158c61bb030f 443 #include <assert.h>
mzta 0:158c61bb030f 444 #define mrb_assert(p) assert(p)
mzta 0:158c61bb030f 445 #define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
mzta 0:158c61bb030f 446 #else
mzta 0:158c61bb030f 447 #define mrb_assert(p) ((void)0)
mzta 0:158c61bb030f 448 #define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
mzta 0:158c61bb030f 449 #endif
mzta 0:158c61bb030f 450
mzta 0:158c61bb030f 451 #if __STDC_VERSION__ >= 201112L
mzta 0:158c61bb030f 452 #define mrb_static_assert(exp, str) _Static_assert(exp, str)
mzta 0:158c61bb030f 453 #else
mzta 0:158c61bb030f 454 #define mrb_static_assert(exp, str) mrb_assert(exp)
mzta 0:158c61bb030f 455 #endif
mzta 0:158c61bb030f 456
mzta 0:158c61bb030f 457 MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
mzta 0:158c61bb030f 458
mzta 0:158c61bb030f 459 #if defined(__cplusplus)
mzta 0:158c61bb030f 460 } /* extern "C" { */
mzta 0:158c61bb030f 461 #endif
mzta 0:158c61bb030f 462
mzta 0:158c61bb030f 463 #endif /* MRUBY_H */
mzta 0:158c61bb030f 464