Ruby: eval_intern.h Source File

Ruby 3.4.3p32 (2025-04-14 revision d0b7e5b6a04bde21ca483d20a1546b28b401c2d4)

eval_intern.h
1#ifndef RUBY_EVAL_INTERN_H
2#define RUBY_EVAL_INTERN_H
3
4#include "ruby/ruby.h"
5#include "vm_core.h"
6
7static inline void
8vm_passed_block_handler_set(rb_execution_context_t *ec, VALUE block_handler)
9{
10 vm_block_handler_verify(block_handler);
11 ec->passed_block_handler = block_handler;
12}
13
14static inline void
15pass_passed_block_handler(rb_execution_context_t *ec)
16{
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);
20}
21
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())
24
25#ifdef HAVE_STDLIB_H
26#include <stdlib.h>
27#endif
28#ifndef EXIT_SUCCESS
29#define EXIT_SUCCESS 0
30#endif
31#ifndef EXIT_FAILURE
32#define EXIT_FAILURE 1
33#endif
34
35#include <stdio.h>
36#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
37# include "wasm/setjmp.h"
38#else
39# include <setjmp.h>
40#endif
41
42#ifdef __APPLE__
43# ifdef HAVE_CRT_EXTERNS_H
44# include <crt_externs.h>
45# else
46# include "missing/crt_externs.h"
47# endif
48#endif
49
50#ifndef HAVE_STRING_H
51char *strrchr(const char *, const char);
52#endif
53
54#ifdef HAVE_UNISTD_H
55#include <unistd.h>
56#endif
57
58#ifdef HAVE_NET_SOCKET_H
59#include <net/socket.h>
60#endif
61
62#define ruby_setjmp(env) RUBY_SETJMP(env)
63#define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
64#ifdef __CYGWIN__
65# ifndef _setjmp
66int _setjmp(jmp_buf);
67# endif
68# ifndef _longjmp
69NORETURN(void _longjmp(jmp_buf, int));
70# endif
71#endif
72
73#include <sys/types.h>
74#include <signal.h>
75#include <errno.h>
76
77#ifdef HAVE_SYS_SELECT_H
78#include <sys/select.h>
79#endif
80
81/*
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.
86*/
87#ifdef HAVE_SELECT_LARGE_FDSET
88#define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
89extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval *);
90#endif
91
92#ifdef HAVE_SYS_PARAM_H
93#include <sys/param.h>
94#endif
95
96#include <sys/stat.h>
97
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; \
102 _tag.tag = Qundef; \
103 _tag.prev = _ec->tag; \
104 _tag.lock_rec = rb_ec_vm_lock_rec(_ec); \
105 rb_vm_tag_jmpbuf_init(&_tag.buf); \
106
107#define EC_POP_TAG() \
108 _ec->tag = _tag.prev; \
109 rb_vm_tag_jmpbuf_deinit(&_tag.buf); \
110} while (0)
111
112#define EC_TMPPOP_TAG() \
113 _ec->tag = _tag.prev
114
115#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
116
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.)
121 */
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
125#else
126# define VAR_FROM_MEMORY(var) (var)
127# define VAR_INITIALIZED(var) ((void)&(var))
128# define VAR_NOCLOBBERED(var) var
129#endif
130
131static inline void
132rb_ec_vm_lock_rec_check(const rb_execution_context_t *ec, unsigned int recorded_lock_rec)
133{
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);
137 }
138}
139
140/* clear ec->tag->state, and return the value */
141static inline int
142rb_ec_tag_state(const rb_execution_context_t *ec)
143{
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);
150 return state;
151}
152
153NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
154static inline void
155rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
156{
157 RUBY_ASSERT(st > TAG_NONE && st <= TAG_FATAL, ": Invalid tag jump: %d", (int)st);
158 ec->tag->state = st;
159 ruby_longjmp(RB_VM_TAG_JMPBUF_GET(ec->tag->buf), 1);
160}
161
162/*
163 setjmp() in assignment expression rhs is undefined behavior
164 [ISO/IEC 9899:1999] 7.13.1.1
165*/
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))
168
169#define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
170
171#define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
172
173/* CREF operators */
174
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
178
179static inline int CREF_SINGLETON(const rb_cref_t *cref);
180
181static inline VALUE
182CREF_CLASS(const rb_cref_t *cref)
183{
184 if (CREF_SINGLETON(cref)) {
185 return CLASS_OF(cref->klass_or_self);
186 }
187 else {
188 return cref->klass_or_self;
189 }
190}
191
192static inline VALUE
193CREF_CLASS_FOR_DEFINITION(const rb_cref_t *cref)
194{
195 if (CREF_SINGLETON(cref)) {
196 return rb_singleton_class(cref->klass_or_self);
197 }
198 else {
199 return cref->klass_or_self;
200 }
201}
202
203static inline rb_cref_t *
204CREF_NEXT(const rb_cref_t *cref)
205{
206 return cref->next;
207}
208
209static inline const rb_scope_visibility_t *
210CREF_SCOPE_VISI(const rb_cref_t *cref)
211{
212 return &cref->scope_visi;
213}
214
215static inline VALUE
216CREF_REFINEMENTS(const rb_cref_t *cref)
217{
218 return cref->refinements;
219}
220
221static inline void
222CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
223{
224 RB_OBJ_WRITE(cref, &cref->refinements, refs);
225}
226
227static inline int
228CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
229{
230 return cref->flags & CREF_FL_PUSHED_BY_EVAL;
231}
232
233static inline void
234CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
235{
236 cref->flags |= CREF_FL_PUSHED_BY_EVAL;
237}
238
239static inline int
240CREF_SINGLETON(const rb_cref_t *cref)
241{
242 return cref->flags & CREF_FL_SINGLETON;
243}
244
245static inline void
246CREF_SINGLETON_SET(rb_cref_t *cref)
247{
248 cref->flags |= CREF_FL_SINGLETON;
249}
250
251static inline int
252CREF_OMOD_SHARED(const rb_cref_t *cref)
253{
254 return cref->flags & CREF_FL_OMOD_SHARED;
255}
256
257static inline void
258CREF_OMOD_SHARED_SET(rb_cref_t *cref)
259{
260 cref->flags |= CREF_FL_OMOD_SHARED;
261}
262
263static inline void
264CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
265{
266 cref->flags &= ~CREF_FL_OMOD_SHARED;
267}
268
269enum {
270 RAISED_EXCEPTION = 1,
271 RAISED_STACKOVERFLOW = 2,
272 RAISED_NOMEMORY = 4
273};
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)
278int rb_ec_set_raised(rb_execution_context_t *ec);
279int rb_ec_reset_raised(rb_execution_context_t *ec);
280int rb_ec_stack_check(rb_execution_context_t *ec);
281
282 VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
283 VALUE rb_make_exception(int argc, const VALUE *argv);
284
285NORETURN(void rb_method_name_error(VALUE, VALUE));
286
287NORETURN(void rb_fiber_start(rb_fiber_t*));
288
289NORETURN(void rb_print_undef(VALUE, ID, rb_method_visibility_t));
290NORETURN(void rb_print_undef_str(VALUE, VALUE));
291NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
292NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
293NORETURN(void rb_vm_jump_tag_but_local_jump(enum ruby_tag_type));
294
295 VALUE rb_vm_make_jump_tag_but_local_jump(enum ruby_tag_type state, VALUE val);
296rb_cref_t *rb_vm_cref(void);
297rb_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);
299void rb_vm_set_progname(VALUE filename);
300 VALUE rb_vm_cbase(void);
301
302/* vm_backtrace.c */
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);
306
307#ifndef CharNext /* defined as CharNext[AW] on Windows. */
308# ifdef HAVE_MBLEN
309# define CharNext(p) rb_char_next(p)
310static inline char *
311rb_char_next(const char *p)
312{
313 if (p) {
314 int len = mblen(p, RUBY_MBCHAR_MAXSIZE);
315 p += len > 0 ? len : 1;
316 }
317 return (char *)p;
318}
319# else
320# define CharNext(p) ((p) + 1)
321# endif
322#endif
323
324#endif /* RUBY_EVAL_INTERN_H */
RUBY_ASSERT
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
rb_singleton_class
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2297
CLASS_OF
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:203
RB_OBJ_WRITE
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
len
int len
Length of the buffer.
Definition io.h:8
RBIMPL_ASSUME
#define RBIMPL_ASSUME(_)
Wraps (or simulates) __builtin_unreachable.
Definition assume.h:76
ruby.h
rb_vm_tag
Definition vm_core.h:993
timeval
Definition missing.h:63
ID
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
VALUE
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40