1 #ifndef RUBY_EVAL_INTERN_H
2 #define RUBY_EVAL_INTERN_H
8 vm_passed_block_handler_set(rb_execution_context_t
*ec
, VALUE block_handler
)
10 vm_block_handler_verify(block_handler
);
11 ec
->passed_block_handler
= block_handler
;
15 pass_passed_block_handler(rb_execution_context_t
*ec
)
17 VALUE block_handler
= rb_vm_frame_block_handler(ec
->cfp
);
18 vm_passed_block_handler_set(ec
, block_handler
);
19 VM_ENV_FLAGS_SET(ec
->cfp
->ep
, VM_FRAME_FLAG_PASSED
);
22 #define PASS_PASSED_BLOCK_HANDLER_EC(ec) pass_passed_block_handler(ec)
23 #define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_EC())
29 #define EXIT_SUCCESS 0
32 #define EXIT_FAILURE 1
36 #if defined(__wasm__) && !defined(__EMSCRIPTEN__)
37 # include "wasm/setjmp.h"
43 # ifdef HAVE_CRT_EXTERNS_H
44 # include <crt_externs.h>
46 # include "missing/crt_externs.h"
51 char *strrchr(const char *, const char);
58 #ifdef HAVE_NET_SOCKET_H
59 #include <net/socket.h>
62 #define ruby_setjmp(env) RUBY_SETJMP(env)
63 #define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
69 NORETURN(void _longjmp(jmp_buf, int));
73 #include <sys/types.h>
77 #ifdef HAVE_SYS_SELECT_H
78 #include <sys/select.h>
82 Solaris sys/select.h switches select to select_large_fdset to support larger
83 file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
84 But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
85 So following definition is required to use select_large_fdset.
87 #ifdef HAVE_SELECT_LARGE_FDSET
88 #define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
89 extern int select_large_fdset(int, fd_set
*, fd_set
*, fd_set
*, struct timeval
*);
92 #ifdef HAVE_SYS_PARAM_H
93 #include <sys/param.h>
98 #define EC_PUSH_TAG(ec) do { \
99 rb_execution_context_t * const _ec = (ec); \
100 struct rb_vm_tag _tag; \
101 _tag.state = TAG_NONE; \
103 _tag.prev = _ec->tag; \
104 _tag.lock_rec = rb_ec_vm_lock_rec(_ec); \
105 rb_vm_tag_jmpbuf_init(&_tag.buf); \
107 #define EC_POP_TAG() \
108 _ec->tag = _tag.prev; \
109 rb_vm_tag_jmpbuf_deinit(&_tag.buf); \
112 #define EC_TMPPOP_TAG() \
115 #define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
117 #if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || defined __clang__
118 /* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
119 * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
120 * (I confirmed Clang 4.0.1 and 5.0.0.)
122 # define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
123 # define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
124 # define VAR_NOCLOBBERED(var) volatile var
126 # define VAR_FROM_MEMORY(var) (var)
127 # define VAR_INITIALIZED(var) ((void)&(var))
128 # define VAR_NOCLOBBERED(var) var
132 rb_ec_vm_lock_rec_check(const rb_execution_context_t
*ec
, unsigned int recorded_lock_rec
)
134 unsigned int current_lock_rec
= rb_ec_vm_lock_rec(ec
);
135 if (current_lock_rec
!= recorded_lock_rec
) {
136 rb_ec_vm_lock_rec_release(ec
, recorded_lock_rec
, current_lock_rec
);
140 /* clear ec->tag->state, and return the value */
142 rb_ec_tag_state(const rb_execution_context_t
*ec
)
144 struct rb_vm_tag
*tag
= ec
->tag
;
145 enum ruby_tag_type state
= tag
->state
;
146 tag
->state
= TAG_NONE
;
147 rb_ec_vm_lock_rec_check(ec
, tag
->lock_rec
);
148 RBIMPL_ASSUME(state
> TAG_NONE
);
149 RBIMPL_ASSUME(state
<= TAG_FATAL
);
153 NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t
*ec
, enum ruby_tag_type st
));
155 rb_ec_tag_jump(const rb_execution_context_t
*ec
, enum ruby_tag_type st
)
157 RUBY_ASSERT(st
> TAG_NONE
&& st
<= TAG_FATAL
, ": Invalid tag jump: %d", (int)st
);
159 ruby_longjmp(RB_VM_TAG_JMPBUF_GET(ec
->tag
->buf
), 1);
163 setjmp() in assignment expression rhs is undefined behavior
164 [ISO/IEC 9899:1999] 7.13.1.1
166 #define EC_EXEC_TAG() \
167 (UNLIKELY(ruby_setjmp(RB_VM_TAG_JMPBUF_GET(_tag.buf))) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
169 #define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
171 #define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
175 #define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
176 #define CREF_FL_OMOD_SHARED IMEMO_FL_USER2
177 #define CREF_FL_SINGLETON IMEMO_FL_USER3
179 static inline int CREF_SINGLETON(const rb_cref_t
*cref
);
182 CREF_CLASS(const rb_cref_t
*cref
)
184 if (CREF_SINGLETON(cref
)) {
185 return CLASS_OF(cref
->klass_or_self
);
188 return cref
->klass_or_self
;
193 CREF_CLASS_FOR_DEFINITION(const rb_cref_t
*cref
)
195 if (CREF_SINGLETON(cref
)) {
196 return rb_singleton_class(cref
->klass_or_self
);
199 return cref
->klass_or_self
;
203 static inline rb_cref_t
*
204 CREF_NEXT(const rb_cref_t
*cref
)
209 static inline const rb_scope_visibility_t
*
210 CREF_SCOPE_VISI(const rb_cref_t
*cref
)
212 return &cref
->scope_visi
;
216 CREF_REFINEMENTS(const rb_cref_t
*cref
)
218 return cref
->refinements
;
222 CREF_REFINEMENTS_SET(rb_cref_t
*cref
, VALUE refs
)
224 RB_OBJ_WRITE(cref
, &cref
->refinements
, refs
);
228 CREF_PUSHED_BY_EVAL(const rb_cref_t
*cref
)
230 return cref
->flags
& CREF_FL_PUSHED_BY_EVAL
;
234 CREF_PUSHED_BY_EVAL_SET(rb_cref_t
*cref
)
236 cref
->flags
|= CREF_FL_PUSHED_BY_EVAL
;
240 CREF_SINGLETON(const rb_cref_t
*cref
)
242 return cref
->flags
& CREF_FL_SINGLETON
;
246 CREF_SINGLETON_SET(rb_cref_t
*cref
)
248 cref
->flags
|= CREF_FL_SINGLETON
;
252 CREF_OMOD_SHARED(const rb_cref_t
*cref
)
254 return cref
->flags
& CREF_FL_OMOD_SHARED
;
258 CREF_OMOD_SHARED_SET(rb_cref_t
*cref
)
260 cref
->flags
|= CREF_FL_OMOD_SHARED
;
264 CREF_OMOD_SHARED_UNSET(rb_cref_t
*cref
)
266 cref
->flags
&= ~CREF_FL_OMOD_SHARED
;
270 RAISED_EXCEPTION
= 1,
271 RAISED_STACKOVERFLOW
= 2,
274 #define rb_ec_raised_set(ec, f) ((ec)->raised_flag |= (f))
275 #define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
276 #define rb_ec_raised_p(ec, f) (((ec)->raised_flag & (f)) != 0)
277 #define rb_ec_raised_clear(ec) ((ec)->raised_flag = 0)
278 int rb_ec_set_raised(rb_execution_context_t
*ec
);
279 int rb_ec_reset_raised(rb_execution_context_t
*ec
);
280 int rb_ec_stack_check(rb_execution_context_t
*ec
);
282 VALUE
rb_f_eval(int argc
, const VALUE
*argv
, VALUE self
);
283 VALUE
rb_make_exception(int argc
, const VALUE
*argv
);
285 NORETURN(void rb_method_name_error(VALUE
, VALUE
));
287 NORETURN(void rb_fiber_start(rb_fiber_t
*));
289 NORETURN(void rb_print_undef(VALUE
, ID
, rb_method_visibility_t
));
290 NORETURN(void rb_print_undef_str(VALUE
, VALUE
));
291 NORETURN(void rb_print_inaccessible(VALUE
, ID
, rb_method_visibility_t
));
292 NORETURN(void rb_vm_localjump_error(const char *,VALUE
, int));
293 NORETURN(void rb_vm_jump_tag_but_local_jump(enum ruby_tag_type
));
295 VALUE
rb_vm_make_jump_tag_but_local_jump(enum ruby_tag_type state
, VALUE val
);
296 rb_cref_t
*rb_vm_cref(void);
297 rb_cref_t
*rb_vm_cref_replace_with_duplicated_cref(void);
298 VALUE
rb_vm_call_cfunc(VALUE recv
, VALUE (*func
)(VALUE
), VALUE arg
, VALUE block_handler
, VALUE filename
);
299 void rb_vm_set_progname(VALUE filename
);
300 VALUE
rb_vm_cbase(void);
303 VALUE
rb_ec_backtrace_object(const rb_execution_context_t
*ec
);
304 VALUE
rb_ec_backtrace_str_ary(const rb_execution_context_t
*ec
, long lev
, long n
);
305 VALUE
rb_ec_backtrace_location_ary(const rb_execution_context_t
*ec
, long lev
, long n
, bool skip_internal
);
307 #ifndef CharNext /* defined as CharNext[AW] on Windows. */
309 # define CharNext(p) rb_char_next(p)
311 rb_char_next(const char *p
)
314 int len
= mblen(p
, RUBY_MBCHAR_MAXSIZE
);
315 p
+= len
> 0 ? len
: 1;
320 # define CharNext(p) ((p) + 1)
324 #endif /* RUBY_EVAL_INTERN_H */