summaryrefslogtreecommitdiffhomepage
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/mrbconf.h11
-rw-r--r--include/mruby.h98
-rw-r--r--include/mruby/array.h19
-rw-r--r--include/mruby/class.h14
-rw-r--r--include/mruby/compile.h58
-rw-r--r--include/mruby/data.h15
-rw-r--r--include/mruby/debug.h65
-rw-r--r--[-rwxr-xr-x]include/mruby/dump.h61
-rw-r--r--include/mruby/error.h28
-rw-r--r--include/mruby/gc.h13
-rw-r--r--include/mruby/hash.h6
-rw-r--r--include/mruby/irep.h17
-rw-r--r--include/mruby/khash.h141
-rw-r--r--include/mruby/numeric.h2
-rw-r--r--include/mruby/proc.h15
-rw-r--r--include/mruby/range.h4
-rw-r--r--include/mruby/string.h59
-rw-r--r--include/mruby/value.h116
-rw-r--r--include/mruby/variable.h19
-rw-r--r--include/mruby/version.h34
20 files changed, 535 insertions, 260 deletions
diff --git a/include/mrbconf.h b/include/mrbconf.h
index 57148d428..bcef1b1bd 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -38,8 +38,8 @@
/* initial size for IV khash; ignored when MRB_USE_IV_SEGLIST is set */
//#define MRB_IVHASH_INIT_SIZE 8
-/* initial size for IREP array */
-//#define MRB_IREP_ARRAY_INIT_SIZE (256u)
+/* turn off generational GC by default */
+//#define MRB_GC_TURN_OFF_GENERATIONAL
/* default size of khash table bucket */
//#define KHASH_DEFAULT_SIZE 32
@@ -53,8 +53,11 @@
/* initial minimum size for string buffer */
//#define MRB_STR_BUF_MIN_SIZE 128
-/* array size for parser buffer */
-//#define MRB_PARSER_BUF_SIZE 1024
+/* arena size */
+//#define MRB_GC_ARENA_SIZE 100
+
+/* fixed size GC arena */
+//#define MRB_GC_FIXED_ARENA
/* -DDISABLE_XXXX to drop following features */
//#define DISABLE_STDIO /* use of stdio */
diff --git a/include/mruby.h b/include/mruby.h
index dcd2aa5fc..0ab2d8037 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -1,7 +1,7 @@
/*
** mruby - An embeddable Ruby implementation
**
-** Copyright (c) mruby developers 2010-2013
+** Copyright (c) mruby developers 2010-2014
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
@@ -34,28 +34,32 @@ extern "C" {
#include <stdint.h>
#include <stddef.h>
+#include <limits.h>
#include "mrbconf.h"
#include "mruby/value.h"
+#include "mruby/version.h"
typedef uint32_t mrb_code;
typedef uint32_t mrb_aspec;
+struct mrb_irep;
struct mrb_state;
typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
-#ifndef MRB_ARENA_SIZE
-#define MRB_ARENA_SIZE 100
+#ifndef MRB_GC_ARENA_SIZE
+#define MRB_GC_ARENA_SIZE 100
#endif
typedef struct {
mrb_sym mid;
struct RProc *proc;
- int stackidx;
+ mrb_value *stackent;
int nregs;
int argc;
- mrb_code *pc;
+ mrb_code *pc; /* return address */
+ mrb_code *err; /* error position */
int acc;
struct RClass *target_class;
int ridx;
@@ -66,7 +70,9 @@ typedef struct {
enum mrb_fiber_state {
MRB_FIBER_CREATED = 0,
MRB_FIBER_RUNNING,
- MRB_FIBER_RESUMED,
+ MRB_FIBER_RESUMING,
+ MRB_FIBER_SUSPENDED,
+ MRB_FIBER_TRANSFERRED,
MRB_FIBER_TERMINATED,
};
@@ -84,7 +90,7 @@ struct mrb_context {
struct RProc **ensure; /* ensure handler stack */
int esize;
- uint8_t status;
+ enum mrb_fiber_state status;
struct RFiber *fib;
};
@@ -94,8 +100,10 @@ enum gc_state {
GC_STATE_SWEEP
};
+struct mrb_jmpbuf;
+
typedef struct mrb_state {
- void *jmp;
+ struct mrb_jmpbuf *jmp;
mrb_allocf allocf; /* memory allocation function */
@@ -104,10 +112,7 @@ typedef struct mrb_state {
struct RObject *exc; /* exception */
struct iv_tbl *globals; /* global variable table */
- struct mrb_irep **irep; /* program data array */
- size_t irep_len, irep_capa;
- mrb_sym init_sym;
struct RObject *top_self;
struct RClass *object_class; /* Object class */
struct RClass *class_class;
@@ -129,7 +134,12 @@ typedef struct mrb_state {
struct heap_page *sweeps;
struct heap_page *free_heaps;
size_t live; /* count of live objects */
- struct RBasic *arena[MRB_ARENA_SIZE]; /* GC protection array */
+#ifdef MRB_GC_FIXED_ARENA
+ struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
+#else
+ struct RBasic **arena; /* GC protection array */
+ int arena_capa;
+#endif
int arena_idx;
enum gc_state gc_state; /* state of gc */
@@ -152,6 +162,7 @@ typedef struct mrb_state {
#ifdef ENABLE_DEBUG
void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
+ void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
#endif
struct RClass *eException_class;
@@ -173,16 +184,20 @@ void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_fun
void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
void mrb_undef_method(mrb_state*, struct RClass*, const char*);
void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
+mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, const mrb_value *argv);
+#define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv)
mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
struct RClass * mrb_module_new(mrb_state *mrb);
mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
+struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
-mrb_bool mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
+mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid);
struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
@@ -203,7 +218,7 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
#define MRB_ARGS_BLOCK() ((mrb_aspec)1)
/* accept any number of arguments */
-#define MRB_ARGS_ANY() ARGS_REST()
+#define MRB_ARGS_ANY() MRB_ARGS_REST()
/* accept no arguments */
#define MRB_ARGS_NONE() ((mrb_aspec)0)
@@ -219,26 +234,28 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
int mrb_get_args(mrb_state *mrb, const char *format, ...);
+/* `strlen` for character string literals (use with caution or `strlen` instead)
+ Adjacent string literals are concatenated in C/C++ in translation phase 6.
+ If `lit` is not one, the compiler will report a syntax error:
+ MSVC: "error C2143: syntax error : missing ')' before 'string'"
+ GCC: "error: expected ')' before string constant"
+*/
+#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
+
mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*, mrb_value);
mrb_sym mrb_intern_cstr(mrb_state*,const char*);
-mrb_sym mrb_intern2(mrb_state*,const char*,size_t);
+mrb_sym mrb_intern(mrb_state*,const char*,size_t);
+mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
mrb_sym mrb_intern_str(mrb_state*,mrb_value);
mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
const char *mrb_sym2name(mrb_state*,mrb_sym);
-const char *mrb_sym2name_len(mrb_state*,mrb_sym,size_t*);
+const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*);
mrb_value mrb_sym2str(mrb_state*,mrb_sym);
-mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
-
-/* For backward compatibility. */
-static inline
-mrb_sym mrb_intern(mrb_state *mrb,const char *cstr)
-{
- return mrb_intern_cstr(mrb, cstr);
-}
void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */
void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
@@ -251,14 +268,16 @@ void mrb_free(mrb_state*, void*);
mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
mrb_value mrb_str_new_cstr(mrb_state*, const char*);
mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
+#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
mrb_state* mrb_open(void);
mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
-void mrb_irep_free(mrb_state*, struct mrb_irep*);
void mrb_close(mrb_state*);
mrb_value mrb_top_self(mrb_state *);
mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
+mrb_value mrb_toplevel_run(mrb_state*, struct RProc*);
+mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
void mrb_p(mrb_state*, mrb_value);
mrb_int mrb_obj_id(mrb_value obj);
@@ -279,11 +298,11 @@ int mrb_gc_arena_save(mrb_state*);
void mrb_gc_arena_restore(mrb_state*,int);
void mrb_gc_mark(mrb_state*,struct RBasic*);
#define mrb_gc_mark_value(mrb,val) do {\
- if (mrb_type(val) >= MRB_TT_HAS_BASIC) mrb_gc_mark((mrb), mrb_basic_ptr(val));\
+ if (MRB_TT_HAS_BASIC_P(mrb_type(val))) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
} while (0)
void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
#define mrb_field_write_barrier_value(mrb, obj, val) do{\
- if ((val.tt >= MRB_TT_HAS_BASIC)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val));\
+ if (MRB_TT_HAS_BASIC_P(val.tt)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
} while (0)
void mrb_write_barrier(mrb_state *, struct RBasic*);
@@ -299,9 +318,8 @@ mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
/* need to include <ctype.h> to use these macros */
#ifndef ISPRINT
-//#define ISASCII(c) isascii((int)(unsigned char)(c))
+/* #define ISASCII(c) isascii((int)(unsigned char)(c)) */
#define ISASCII(c) 1
-#undef ISPRINT
#define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c)))
#define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c)))
#define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c)))
@@ -348,31 +366,33 @@ void mrb_print_error(mrb_state *mrb);
#define E_KEY_ERROR (mrb_class_get(mrb, "KeyError"))
mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
-mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
-mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
-mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
+mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv);
+mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
typedef enum call_type {
- CALL_PUBLIC,
- CALL_FCALL,
- CALL_VCALL,
- CALL_TYPE_MAX
+ CALL_PUBLIC,
+ CALL_FCALL,
+ CALL_VCALL,
+ CALL_TYPE_MAX
} call_type;
void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2);
const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
-mrb_value mrb_block_proc(void);
mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
+/* fiber functions (you need to link mruby-fiber mrbgem to use) */
+mrb_value mrb_fiber_yield(mrb_state *mrb, int argc, const mrb_value *argv);
+#define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
+
/* memory pool implementation */
typedef struct mrb_pool mrb_pool;
struct mrb_pool* mrb_pool_open(mrb_state*);
diff --git a/include/mruby/array.h b/include/mruby/array.h
index d52ca1596..5fbf71174 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -13,8 +13,8 @@ extern "C" {
typedef struct mrb_shared_array {
int refcnt;
- mrb_value *ptr;
mrb_int len;
+ mrb_value *ptr;
} mrb_shared_array;
struct RArray {
@@ -27,35 +27,42 @@ struct RArray {
mrb_value *ptr;
};
-#define mrb_ary_ptr(v) ((struct RArray*)((v).value.p))
+#define mrb_ary_ptr(v) ((struct RArray*)(mrb_ptr(v)))
#define mrb_ary_value(p) mrb_obj_value((void*)(p))
-#define RARRAY(v) ((struct RArray*)((v).value.p))
+#define RARRAY(v) ((struct RArray*)(mrb_ptr(v)))
#define RARRAY_LEN(a) (RARRAY(a)->len)
#define RARRAY_PTR(a) (RARRAY(a)->ptr)
#define MRB_ARY_SHARED 256
+void mrb_ary_modify(mrb_state*, struct RArray*);
void mrb_ary_decref(mrb_state*, mrb_shared_array*);
mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
mrb_value mrb_ary_new(mrb_state *mrb);
mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals);
+mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
void mrb_ary_concat(mrb_state*, mrb_value, mrb_value);
mrb_value mrb_ary_splat(mrb_state*, mrb_value);
void mrb_ary_push(mrb_state*, mrb_value, mrb_value);
mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
-mrb_int mrb_ary_len(mrb_state *mrb, mrb_value ary);
void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b);
mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
-mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self);
mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
+static inline mrb_int
+mrb_ary_len(mrb_state *mrb, mrb_value ary)
+{
+ (void)mrb;
+ mrb_assert(mrb_array_p(ary));
+ return RARRAY_LEN(ary);
+}
+
#if defined(__cplusplus)
} /* extern "C" { */
#endif
diff --git a/include/mruby/class.h b/include/mruby/class.h
index 4ab954d9e..3c4915dc4 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -18,10 +18,10 @@ struct RClass {
struct RClass *super;
};
-#define mrb_class_ptr(v) ((struct RClass*)((v).value.p))
-#define RCLASS_SUPER(v) (((struct RClass*)((v).value.p))->super)
-#define RCLASS_IV_TBL(v) (((struct RClass*)((v).value.p))->iv)
-#define RCLASS_M_TBL(v) (((struct RClass*)((v).value.p))->mt)
+#define mrb_class_ptr(v) ((struct RClass*)(mrb_ptr(v)))
+#define RCLASS_SUPER(v) (((struct RClass*)(mrb_ptr(v)))->super)
+#define RCLASS_IV_TBL(v) (((struct RClass*)(mrb_ptr(v)))->iv)
+#define RCLASS_M_TBL(v) (((struct RClass*)(mrb_ptr(v)))->mt)
static inline struct RClass*
mrb_class(mrb_state *mrb, mrb_value v)
@@ -39,6 +39,10 @@ mrb_class(mrb_state *mrb, mrb_value v)
return mrb->fixnum_class;
case MRB_TT_FLOAT:
return mrb->float_class;
+ case MRB_TT_CPTR:
+ return mrb->object_class;
+ case MRB_TT_ENV:
+ return NULL;
default:
return mrb_obj_ptr(v)->c;
}
@@ -62,8 +66,6 @@ struct RProc *mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
struct RClass* mrb_class_real(struct RClass* cl);
-void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv);
-
void mrb_gc_mark_mt(mrb_state*, struct RClass*);
size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
void mrb_gc_free_mt(mrb_state*, struct RClass*);
diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index 7c5884e58..9af9c39c6 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -5,14 +5,15 @@
*/
#ifndef MRUBY_COMPILE_H
-#define MRUBY_COMPILE_H 1
+#define MRUBY_COMPILE_H
#if defined(__cplusplus)
extern "C" {
#endif
#include "mruby.h"
-#include <setjmp.h>
+
+struct mrb_jmpbuf;
struct mrb_parser_state;
/* load context */
@@ -37,23 +38,23 @@ void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(stru
/* AST node structure */
typedef struct mrb_ast_node {
struct mrb_ast_node *car, *cdr;
- short lineno;
+ uint16_t lineno, filename_index;
} mrb_ast_node;
/* lexer states */
enum mrb_lex_state_enum {
- EXPR_BEG, /* ignore newline, +/- is a sign. */
- EXPR_END, /* newline significant, +/- is an operator. */
- EXPR_ENDARG, /* ditto, and unbound braces. */
- EXPR_ENDFN, /* ditto, and unbound braces. */
- EXPR_ARG, /* newline significant, +/- is an operator. */
- EXPR_CMDARG, /* newline significant, +/- is an operator. */
- EXPR_MID, /* newline significant, +/- is an operator. */
- EXPR_FNAME, /* ignore newline, no reserved words. */
- EXPR_DOT, /* right after `.' or `::', no reserved words. */
- EXPR_CLASS, /* immediate after `class', no here document. */
- EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */
- EXPR_MAX_STATE
+ EXPR_BEG, /* ignore newline, +/- is a sign. */
+ EXPR_END, /* newline significant, +/- is an operator. */
+ EXPR_ENDARG, /* ditto, and unbound braces. */
+ EXPR_ENDFN, /* ditto, and unbound braces. */
+ EXPR_ARG, /* newline significant, +/- is an operator. */
+ EXPR_CMDARG, /* newline significant, +/- is an operator. */
+ EXPR_MID, /* newline significant, +/- is an operator. */
+ EXPR_FNAME, /* ignore newline, no reserved words. */
+ EXPR_DOT, /* right after `.' or `::', no reserved words. */
+ EXPR_CLASS, /* immediate after `class', no here document. */
+ EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */
+ EXPR_MAX_STATE
};
/* saved error message */
@@ -96,9 +97,7 @@ struct mrb_parser_heredoc_info {
mrb_ast_node *doc;
};
-#ifndef MRB_PARSER_BUF_SIZE
-# define MRB_PARSER_BUF_SIZE 1024
-#endif
+#define MRB_PARSER_BUF_SIZE 1024
/* parser structure */
struct mrb_parser_state {
@@ -110,7 +109,7 @@ struct mrb_parser_state {
FILE *f;
#endif
mrbc_context *cxt;
- char *filename;
+ char const *filename;
int lineno;
int column;
@@ -121,16 +120,18 @@ struct mrb_parser_state {
unsigned int cmdarg_stack;
int paren_nest;
int lpar_beg;
- int in_def, in_single, cmd_start;
+ int in_def, in_single;
+ mrb_bool cmd_start:1;
mrb_ast_node *locals;
mrb_ast_node *pb;
char buf[MRB_PARSER_BUF_SIZE];
int bidx;
- mrb_ast_node *heredocs; /* list of mrb_parser_heredoc_info* */
+ mrb_ast_node *all_heredocs; /* list of mrb_parser_heredoc_info* */
+ mrb_ast_node *heredocs_from_nextline;
mrb_ast_node *parsing_heredoc;
- mrb_bool heredoc_starts_nextline:1;
+ mrb_ast_node *lex_strterm_before_heredoc;
mrb_bool heredoc_end_now:1; /* for mirb */
void *ylval;
@@ -139,24 +140,31 @@ struct mrb_parser_state {
size_t nwarn;
mrb_ast_node *tree;
- int capture_errors;
+ mrb_bool capture_errors:1;
struct mrb_parser_message error_buffer[10];
struct mrb_parser_message warn_buffer[10];
- jmp_buf jmp;
+ mrb_sym* filename_table;
+ size_t filename_table_length;
+ int current_filename_index;
+
+ struct mrb_jmpbuf* jmp;
};
struct mrb_parser_state* mrb_parser_new(mrb_state*);
void mrb_parser_free(struct mrb_parser_state*);
void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
+void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
+char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
+
/* utility functions */
#ifdef ENABLE_STDIO
struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
#endif
struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*);
-int mrb_generate_code(mrb_state*, struct mrb_parser_state*);
+struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
/* program load functions */
#ifdef ENABLE_STDIO
diff --git a/include/mruby/data.h b/include/mruby/data.h
index c6b380f28..8b1b5edb7 100644
--- a/include/mruby/data.h
+++ b/include/mruby/data.h
@@ -5,7 +5,7 @@
*/
#ifndef MRUBY_DATA_H
-#define MRUBY_DATA_H 1
+#define MRUBY_DATA_H
#if defined(__cplusplus)
extern "C" {
@@ -34,16 +34,21 @@ struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *
data = Data_Wrap_Struct(mrb,klass,type,sval);\
} while (0)
-#define RDATA(obj) ((struct RData *)((obj).value.p))
+#define RDATA(obj) ((struct RData *)(mrb_ptr(obj)))
#define DATA_PTR(d) (RDATA(d)->data)
#define DATA_TYPE(d) (RDATA(d)->type)
void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*);
void *mrb_data_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
-void *mrb_data_check_and_get(mrb_state *mrb, mrb_value, const mrb_data_type*);
+#define DATA_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_get_ptr(mrb,obj,dtype)
+void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
+#define DATA_CHECK_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_check_get_ptr(mrb,obj,dtype)
+
+/* obsolete functions and macros */
+#define mrb_data_check_and_get(mrb,obj,dtype) mrb_data_get_ptr(mrb,obj,dtype)
#define mrb_get_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
-#define mrb_check_datatype(mrb,val,type) mrb_data_check_and_get(mrb, val, type)
+#define mrb_check_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
#define Data_Get_Struct(mrb,obj,type,sval) do {\
- *(void**)&sval = mrb_data_check_and_get(mrb, obj, type); \
+ *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
} while (0)
#if defined(__cplusplus)
diff --git a/include/mruby/debug.h b/include/mruby/debug.h
new file mode 100644
index 000000000..a56321d42
--- /dev/null
+++ b/include/mruby/debug.h
@@ -0,0 +1,65 @@
+/*
+** mruby/debug.h - mruby debug info
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_DEBUG_H
+#define MRUBY_DEBUG_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+typedef enum mrb_debug_line_type {
+ mrb_debug_line_ary = 0,
+ mrb_debug_line_flat_map = 1
+} mrb_debug_line_type;
+
+typedef struct mrb_irep_debug_info_line {
+ uint32_t start_pos;
+ uint16_t line;
+} mrb_irep_debug_info_line;
+
+typedef struct mrb_irep_debug_info_file {
+ uint32_t start_pos;
+ const char *filename;
+ mrb_sym filename_sym;
+ uint32_t line_entry_count;
+ mrb_debug_line_type line_type;
+ union {
+ void *ptr;
+ mrb_irep_debug_info_line *flat_map;
+ uint16_t *ary;
+ } lines;
+} mrb_irep_debug_info_file;
+
+typedef struct mrb_irep_debug_info {
+ uint32_t pc_count;
+ uint16_t flen;
+ mrb_irep_debug_info_file **files;
+} mrb_irep_debug_info;
+
+/*
+ * get line from irep's debug info and program counter
+ * @return returns NULL if not found
+ */
+const char *mrb_debug_get_filename(mrb_irep *irep, uint32_t pc);
+
+/*
+ * get line from irep's debug info and program counter
+ * @return returns -1 if not found
+ */
+int32_t mrb_debug_get_line(mrb_irep *irep, uint32_t pc);
+
+mrb_irep_debug_info_file *mrb_debug_info_append_file(
+ mrb_state *mrb, mrb_irep *irep,
+ uint32_t start_pos, uint32_t end_pos);
+mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
+void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d);
+
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+
+#endif /* MRUBY_DEBUG_H */
diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index 55227c8cf..35546f9de 100755..100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -12,38 +12,37 @@ extern "C" {
#endif
#include "mruby.h"
+#include "mruby/irep.h"
#ifdef ENABLE_STDIO
-int mrb_dump_irep_binary(mrb_state*, size_t, int, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, size_t n, int, FILE *f, const char *initname);
-int32_t mrb_read_irep_file(mrb_state*, FILE*);
-#endif
-int32_t mrb_read_irep(mrb_state*, const uint8_t*);
-
-#ifdef ENABLE_STDIO
+int mrb_dump_irep_binary(mrb_state*, mrb_irep*, int, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, int, FILE *f, const char *initname);
+mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
mrb_value mrb_load_irep_file(mrb_state*,FILE*);
+mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
#endif
+mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
/* dump/load error code
*
* NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
* unspecified issues like malloc failed.
*/
-#define MRB_DUMP_OK 0
-#define MRB_DUMP_GENERAL_FAILURE -1
-#define MRB_DUMP_WRITE_FAULT -2
-#define MRB_DUMP_READ_FAULT -3
-#define MRB_DUMP_CRC_ERROR -4
-#define MRB_DUMP_INVALID_FILE_HEADER -5
-#define MRB_DUMP_INVALID_IREP -6
-#define MRB_DUMP_INVALID_ARGUMENT -7
+#define MRB_DUMP_OK 0
+#define MRB_DUMP_GENERAL_FAILURE (-1)
+#define MRB_DUMP_WRITE_FAULT (-2)
+#define MRB_DUMP_READ_FAULT (-3)
+#define MRB_DUMP_CRC_ERROR (-4)
+#define MRB_DUMP_INVALID_FILE_HEADER (-5)
+#define MRB_DUMP_INVALID_IREP (-6)
+#define MRB_DUMP_INVALID_ARGUMENT (-7)
/* null symbol length */
#define MRB_DUMP_NULL_SYM_LEN 0xFFFF
/* Rite Binary File header */
#define RITE_BINARY_IDENTIFIER "RITE"
-#define RITE_BINARY_FORMAT_VER "0001"
+#define RITE_BINARY_FORMAT_VER "0002"
#define RITE_COMPILER_NAME "MATZ"
#define RITE_COMPILER_VERSION "0000"
@@ -52,20 +51,21 @@ mrb_value mrb_load_irep_file(mrb_state*,FILE*);
#define RITE_BINARY_EOF "END\0"
#define RITE_SECTION_IREP_IDENTIFIER "IREP"
#define RITE_SECTION_LINENO_IDENTIFIER "LINE"
+#define RITE_SECTION_DEBUG_IDENTIFIER "DBG\0"
#define MRB_DUMP_DEFAULT_STR_LEN 128
-// binary header
+/* binary header */
struct rite_binary_header {
- uint8_t binary_identify[4]; // Binary Identifier
- uint8_t binary_version[4]; // Binary Format Version
- uint8_t binary_crc[2]; // Binary CRC
- uint8_t binary_size[4]; // Binary Size
- uint8_t compiler_name[4]; // Compiler name
+ uint8_t binary_identify[4]; /* Binary Identifier */
+ uint8_t binary_version[4]; /* Binary Format Version */
+ uint8_t binary_crc[2]; /* Binary CRC */
+ uint8_t binary_size[4]; /* Binary Size */
+ uint8_t compiler_name[4]; /* Compiler name */
uint8_t compiler_version[4];
};
-// section header
+/* section header */
#define RITE_SECTION_HEADER \
uint8_t section_identify[4]; \
uint8_t section_size[4]
@@ -77,30 +77,29 @@ struct rite_section_header {
struct rite_section_irep_header {
RITE_SECTION_HEADER;
- uint8_t rite_version[4]; // Rite Instruction Specification Version
- uint8_t nirep[2]; // Number of ireps
- uint8_t sirep[2]; // Start index
+ uint8_t rite_version[4]; /* Rite Instruction Specification Version */
};
struct rite_section_lineno_header {
RITE_SECTION_HEADER;
+};
- uint8_t nirep[2]; // Number of ireps
- uint8_t sirep[2]; // Start index
+struct rite_section_debug_header {
+ RITE_SECTION_HEADER;
};
struct rite_binary_footer {
RITE_SECTION_HEADER;
};
-static inline int
+static inline size_t
uint8_to_bin(uint8_t s, uint8_t *bin)
{
*bin = s;
return sizeof(uint8_t);
}
-static inline int
+static inline size_t
uint16_to_bin(uint16_t s, uint8_t *bin)
{
*bin++ = (s >> 8) & 0xff;
@@ -108,7 +107,7 @@ uint16_to_bin(uint16_t s, uint8_t *bin)
return sizeof(uint16_t);
}
-static inline int
+static inline size_t
uint32_to_bin(uint32_t l, uint8_t *bin)
{
*bin++ = (l >> 24) & 0xff;
diff --git a/include/mruby/error.h b/include/mruby/error.h
new file mode 100644
index 000000000..689cf4b8f
--- /dev/null
+++ b/include/mruby/error.h
@@ -0,0 +1,28 @@
+/*
+** error.h - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ERROR_H
+#define MRUBY_ERROR_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+void mrb_sys_fail(mrb_state *mrb, const char *mesg);
+mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+mrb_value mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv);
+mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
+void mrb_exc_print(mrb_state *mrb, struct RObject *exc);
+void mrb_print_backtrace(mrb_state *mrb);
+mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
+mrb_value mrb_get_backtrace(mrb_state *mrb);
+
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+
+#endif /* MRUBY_ERROR_H */
diff --git a/include/mruby/gc.h b/include/mruby/gc.h
index 7afa24b48..02714be8e 100644
--- a/include/mruby/gc.h
+++ b/include/mruby/gc.h
@@ -7,11 +7,16 @@
#ifndef MRUBY_GC_H
#define MRUBY_GC_H
-#include "mruby.h"
-#include "mruby/value.h"
+#if defined(__cplusplus)
+extern "C" {
+#endif
-typedef void (each_object_callback)(mrb_state *mrb, struct RBasic* obj, void *data);
-void mrb_objspace_each_objects(mrb_state *mrb, each_object_callback* callback, void *data);
+typedef void (mrb_each_object_callback)(mrb_state *mrb, struct RBasic *obj, void *data);
+void mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, void *data);
void mrb_free_context(mrb_state *mrb, struct mrb_context *c);
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+
#endif /* MRUBY_GC_H */
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index c331db157..6a8b11373 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -17,7 +17,7 @@ struct RHash {
struct kh_ht *ht;
};
-#define mrb_hash_ptr(v) ((struct RHash*)((v).value.p))
+#define mrb_hash_ptr(v) ((struct RHash*)(mrb_ptr(v)))
#define mrb_hash_value(p) mrb_obj_value((void*)(p))
mrb_value mrb_hash_new_capa(mrb_state*, int);
@@ -33,9 +33,9 @@ mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
/* RHASH_TBL allocates st_table if not available. */
-#define RHASH(obj) ((struct RHash*)((obj).value.p))
+#define RHASH(obj) ((struct RHash*)(mrb_ptr(obj)))
#define RHASH_TBL(h) (RHASH(h)->ht)
-#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern2(mrb, "ifnone", 6))
+#define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
#define RHASH_PROCDEFAULT(h) RHASH_IFNONE(h)
struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 498b58ca3..480cb052f 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -11,9 +11,16 @@
extern "C" {
#endif
+#include "mruby/compile.h"
+
+enum irep_pool_type {
+ IREP_TT_STRING,
+ IREP_TT_FIXNUM,
+ IREP_TT_FLOAT,
+};
+
/* Program data array struct */
typedef struct mrb_irep {
- uint32_t idx;
uint16_t nlocals; /* Number of local variables */
uint16_t nregs; /* Number of register variables */
uint8_t flags;
@@ -21,18 +28,24 @@ typedef struct mrb_irep {
mrb_code *iseq;
mrb_value *pool;
mrb_sym *syms;
+ struct mrb_irep **reps;
/* debug info */
const char *filename;
uint16_t *lines;
+ struct mrb_irep_debug_info* debug_info;
- size_t ilen, plen, slen;
+ size_t ilen, plen, slen, rlen, refcnt;
} mrb_irep;
#define MRB_ISEQ_NO_FREE 1
mrb_irep *mrb_add_irep(mrb_state *mrb);
mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
+mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
+void mrb_irep_free(mrb_state*, struct mrb_irep*);
+void mrb_irep_incref(mrb_state*, struct mrb_irep*);
+void mrb_irep_decref(mrb_state*, struct mrb_irep*);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index fb11586d2..bd33b7a6d 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -24,12 +24,12 @@ typedef khint_t khiter_t;
#define UPPER_BOUND(x) ((x)>>2|(x)>>1)
-//extern uint8_t __m[];
+/* extern uint8_t __m[]; */
/* mask for flags */
-static const uint8_t __m_empty[8] = {0x02, 0x08, 0x20, 0x80};
-static const uint8_t __m_del[8] = {0x01, 0x04, 0x10, 0x40};
-static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
+static const uint8_t __m_empty[] = {0x02, 0x08, 0x20, 0x80};
+static const uint8_t __m_del[] = {0x01, 0x04, 0x10, 0x40};
+static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
#define __ac_isempty(ed_flag, i) (ed_flag[(i)/4]&__m_empty[(i)%4])
@@ -44,36 +44,34 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
v |= v >> 16;\
v++;\
} while (0)
+#define khash_mask(h) ((h)->n_buckets-1)
+#define khash_upper_bound(h) (UPPER_BOUND((h)->n_buckets))
/* declare struct kh_xxx and kh_xxx_funcs
name: hash name
khkey_t: key data type
khval_t: value data type
- kh_is_map: (not implemented / not used in RiteVM)
+ kh_is_map: (0: hash set / 1: hash map)
*/
#define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map) \
typedef struct kh_##name { \
khint_t n_buckets; \
khint_t size; \
khint_t n_occupied; \
- khint_t upper_bound; \
uint8_t *ed_flags; \
khkey_t *keys; \
khval_t *vals; \
- khint_t mask; \
- khint_t inc; \
- mrb_state *mrb; \
} kh_##name##_t; \
- void kh_alloc_##name(kh_##name##_t *h); \
+ void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h); \
kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size); \
kh_##name##_t *kh_init_##name(mrb_state *mrb); \
- void kh_destroy_##name(kh_##name##_t *h); \
- void kh_clear_##name(kh_##name##_t *h); \
- khint_t kh_get_##name(kh_##name##_t *h, khkey_t key); \
- khint_t kh_put_##name(kh_##name##_t *h, khkey_t key); \
- void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
- void kh_del_##name(kh_##name##_t *h, khint_t x); \
+ void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h); \
+ void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h); \
+ khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key); \
+ khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret); \
+ void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \
+ void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x); \
kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
static inline void
@@ -89,23 +87,21 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
name: hash name
khkey_t: key data type
khval_t: value data type
- kh_is_map: (not implemented / not used in RiteVM)
+ kh_is_map: (0: hash set / 1: hash map)
__hash_func: hash function
__hash_equal: hash comparation function
*/
#define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
- void kh_alloc_##name(kh_##name##_t *h) \
+ void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h) \
{ \
khint_t sz = h->n_buckets; \
- uint8_t *p = mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4+(sizeof(khkey_t)+sizeof(khval_t))*sz); \
+ size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0); \
+ uint8_t *p = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz); \
h->size = h->n_occupied = 0; \
- h->upper_bound = UPPER_BOUND(sz); \
h->keys = (khkey_t *)p; \
- h->vals = (khval_t *)(p+sizeof(khkey_t)*sz); \
- h->ed_flags = (p+sizeof(khkey_t)*sz+sizeof(khval_t)*sz); \
+ h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL; \
+ h->ed_flags = p+len*sz; \
kh_fill_flags(h->ed_flags, 0xaa, sz/4); \
- h->mask = sz-1; \
- h->inc = sz/2-1; \
} \
kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) { \
kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
@@ -113,39 +109,40 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
size = KHASH_MIN_SIZE; \
khash_power2(size); \
h->n_buckets = size; \
- h->mrb = mrb; \
- kh_alloc_##name(h); \
+ kh_alloc_##name(mrb, h); \
return h; \
} \
kh_##name##_t *kh_init_##name(mrb_state *mrb){ \
return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE); \
} \
- void kh_destroy_##name(kh_##name##_t *h) \
+ void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h) \
{ \
if (h) { \
- mrb_free(h->mrb, h->keys); \
- mrb_free(h->mrb, h); \
+ mrb_free(mrb, h->keys); \
+ mrb_free(mrb, h); \
} \
} \
- void kh_clear_##name(kh_##name##_t *h) \
+ void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h) \
{ \
+ (void)mrb; \
if (h && h->ed_flags) { \
kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4); \
h->size = h->n_occupied = 0; \
} \
} \
- khint_t kh_get_##name(kh_##name##_t *h, khkey_t key) \
+ khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key) \
{ \
- khint_t k = __hash_func(h->mrb,key) & (h->mask); \
+ khint_t k = __hash_func(mrb,key) & khash_mask(h), step = 0; \
+ (void)mrb; \
while (!__ac_isempty(h->ed_flags, k)) { \
if (!__ac_isdel(h->ed_flags, k)) { \
- if (__hash_equal(h->mrb,h->keys[k], key)) return k; \
+ if (__hash_equal(mrb,h->keys[k], key)) return k; \
} \
- k = (k+h->inc) & (h->mask); \
+ k = (k+(++step)) & khash_mask(h); \
} \
- return h->n_buckets; \
+ return kh_end(h); \
} \
- void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
+ void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets) \
{ \
if (new_n_buckets < KHASH_MIN_SIZE) \
new_n_buckets = KHASH_MIN_SIZE; \
@@ -157,44 +154,59 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
khint_t old_n_buckets = h->n_buckets; \
khint_t i; \
h->n_buckets = new_n_buckets; \
- kh_alloc_##name(h); \
+ kh_alloc_##name(mrb, h); \
/* relocate */ \
for (i=0 ; i<old_n_buckets ; i++) { \
if (!__ac_iseither(old_ed_flags, i)) { \
- khint_t k = kh_put_##name(h, old_keys[i]); \
- kh_value(h,k) = old_vals[i]; \
+ khint_t k = kh_put_##name(mrb, h, old_keys[i], NULL); \
+ if (kh_is_map) kh_value(h,k) = old_vals[i]; \
} \
} \
- mrb_free(h->mrb, old_keys); \
+ mrb_free(mrb, old_keys); \
} \
} \
- khint_t kh_put_##name(kh_##name##_t *h, khkey_t key) \
+ khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret) \
{ \
- khint_t k; \
- if (h->n_occupied >= h->upper_bound) { \
- kh_resize_##name(h, h->n_buckets*2); \
+ khint_t k, del_k, step = 0; \
+ if (h->n_occupied >= khash_upper_bound(h)) { \
+ kh_resize_##name(mrb, h, h->n_buckets*2); \
} \
- k = __hash_func(h->mrb,key) & (h->mask); \
- while (!__ac_iseither(h->ed_flags, k)) { \
- if (__hash_equal(h->mrb,h->keys[k], key)) break; \
- k = (k+h->inc) & (h->mask); \
+ k = __hash_func(mrb,key) & khash_mask(h); \
+ del_k = kh_end(h); \
+ while (!__ac_isempty(h->ed_flags, k)) { \
+ if (!__ac_isdel(h->ed_flags, k)) { \
+ if (__hash_equal(mrb,h->keys[k], key)) { \
+ if (ret) *ret = 0; \
+ return k; \
+ } \
+ } \
+ else if (del_k != kh_end(h)) { \
+ del_k = k; \
+ } \
+ k = (k+(++step)) & khash_mask(h); \
} \
- if (__ac_isempty(h->ed_flags, k)) { \
+ if (del_k != kh_end(h)) { \
+ /* put at del */ \
+ h->keys[del_k] = key; \
+ h->ed_flags[del_k/4] &= ~__m_del[del_k%4]; \
+ h->size++; \
+ if (ret) *ret = 2; \
+ return del_k; \
+ } \
+ else { \
/* put at empty */ \
h->keys[k] = key; \
h->ed_flags[k/4] &= ~__m_empty[k%4]; \
h->size++; \
h->n_occupied++; \
- } else if (__ac_isdel(h->ed_flags, k)) { \
- /* put at del */ \
- h->keys[k] = key; \
- h->ed_flags[k/4] &= ~__m_del[k%4]; \
- h->size++; \
+ if (ret) *ret = 1; \
+ return k; \
} \
- return k; \
} \
- void kh_del_##name(kh_##name##_t *h, khint_t x) \
+ void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x) \
{ \
+ (void)mrb; \
+ mrb_assert(x != h->n_buckets && !__ac_iseither(h->ed_flags, x)); \
h->ed_flags[x/4] |= __m_del[x%4]; \
h->size--; \
} \
@@ -206,8 +218,8 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
h2 = kh_init_##name(mrb); \
for (k = kh_begin(h); k != kh_end(h); k++) { \
if (kh_exist(h, k)) { \
- k2 = kh_put_##name(h2, kh_key(h, k)); \
- kh_value(h2, k2) = kh_value(h, k); \
+ k2 = kh_put_##name(mrb, h2, kh_key(h, k), NULL); \
+ if (kh_is_map) kh_value(h2, k2) = kh_value(h, k); \
} \
} \
return h2; \
@@ -218,12 +230,13 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
#define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size)
#define kh_init(name,mrb) kh_init_##name(mrb)
-#define kh_destroy(name, h) kh_destroy_##name(h)
-#define kh_clear(name, h) kh_clear_##name(h)
-#define kh_resize(name, h, s) kh_resize_##name(h, s)
-#define kh_put(name, h, k) kh_put_##name(h, k)
-#define kh_get(name, h, k) kh_get_##name(h, k)
-#define kh_del(name, h, k) kh_del_##name(h, k)
+#define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h)
+#define kh_clear(name, mrb, h) kh_clear_##name(mrb, h)
+#define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s)
+#define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k, NULL)
+#define kh_put2(name, mrb, h, k, r) kh_put_##name(mrb, h, k, r)
+#define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k)
+#define kh_del(name, mrb, h, k) kh_del_##name(mrb, h, k)
#define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
#define kh_exist(h, x) (!__ac_iseither((h)->ed_flags, (x)))
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index aac7b9920..17291c2f2 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -16,7 +16,6 @@ extern "C" {
#define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
-mrb_value mrb_flo_to_str(mrb_state *mrb, mrb_value flo, int max_digit);
mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base);
@@ -24,6 +23,7 @@ mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 8c6146860..f05813b78 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -20,6 +20,10 @@ struct REnv {
int cioff;
};
+#define MRB_ENV_STACK_LEN(e) ((e)->flags)
+#define MRB_ENV_UNSHARE_STACK(e) ((e)->cioff = -1)
+#define MRB_ENV_STACK_SHARED_P(e) ((e)->cioff >= 0)
+
struct RProc {
MRB_OBJECT_HEADER;
union {
@@ -44,7 +48,7 @@ struct RProc {
#define MRB_PROC_STRICT 256
#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
-#define mrb_proc_ptr(v) ((struct RProc*)((v).value.p))
+#define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v)))
struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
@@ -52,8 +56,15 @@ struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
void mrb_proc_copy(struct RProc *a, struct RProc *b);
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
+/* following functions are defined in mruby-proc-ext so please include it when using */
+struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const mrb_value*);
+mrb_value mrb_cfunc_env_get(mrb_state*, mrb_int);
+
#include "mruby/khash.h"
-KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1)
+KHASH_DECLARE(mt, mrb_sym, struct RProc*, TRUE)
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/range.h b/include/mruby/range.h
index a87f1cc6a..78ddf32a3 100644
--- a/include/mruby/range.h
+++ b/include/mruby/range.h
@@ -22,11 +22,11 @@ struct RRange {
int excl;
};
-#define mrb_range_ptr(v) ((struct RRange*)((v).value.p))
+#define mrb_range_ptr(v) ((struct RRange*)(mrb_ptr(v)))
#define mrb_range_value(p) mrb_obj_value((void*)(p))
mrb_value mrb_range_new(mrb_state*, mrb_value, mrb_value, int);
-mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len);
+mrb_bool mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 000c80b09..d19e0d493 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -15,34 +15,57 @@ extern "C" {
extern const char mrb_digitmap[];
+#define RSTRING_EMBED_LEN_MAX ((mrb_int)(sizeof(void*) * 3 - 1))
+
struct RString {
MRB_OBJECT_HEADER;
- mrb_int len;
union {
- mrb_int capa;
- struct mrb_shared_string *shared;
- } aux;
- char *ptr;
+ struct {
+ mrb_int len;
+ union {
+ mrb_int capa;
+ struct mrb_shared_string *shared;
+ } aux;
+ char *ptr;
+ } heap;
+ char ary[RSTRING_EMBED_LEN_MAX + 1];
+ } as;
};
-#define mrb_str_ptr(s) ((struct RString*)((s).value.p))
-#define RSTRING(s) ((struct RString*)((s).value.p))
-#define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#define RSTRING_LEN(s) (RSTRING(s)->len)
-#define RSTRING_CAPA(s) (RSTRING(s)->aux.capa)
-#define RSTRING_END(s) (RSTRING(s)->ptr + RSTRING(s)->len)
+#define mrb_str_ptr(s) ((struct RString*)(mrb_ptr(s)))
+#define RSTRING(s) ((struct RString*)(mrb_ptr(s)))
+#define RSTRING_PTR(s)\
+ ((RSTRING(s)->flags & MRB_STR_EMBED) ?\
+ RSTRING(s)->as.ary :\
+ RSTRING(s)->as.heap.ptr)
+#define RSTRING_LEN(s)\
+ ((RSTRING(s)->flags & MRB_STR_EMBED) ?\
+ (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT) :\
+ RSTRING(s)->as.heap.len)
+#define RSTRING_CAPA(s)\
+ ((RSTRING(s)->flags & MRB_STR_EMBED) ?\
+ RSTRING_EMBED_LEN_MAX :\
+ RSTRING(s)->as.heap.aux.capa)
+#define RSTRING_END(s) (RSTRING_PTR(s) + RSTRING_LEN(s))
+mrb_int mrb_str_strlen(mrb_state*, struct RString*);
+
+#define MRB_STR_SHARED 1
+#define MRB_STR_NOFREE 2
+#define MRB_STR_EMBED 4
+#define MRB_STR_EMBED_LEN_MASK 0xf8
+#define MRB_STR_EMBED_LEN_SHIFT 3
void mrb_gc_free_str(mrb_state*, struct RString*);
void mrb_str_modify(mrb_state*, struct RString*);
-mrb_value mrb_str_literal(mrb_state*, mrb_value);
void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
-mrb_value mrb_ptr_to_str(mrb_state *, void *);
+mrb_value mrb_ptr_to_str(mrb_state *, void*);
mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
+mrb_value mrb_string_type(mrb_state *mrb, mrb_value str);
mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
-mrb_value mrb_str_buf_new(mrb_state *mrb, mrb_int capa);
+mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr);
@@ -50,9 +73,8 @@ char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr);
int mrb_str_offset(mrb_state *mrb, mrb_value str, int pos);
mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
-mrb_value mrb_str_cat_cstr(mrb_state *, mrb_value, const char *);
-mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck);
-double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck);
+mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck);
+double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
@@ -60,10 +82,13 @@ mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
+mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr);
+#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
+mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str);
/* For backward compatibility */
static inline mrb_value
diff --git a/include/mruby/value.h b/include/mruby/value.h
index e78035b5f..899ec30eb 100644
--- a/include/mruby/value.h
+++ b/include/mruby/value.h
@@ -26,6 +26,7 @@
# error Cannot use NaN boxing when mrb_int is 64bit
# else
typedef int64_t mrb_int;
+# define MRB_INT_BIT 64
# define MRB_INT_MIN INT64_MIN
# define MRB_INT_MAX INT64_MAX
# define PRIdMRB_INT PRId64
@@ -36,10 +37,12 @@
# endif
#elif defined(MRB_INT16)
typedef int16_t mrb_int;
+# define MRB_INT_BIT 16
# define MRB_INT_MIN INT16_MIN
# define MRB_INT_MAX INT16_MAX
#else
typedef int32_t mrb_int;
+# define MRB_INT_BIT 32
# define MRB_INT_MIN INT32_MIN
# define MRB_INT_MAX INT32_MAX
# define PRIdMRB_INT PRId32
@@ -59,6 +62,7 @@ typedef short mrb_sym;
# include <float.h>
# define isnan _isnan
# define isinf(n) (!_finite(n) && !_isnan(n))
+# define signbit(n) (_copysign(1.0, (n)) < 0.0)
# define strtoll _strtoi64
# define strtof (float)strtod
# define PRId32 "I32d"
@@ -71,6 +75,8 @@ typedef short mrb_sym;
# define PRIo64 "I64o"
# define PRIx64 "I64x"
# define PRIX64 "I64X"
+# define INFINITY ((float)(DBL_MAX * DBL_MAX))
+# define NAN ((float)(INFINITY - INFINITY))
# else
# include <inttypes.h>
# endif
@@ -99,7 +105,7 @@ enum mrb_vtype {
MRB_TT_SYMBOL, /* 5 */
MRB_TT_UNDEF, /* 6 */
MRB_TT_FLOAT, /* 7 */
- MRB_TT_VOIDP, /* 8 */
+ MRB_TT_CPTR, /* 8 */
MRB_TT_OBJECT, /* 9 */
MRB_TT_CLASS, /* 10 */
MRB_TT_MODULE, /* 11 */
@@ -129,27 +135,45 @@ enum mrb_vtype {
typedef struct mrb_value {
union {
mrb_float f;
- struct {
- MRB_ENDIAN_LOHI(
- uint32_t ttt;
- ,union {
- void *p;
- mrb_int i;
- mrb_sym sym;
- } value;
- )
- };
+ union {
+ void *p;
+ struct {
+ MRB_ENDIAN_LOHI(
+ uint32_t ttt;
+ ,union {
+ mrb_int i;
+ mrb_sym sym;
+ };
+ )
+ };
+ } value;
};
} mrb_value;
-#define mrb_tt(o) ((o).ttt & 0xff)
-#define mrb_mktt(tt) (0xfff00000|(tt))
-#define mrb_type(o) ((uint32_t)0xfff00000 < (o).ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_float(o) (o).f
+/* value representation by nan-boxing:
+ * float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
+ * object: 111111111111TTTT TTPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP
+ * int : 1111111111110001 0000000000000000 IIIIIIIIIIIIIIII IIIIIIIIIIIIIIII
+ * sym : 1111111111110001 0100000000000000 SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS
+ * In order to get enough bit size to save TT, all pointers are shifted 2 bits
+ * in the right direction.
+ */
+#define mrb_tt(o) ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14))
+#define mrb_mktt(tt) (0xfff00000|((tt)<<14))
+#define mrb_type(o) ((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
+#define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
+#define mrb_float(o) (o).f
#define MRB_SET_VALUE(o, tt, attr, v) do {\
- (o).ttt = mrb_mktt(tt);\
- (o).attr = v;\
+ (o).value.ttt = mrb_mktt(tt);\
+ switch (tt) {\
+ case MRB_TT_FALSE:\
+ case MRB_TT_TRUE:\
+ case MRB_TT_UNDEF:\
+ case MRB_TT_FIXNUM:\
+ case MRB_TT_SYMBOL: (o).attr = (v); break;\
+ default: (o).value.i = 0; (o).value.p = (void*)((uintptr_t)(o).value.p | (((uintptr_t)(v))>>2)); break;\
+ }\
} while (0)
static inline mrb_value
@@ -158,13 +182,14 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
mrb_value v;
if (f != f) {
- v.ttt = 0x7ff80000;
+ v.value.ttt = 0x7ff80000;
v.value.i = 0;
} else {
v.f = f;
}
return v;
}
+#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
#else
@@ -176,7 +201,7 @@ enum mrb_vtype {
MRB_TT_SYMBOL, /* 4 */
MRB_TT_UNDEF, /* 5 */
MRB_TT_FLOAT, /* 6 */
- MRB_TT_VOIDP, /* 7 */
+ MRB_TT_CPTR, /* 7 */
MRB_TT_OBJECT, /* 8 */
MRB_TT_CLASS, /* 9 */
MRB_TT_MODULE, /* 10 */
@@ -197,6 +222,7 @@ enum mrb_vtype {
#if defined(MRB_WORD_BOXING)
+#include <limits.h>
#define MRB_TT_HAS_BASIC MRB_TT_FLOAT
enum mrb_special_consts {
@@ -216,20 +242,21 @@ typedef union mrb_value {
void *p;
struct {
unsigned int i_flag : MRB_FIXNUM_SHIFT;
- mrb_int i : (sizeof(mrb_int) * 8 - MRB_FIXNUM_SHIFT);
+ mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT);
};
struct {
unsigned int sym_flag : MRB_SPECIAL_SHIFT;
- int sym : (sizeof(mrb_sym) * 8);
+ int sym : (sizeof(mrb_sym) * CHAR_BIT);
};
struct RBasic *bp;
struct RFloat *fp;
- struct RVoidp *vp;
+ struct RCptr *vp;
} value;
unsigned long w;
} mrb_value;
-#define mrb_float(o) (o).value.fp->f
+#define mrb_ptr(o) (o).value.p
+#define mrb_float(o) (o).value.fp->f
#define MRB_SET_VALUE(o, ttt, attr, v) do {\
(o).w = 0;\
@@ -244,8 +271,8 @@ typedef union mrb_value {
}\
} while (0)
-extern mrb_value
-mrb_float_value(struct mrb_state *mrb, mrb_float f);
+mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f);
+mrb_value mrb_float_pool(struct mrb_state *mrb, mrb_float f);
#else /* No MRB_xxx_BOXING */
@@ -261,8 +288,9 @@ typedef struct mrb_value {
enum mrb_vtype tt;
} mrb_value;
-#define mrb_type(o) (o).tt
-#define mrb_float(o) (o).value.f
+#define mrb_type(o) (o).tt
+#define mrb_ptr(o) (o).value.p
+#define mrb_float(o) (o).value.f
#define MRB_SET_VALUE(o, ttt, attr, v) do {\
(o).tt = ttt;\
@@ -273,10 +301,12 @@ static inline mrb_value
mrb_float_value(struct mrb_state *mrb, mrb_float f)
{
mrb_value v;
+ (void) mrb;
MRB_SET_VALUE(v, MRB_TT_FLOAT, value.f, f);
return v;
}
+#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
#endif /* no boxing */
@@ -284,7 +314,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
#ifdef MRB_WORD_BOXING
-#define mrb_voidp(o) (o).value.vp->p
+#define mrb_cptr(o) (o).value.vp->p
#define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG)
#define mrb_undef_p(o) ((o).w == MRB_Qundef)
#define mrb_nil_p(o) ((o).w == MRB_Qnil)
@@ -292,7 +322,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
#else
-#define mrb_voidp(o) (o).value.p
+#define mrb_cptr(o) mrb_ptr(o)
#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
#define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
#define mrb_nil_p(o) (mrb_type(o) == MRB_TT_FALSE && !(o).value.i)
@@ -307,7 +337,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
#define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
#define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
#define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
-#define mrb_voidp_p(o) (mrb_type(o) == MRB_TT_VOIDP)
+#define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
#define mrb_test(o) mrb_bool(o)
#define MRB_OBJECT_HEADER \
@@ -339,8 +369,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
struct RBasic {
MRB_OBJECT_HEADER;
};
-
-#define mrb_basic_ptr(v) ((struct RBasic*)((v).value.p))
+#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
/* obsolete macro mrb_basic; will be removed soon */
#define mrb_basic(v) mrb_basic_ptr(v)
@@ -348,11 +377,10 @@ struct RObject {
MRB_OBJECT_HEADER;
struct iv_tbl *iv;
};
-
-#define mrb_obj_ptr(v) ((struct RObject*)((v).value.p))
+#define mrb_obj_ptr(v) ((struct RObject*)(mrb_ptr(v)))
/* obsolete macro mrb_object; will be removed soon */
#define mrb_object(o) mrb_obj_ptr(o)
-#define mrb_immediate_p(x) (mrb_type(x) <= MRB_TT_VOIDP)
+#define mrb_immediate_p(x) (mrb_type(x) <= MRB_TT_CPTR)
#define mrb_special_const_p(x) mrb_immediate_p(x)
struct RFiber {
@@ -366,7 +394,7 @@ struct RFloat {
mrb_float f;
};
-struct RVoidp {
+struct RCptr {
MRB_OBJECT_HEADER;
void *p;
};
@@ -423,17 +451,25 @@ mrb_obj_value(void *p)
#ifdef MRB_WORD_BOXING
mrb_value
-mrb_voidp_value(struct mrb_state *mrb, void *p);
+mrb_cptr_value(struct mrb_state *mrb, void *p);
#else
static inline mrb_value
-mrb_voidp_value(struct mrb_state *mrb, void *p)
+mrb_cptr_value(struct mrb_state *mrb, void *p)
{
mrb_value v;
+ (void) mrb;
- MRB_SET_VALUE(v, MRB_TT_VOIDP, value.p, p);
+ MRB_SET_VALUE(v, MRB_TT_CPTR, value.p, p);
return v;
}
#endif
+/* obsolete macros; will be removed */
+#define MRB_TT_VOIDP MRB_TT_CPTR
+#define mrb_voidp_value(m,p) mrb_cptr_value((m),(p))
+#define mrb_voidp(o) mrb_cptr(o)
+#define mrb_voidp_p(o) mrb_cptr_p(o)
+
+#define MRB_TT_HAS_BASIC_P(tt) ((tt) >= MRB_TT_HAS_BASIC)
static inline mrb_value
mrb_false_value(void)
@@ -480,4 +516,4 @@ mrb_bool_value(mrb_bool boolean)
return v;
}
-#endif /* MRUBY_OBJECT_H */
+#endif /* MRUBY_VALUE_H */
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 2845e0daa..68a4e5889 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -12,18 +12,18 @@ extern "C" {
#endif
typedef struct global_variable {
- int counter;
- mrb_value *data;
- mrb_value (*getter)(void);
- void (*setter)(void);
- //void (*marker)();
- //int block_trace;
- //struct trace_var *trace;
+ int counter;
+ mrb_value *data;
+ mrb_value (*getter)(void);
+ void (*setter)(void);
+ /* void (*marker)(); */
+ /* int block_trace; */
+ /* struct trace_var *trace; */
} global_variable;
struct global_entry {
- global_variable *var;
- mrb_sym id;
+ global_variable *var;
+ mrb_sym id;
};
mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
@@ -53,6 +53,7 @@ mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
+void mrb_gv_remove(mrb_state *mrb, mrb_sym sym);
mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
mrb_sym mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer);
diff --git a/include/mruby/version.h b/include/mruby/version.h
new file mode 100644
index 000000000..d451dfb31
--- /dev/null
+++ b/include/mruby/version.h
@@ -0,0 +1,34 @@
+#ifndef MRUBY_VERSION_H
+#define MRUBY_VERSION_H
+
+#define MRUBY_RUBY_VERSION "1.9"
+#define MRUBY_RUBY_ENGINE "mruby"
+
+#define MRUBY_VERSION "1.0.0"
+#define MRUBY_RELEASE_MAJOR 1
+#define MRUBY_RELEASE_MINOR 0
+#define MRUBY_RELEASE_TEENY 1
+#define MRUBY_RELEASE_NO 10001
+#define MRUBY_RELEASE_DATE "2014-01-10"
+#define MRUBY_RELEASE_YEAR 2014
+#define MRUBY_RELEASE_MONTH 1
+#define MRUBY_RELEASE_DAY 10
+
+#define MRUBY_BIRTH_YEAR 2010
+
+#define MRUBY_AUTHOR "mruby developers"
+
+#define MRB_STRINGIZE0(expr) #expr
+#define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
+
+#define MRUBY_DESCRIPTION \
+ "mruby " MRUBY_VERSION \
+ " (" MRUBY_RELEASE_DATE ") " \
+
+#define MRUBY_COPYRIGHT \
+ "mruby - Copyright (c) " \
+ MRB_STRINGIZE(MRUBY_BIRTH_YEAR)"-" \
+ MRB_STRINGIZE(MRUBY_RELEASE_YEAR)" " \
+ MRUBY_AUTHOR \
+
+#endif /* MRUBY_VERSION_H */
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-18 19:25:49 +0000