include/mruby.h

   1 /*
   2 ** mruby - An embeddable Ruby implementation
   3 **
   4 ** Copyright (c) mruby developers 2010-2013
   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: http://www.opensource.org/licenses/mit-license.php ]
  26 */
  27
  28 #ifndef MRUBY_H
  29 #define MRUBY_H
  30
  31 #if defined(__cplusplus)
  32 extern "C" {
  33 #endif
  34
  35 #include "mrbconf.h"
  36
  37 #include "mruby/value.h"
  38
  39 typedef uint32_t mrb_code;
  40 typedef uint32_t mrb_aspec;
  41
  42 struct mrb_state;
  43
  44 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
  45
  46 #ifndef MRB_ARENA_SIZE
  47 #define MRB_ARENA_SIZE 100
  48 #endif
  49
  50 typedef struct {
  51   mrb_sym mid;
  52   struct RProc *proc;
  53   int stackidx;
  54   int nregs;
  55   int argc;
  56   mrb_code *pc;
  57   int acc;
  58   struct RClass *target_class;
  59   int ridx;
  60   int eidx;
  61   struct REnv *env;
  62 } mrb_callinfo;
  63
  64 enum gc_state {
  65   GC_STATE_NONE = 0,
  66   GC_STATE_MARK,
  67   GC_STATE_SWEEP
  68 };
  69
  70 typedef struct mrb_state {
  71   void *jmp;
  72
  73   mrb_allocf allocf;
  74
  75   mrb_value *stack;
  76   mrb_value *stbase, *stend;
  77
  78   mrb_callinfo *ci;
  79   mrb_callinfo *cibase, *ciend;
  80
  81   mrb_code **rescue;
  82   int rsize;
  83   struct RProc **ensure;
  84   int esize;
  85
  86   struct RObject *exc;
  87   struct iv_tbl *globals;
  88
  89   struct mrb_irep **irep;
  90   size_t irep_len, irep_capa;
  91
  92   mrb_sym init_sym;
  93   struct RObject *top_self;
  94   struct RClass *object_class;
  95   struct RClass *class_class;
  96   struct RClass *module_class;
  97   struct RClass *proc_class;
  98   struct RClass *string_class;
  99   struct RClass *array_class;
 100   struct RClass *hash_class;
 101
 102   struct RClass *float_class;
 103   struct RClass *fixnum_class;
 104   struct RClass *true_class;
 105   struct RClass *false_class;
 106   struct RClass *nil_class;
 107   struct RClass *symbol_class;
 108   struct RClass *kernel_module;
 109
 110   struct heap_page *heaps;
 111   struct heap_page *sweeps;
 112   struct heap_page *free_heaps;
 113   size_t live; /* count of live objects */
 114   struct RBasic *arena[MRB_ARENA_SIZE];
 115   int arena_idx;
 116
 117   enum gc_state gc_state; /* state of gc */
 118   int current_white_part; /* make white object by white_part */
 119   struct RBasic *gray_list; /* list of gray objects */
 120   struct RBasic *variable_gray_list; /* list of objects to be traversed atomically */
 121   size_t gc_live_after_mark;
 122   size_t gc_threshold;
 123   int gc_interval_ratio;
 124   int gc_step_ratio;
 125   mrb_bool gc_disabled:1;
 126   mrb_bool gc_full:1;
 127   mrb_bool is_generational_gc_mode:1;
 128   mrb_bool out_of_memory:1;
 129   size_t majorgc_old_threshold;
 130   struct alloca_header *mems;
 131
 132   mrb_sym symidx;
 133   struct kh_n2s *name2sym;      /* symbol table */
 134
 135 #ifdef ENABLE_DEBUG
 136   void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
 137 #endif
 138
 139   struct RClass *eException_class;
 140   struct RClass *eStandardError_class;
 141
 142   void *ud; /* auxiliary data */
 143
 144 } mrb_state;
 145
 146 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
 147 struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*);
 148 struct RClass *mrb_define_module(mrb_state *, const char*);
 149 mrb_value mrb_singleton_class(mrb_state*, mrb_value);
 150 void mrb_include_module(mrb_state*, struct RClass*, struct RClass*);
 151
 152 void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
 153 void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, mrb_aspec);
 154 void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_func_t, mrb_aspec);
 155 void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
 156 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
 157 void mrb_undef_method(mrb_state*, struct RClass*, const char*);
 158 void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
 159 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 160 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 161 struct RClass * mrb_module_new(mrb_state *mrb);
 162 int mrb_class_defined(mrb_state *mrb, const char *name);
 163 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
 164
 165 mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
 166 mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
 167 int mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
 168 struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
 169 struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
 170
 171 /* required arguments */
 172 #define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
 173 /* optional arguments */
 174 #define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
 175 /* mandatory and optinal arguments */
 176 #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
 177
 178 /* rest argument */
 179 #define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
 180 /* required arguments after rest */
 181 #define MRB_ARGS_POST(n)    ((mrb_aspec)((n)&0x1f) << 7)
 182 /* keyword arguments (n of keys, kdict) */
 183 #define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
 184 /* block argument */
 185 #define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
 186
 187 /* accept any number of arguments */
 188 #define MRB_ARGS_ANY()      ARGS_REST()
 189 /* accept no arguments */
 190 #define MRB_ARGS_NONE()     ((mrb_aspec)0)
 191
 192 /* compatibility macros; will be removed */
 193 #define ARGS_REQ(n)         MRB_ARGS_REQ(n)
 194 #define ARGS_OPT(n)         MRB_ARGS_OPT(n)
 195 #define ARGS_REST()         MRB_ARGS_REST()
 196 #define ARGS_POST(n)        MRB_ARGS_POST()
 197 #define ARGS_KEY(n1,n2)     MRB_ARGS_KEY(n1,n2)
 198 #define ARGS_BLOCK()        MRB_ARGS_BLOCK()
 199 #define ARGS_ANY()          MRB_ARGS_ANY()
 200 #define ARGS_NONE()         MRB_ARGS_NONE()
 201
 202 int mrb_get_args(mrb_state *mrb, const char *format, ...);
 203
 204 mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
 205 mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
 206 mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
 207 mrb_sym mrb_intern_cstr(mrb_state*,const char*);
 208 mrb_sym mrb_intern2(mrb_state*,const char*,size_t);
 209 mrb_sym mrb_intern_str(mrb_state*,mrb_value);
 210 mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
 211 mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
 212 mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
 213 const char *mrb_sym2name(mrb_state*,mrb_sym);
 214 const char *mrb_sym2name_len(mrb_state*,mrb_sym,size_t*);
 215 mrb_value mrb_sym2str(mrb_state*,mrb_sym);
 216 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 217
 218 /* For backward compatibility. */
 219 static inline
 220 mrb_sym mrb_intern(mrb_state *mrb,const char *cstr)
 221 {
 222   return mrb_intern_cstr(mrb, cstr);
 223 }
 224
 225 void *mrb_malloc(mrb_state*, size_t);
 226 void *mrb_calloc(mrb_state*, size_t, size_t);
 227 void *mrb_realloc(mrb_state*, void*, size_t);
 228 struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
 229 void mrb_free(mrb_state*, void*);
 230
 231 mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
 232 mrb_value mrb_str_new_cstr(mrb_state*, const char*);
 233 mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
 234
 235 mrb_state* mrb_open(void);
 236 mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
 237 void mrb_irep_free(mrb_state*, struct mrb_irep*);
 238 void mrb_close(mrb_state*);
 239
 240 mrb_value mrb_top_self(mrb_state *);
 241 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
 242
 243 void mrb_p(mrb_state*, mrb_value);
 244 mrb_int mrb_obj_id(mrb_value obj);
 245 mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
 246
 247 int mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
 248 int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
 249 int mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 250 mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
 251 mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
 252 mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
 253 int mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 254
 255 void mrb_garbage_collect(mrb_state*);
 256 void mrb_incremental_gc(mrb_state *);
 257 int mrb_gc_arena_save(mrb_state*);
 258 void mrb_gc_arena_restore(mrb_state*,int);
 259 void mrb_gc_mark(mrb_state*,struct RBasic*);
 260 #define mrb_gc_mark_value(mrb,val) do {\
 261   if (mrb_type(val) >= MRB_TT_OBJECT) mrb_gc_mark((mrb), mrb_basic_ptr(val));\
 262 } while (0)
 263 void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
 264 #define mrb_field_write_barrier_value(mrb, obj, val) do{\
 265   if ((val.tt >= MRB_TT_OBJECT)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val));\
 266 } while (0)
 267 void mrb_write_barrier(mrb_state *, struct RBasic*);
 268
 269 mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method);
 270 mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
 271 const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
 272 struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
 273 mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
 274 mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method);
 275 int mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
 276 mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
 277 mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
 278
 279 /* need to include <ctype.h> to use these macros */
 280 #ifndef ISPRINT
 281 //#define ISASCII(c) isascii((int)(unsigned char)(c))
 282 #define ISASCII(c) 1
 283 #undef ISPRINT
 284 #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c)))
 285 #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c)))
 286 #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c)))
 287 #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c)))
 288 #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c)))
 289 #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c)))
 290 #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c)))
 291 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
 292 #define TOUPPER(c) (ISASCII(c) ? toupper((int)(unsigned char)(c)) : (c))
 293 #define TOLOWER(c) (ISASCII(c) ? tolower((int)(unsigned char)(c)) : (c))
 294 #endif
 295
 296 mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
 297 void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
 298
 299 void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
 300 void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 301 void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
 302 void mrb_warn(mrb_state *mrb, const char *fmt, ...);
 303 void mrb_bug(mrb_state *mrb, const char *fmt, ...);
 304 void mrb_print_backtrace(mrb_state *mrb);
 305
 306 /* macros to get typical exception objects
 307    note:
 308    + those E_* macros requires mrb_state* variable named mrb.
 309    + exception objects obtained from those macros are local to mrb
 310 */
 311 #define E_RUNTIME_ERROR             (mrb_class_get(mrb, "RuntimeError"))
 312 #define E_TYPE_ERROR                (mrb_class_get(mrb, "TypeError"))
 313 #define E_ARGUMENT_ERROR            (mrb_class_get(mrb, "ArgumentError"))
 314 #define E_INDEX_ERROR               (mrb_class_get(mrb, "IndexError"))
 315 #define E_RANGE_ERROR               (mrb_class_get(mrb, "RangeError"))
 316 #define E_NAME_ERROR                (mrb_class_get(mrb, "NameError"))
 317 #define E_NOMETHOD_ERROR            (mrb_class_get(mrb, "NoMethodError"))
 318 #define E_SCRIPT_ERROR              (mrb_class_get(mrb, "ScriptError"))
 319 #define E_SYNTAX_ERROR              (mrb_class_get(mrb, "SyntaxError"))
 320 #define E_LOCALJUMP_ERROR           (mrb_class_get(mrb, "LocalJumpError"))
 321 #define E_REGEXP_ERROR              (mrb_class_get(mrb, "RegexpError"))
 322
 323 #define E_NOTIMP_ERROR              (mrb_class_get(mrb, "NotImplementedError"))
 324 #define E_FLOATDOMAIN_ERROR         (mrb_class_get(mrb, "FloatDomainError"))
 325
 326 #define E_KEY_ERROR                 (mrb_class_get(mrb, "KeyError"))
 327
 328 mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
 329 mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
 330 mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
 331 mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
 332
 333 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 334 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 335 void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
 336
 337 typedef enum call_type {
 338     CALL_PUBLIC,
 339     CALL_FCALL,
 340     CALL_VCALL,
 341     CALL_TYPE_MAX
 342 } call_type;
 343
 344 void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2);
 345 const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
 346 void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 347
 348 mrb_value mrb_block_proc(void);
 349 mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
 350
 351 int mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
 352 int mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
 353
 354 /* memory pool implementation */
 355 typedef struct mrb_pool mrb_pool;
 356 struct mrb_pool* mrb_pool_open(mrb_state*);
 357 void mrb_pool_close(struct mrb_pool*);
 358 void* mrb_pool_alloc(struct mrb_pool*, size_t);
 359 void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
 360 int mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
 361 void* mrb_alloca(mrb_state *mrb, size_t);
 362
 363 #if defined(__cplusplus)
 364 }  /* extern "C" { */
 365 #endif
 366
 367 #endif  /* MRUBY_H */