Ruby: eval_intern.h Source File

Ruby 3.2.5p208 (2024-07-26 revision 31d0f1a2e7dbfb60731d1f05b868e1d578cda493)

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
99#define SAVE_ROOT_JMPBUF(th, stmt) do \
100 if (true) { \
101 stmt; \
102 } \
103 else if (th) { /* suppress unused-variable warning */ \
104 } while (0)
105
106#define EC_PUSH_TAG(ec) do { \
107 rb_execution_context_t * const _ec = (ec); \
108 struct rb_vm_tag _tag; \
109 _tag.state = TAG_NONE; \
110 _tag.tag = Qundef; \
111 _tag.prev = _ec->tag; \
112 _tag.lock_rec = rb_ec_vm_lock_rec(_ec); \
113
114#define EC_POP_TAG() \
115 _ec->tag = _tag.prev; \
116} while (0)
117
118#define EC_TMPPOP_TAG() \
119 _ec->tag = _tag.prev
120
121#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
122
123#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || defined __clang__
124/* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
125 * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
126 * (I confirmed Clang 4.0.1 and 5.0.0.)
127 */
128# define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
129# define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
130# define VAR_NOCLOBBERED(var) volatile var
131#else
132# define VAR_FROM_MEMORY(var) (var)
133# define VAR_INITIALIZED(var) ((void)&(var))
134# define VAR_NOCLOBBERED(var) var
135#endif
136
137static inline void
138rb_ec_vm_lock_rec_check(const rb_execution_context_t *ec, unsigned int recorded_lock_rec)
139{
140 unsigned int current_lock_rec = rb_ec_vm_lock_rec(ec);
141 if (current_lock_rec != recorded_lock_rec) {
142 rb_ec_vm_lock_rec_release(ec, recorded_lock_rec, current_lock_rec);
143 }
144}
145
146/* clear ec->tag->state, and return the value */
147static inline int
148rb_ec_tag_state(const rb_execution_context_t *ec)
149{
150 struct rb_vm_tag *tag = ec->tag;
151 enum ruby_tag_type state = tag->state;
152 tag->state = TAG_NONE;
153 rb_ec_vm_lock_rec_check(ec, tag->lock_rec);
154 return state;
155}
156
157NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
158static inline void
159rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
160{
161 ec->tag->state = st;
162 ruby_longjmp(ec->tag->buf, 1);
163}
164
165/*
166 setjmp() in assignment expression rhs is undefined behavior
167 [ISO/IEC 9899:1999] 7.13.1.1
168*/
169#define EC_EXEC_TAG() \
170 (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
171
172#define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
173
174#define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
175
176/* CREF operators */
177
178#define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
179#define CREF_FL_OMOD_SHARED IMEMO_FL_USER2
180#define CREF_FL_SINGLETON IMEMO_FL_USER3
181
182static inline int CREF_SINGLETON(const rb_cref_t *cref);
183
184static inline VALUE
185CREF_CLASS(const rb_cref_t *cref)
186{
187 if (CREF_SINGLETON(cref)) {
188 return CLASS_OF(cref->klass_or_self);
189 }
190 else {
191 return cref->klass_or_self;
192 }
193}
194
195static inline VALUE
196CREF_CLASS_FOR_DEFINITION(const rb_cref_t *cref)
197{
198 if (CREF_SINGLETON(cref)) {
199 return rb_singleton_class(cref->klass_or_self);
200 }
201 else {
202 return cref->klass_or_self;
203 }
204}
205
206static inline rb_cref_t *
207CREF_NEXT(const rb_cref_t *cref)
208{
209 return cref->next;
210}
211
212static inline const rb_scope_visibility_t *
213CREF_SCOPE_VISI(const rb_cref_t *cref)
214{
215 return &cref->scope_visi;
216}
217
218static inline VALUE
219CREF_REFINEMENTS(const rb_cref_t *cref)
220{
221 return cref->refinements;
222}
223
224static inline void
225CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
226{
227 RB_OBJ_WRITE(cref, &cref->refinements, refs);
228}
229
230static inline int
231CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
232{
233 return cref->flags & CREF_FL_PUSHED_BY_EVAL;
234}
235
236static inline void
237CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
238{
239 cref->flags |= CREF_FL_PUSHED_BY_EVAL;
240}
241
242static inline int
243CREF_SINGLETON(const rb_cref_t *cref)
244{
245 return cref->flags & CREF_FL_SINGLETON;
246}
247
248static inline void
249CREF_SINGLETON_SET(rb_cref_t *cref)
250{
251 cref->flags |= CREF_FL_SINGLETON;
252}
253
254static inline int
255CREF_OMOD_SHARED(const rb_cref_t *cref)
256{
257 return cref->flags & CREF_FL_OMOD_SHARED;
258}
259
260static inline void
261CREF_OMOD_SHARED_SET(rb_cref_t *cref)
262{
263 cref->flags |= CREF_FL_OMOD_SHARED;
264}
265
266static inline void
267CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
268{
269 cref->flags &= ~CREF_FL_OMOD_SHARED;
270}
271
272enum {
273 RAISED_EXCEPTION = 1,
274 RAISED_STACKOVERFLOW = 2,
275 RAISED_NOMEMORY = 4
276};
277#define rb_ec_raised_set(ec, f) ((ec)->raised_flag |= (f))
278#define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
279#define rb_ec_raised_p(ec, f) (((ec)->raised_flag & (f)) != 0)
280#define rb_ec_raised_clear(ec) ((ec)->raised_flag = 0)
281int rb_ec_set_raised(rb_execution_context_t *ec);
282int rb_ec_reset_raised(rb_execution_context_t *ec);
283int rb_ec_stack_check(rb_execution_context_t *ec);
284
285 VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
286 VALUE rb_make_exception(int argc, const VALUE *argv);
287
288NORETURN(void rb_method_name_error(VALUE, VALUE));
289
290NORETURN(void rb_fiber_start(rb_fiber_t*));
291
292NORETURN(void rb_print_undef(VALUE, ID, rb_method_visibility_t));
293NORETURN(void rb_print_undef_str(VALUE, VALUE));
294NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
295NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
296NORETURN(void rb_vm_jump_tag_but_local_jump(int));
297
298 VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
299 rb_cref_t *rb_vm_cref(void);
300 rb_cref_t *rb_vm_cref_replace_with_duplicated_cref(void);
301 VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename);
302void rb_vm_set_progname(VALUE filename);
303 VALUE rb_vm_cbase(void);
304
305/* vm_backtrace.c */
306 VALUE rb_ec_backtrace_object(const rb_execution_context_t *ec);
307 VALUE rb_ec_backtrace_str_ary(const rb_execution_context_t *ec, long lev, long n);
308 VALUE rb_ec_backtrace_location_ary(const rb_execution_context_t *ec, long lev, long n, bool skip_internal);
309
310#ifndef CharNext /* defined as CharNext[AW] on Windows. */
311# ifdef HAVE_MBLEN
312# define CharNext(p) rb_char_next(p)
313static inline char *
314rb_char_next(const char *p)
315{
316 if (p) {
317 int len = mblen(p, RUBY_MBCHAR_MAXSIZE);
318 p += len > 0 ? len : 1;
319 }
320 return (char *)p;
321}
322# else
323# define CharNext(p) ((p) + 1)
324# endif
325#endif
326
327#if defined DOSISH || defined __CYGWIN__
328static inline void
329translit_char(char *p, int from, int to)
330{
331 while (*p) {
332 if ((unsigned char)*p == from)
333 *p = to;
334 p = CharNext(p);
335 }
336}
337#endif
338
339#endif /* RUBY_EVAL_INTERN_H */
rb_singleton_class
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2241
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 rgengc.h:220
ruby.h
rb_cref_struct
CREF (Class REFerence)
Definition method.h:44
rb_execution_context_struct
Definition vm_core.h:899
rb_fiber_struct
Definition cont.c:258
rb_scope_visi_struct
Definition method.h:38
rb_vm_tag
Definition vm_core.h:859
rb_wasm_jmp_buf
Definition setjmp.h:17
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