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
   7 static inline void
   8 vm_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
  14 static inline void
  15 pass_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 #include <setjmp.h>
  37
  38 #ifdef __APPLE__
  39 # ifdef HAVE_CRT_EXTERNS_H
  40 #  include <crt_externs.h>
  41 # else
  42 #  include "missing/crt_externs.h"
  43 # endif
  44 #endif
  45
  46 #ifndef HAVE_STRING_H
  47 char *strrchr(const char *, const char);
  48 #endif
  49
  50 #ifdef HAVE_UNISTD_H
  51 #include <unistd.h>
  52 #endif
  53
  54 #ifdef HAVE_NET_SOCKET_H
  55 #include <net/socket.h>
  56 #endif
  57
  58 #define ruby_setjmp(env) RUBY_SETJMP(env)
  59 #define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
  60 #ifdef __CYGWIN__
  61 # ifndef _setjmp
  62 int _setjmp(jmp_buf);
  63 # endif
  64 # ifndef _longjmp
  65 NORETURN(void _longjmp(jmp_buf, int));
  66 # endif
  67 #endif
  68
  69 #include <sys/types.h>
  70 #include <signal.h>
  71 #include <errno.h>
  72
  73 #ifdef HAVE_SYS_SELECT_H
  74 #include <sys/select.h>
  75 #endif
  76
  77 /*
  78   Solaris sys/select.h switches select to select_large_fdset to support larger
  79   file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
  80   But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
  81   So following definition is required to use select_large_fdset.
  82 */
  83 #ifdef HAVE_SELECT_LARGE_FDSET
  84 #define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
  85 extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval *);
  86 #endif
  87
  88 #ifdef HAVE_SYS_PARAM_H
  89 #include <sys/param.h>
  90 #endif
  91
  92 #include <sys/stat.h>
  93
  94
  95 #define SAVE_ROOT_JMPBUF(th, stmt) do \
  96   if (true) { \
  97       stmt; \
  98   } \
  99   else if (th) { /* suppress unused-variable warning */ \
 100   } while (0)
 101
 102 #define EC_PUSH_TAG(ec) do { \
 103   rb_execution_context_t * const _ec = (ec); \
 104   struct rb_vm_tag _tag; \
 105   _tag.state = TAG_NONE; \
 106   _tag.tag = Qundef; \
 107   _tag.prev = _ec->tag; \
 108   _tag.lock_rec = rb_ec_vm_lock_rec(_ec); \
 109
 110 #define EC_POP_TAG() \
 111   _ec->tag = _tag.prev; \
 112 } while (0)
 113
 114 #define EC_TMPPOP_TAG() \
 115   _ec->tag = _tag.prev
 116
 117 #define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
 118
 119 #if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || defined __clang__
 120 /* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
 121  * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
 122  * (I confirmed Clang 4.0.1 and 5.0.0.)
 123  */
 124 # define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
 125 # define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
 126 # define VAR_NOCLOBBERED(var) volatile var
 127 #else
 128 # define VAR_FROM_MEMORY(var) (var)
 129 # define VAR_INITIALIZED(var) ((void)&(var))
 130 # define VAR_NOCLOBBERED(var) var
 131 #endif
 132
 133 static inline void
 134 rb_ec_vm_lock_rec_check(const rb_execution_context_t *ec, unsigned int recorded_lock_rec)
 135 {
 136     unsigned int current_lock_rec = rb_ec_vm_lock_rec(ec);
 137     if (current_lock_rec != recorded_lock_rec) {
 138         rb_ec_vm_lock_rec_release(ec, recorded_lock_rec, current_lock_rec);
 139     }
 140 }
 141
 142 /* clear ec->tag->state, and return the value */
 143 static inline int
 144 rb_ec_tag_state(const rb_execution_context_t *ec)
 145 {
 146     struct rb_vm_tag *tag = ec->tag;
 147     enum ruby_tag_type state = tag->state;
 148     tag->state = TAG_NONE;
 149     rb_ec_vm_lock_rec_check(ec, tag->lock_rec);
 150     return state;
 151 }
 152
 153 NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
 154 static inline void
 155 rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
 156 {
 157     ec->tag->state = st;
 158     ruby_longjmp(ec->tag->buf, 1);
 159 }
 160
 161 /*
 162   setjmp() in assignment expression rhs is undefined behavior
 163   [ISO/IEC 9899:1999] 7.13.1.1
 164 */
 165 #define EC_EXEC_TAG() \
 166     (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
 167
 168 #define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
 169
 170 #define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
 171
 172 /* CREF operators */
 173
 174 #define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
 175 #define CREF_FL_OMOD_SHARED    IMEMO_FL_USER2
 176 #define CREF_FL_SINGLETON      IMEMO_FL_USER3
 177
 178 static inline int CREF_SINGLETON(const rb_cref_t *cref);
 179
 180 static inline VALUE
 181 CREF_CLASS(const rb_cref_t *cref)
 182 {
 183     if (CREF_SINGLETON(cref)) {
 184         return CLASS_OF(cref->klass_or_self);
 185     }
 186     else {
 187         return cref->klass_or_self;
 188     }
 189 }
 190
 191 static inline VALUE
 192 CREF_CLASS_FOR_DEFINITION(const rb_cref_t *cref)
 193 {
 194     if (CREF_SINGLETON(cref)) {
 195         return rb_singleton_class(cref->klass_or_self);
 196     }
 197     else {
 198         return cref->klass_or_self;
 199     }
 200 }
 201
 202 static inline rb_cref_t *
 203 CREF_NEXT(const rb_cref_t *cref)
 204 {
 205     return cref->next;
 206 }
 207
 208 static inline const rb_scope_visibility_t *
 209 CREF_SCOPE_VISI(const rb_cref_t *cref)
 210 {
 211     return &cref->scope_visi;
 212 }
 213
 214 static inline VALUE
 215 CREF_REFINEMENTS(const rb_cref_t *cref)
 216 {
 217     return cref->refinements;
 218 }
 219
 220 static inline void
 221 CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
 222 {
 223     RB_OBJ_WRITE(cref, &cref->refinements, refs);
 224 }
 225
 226 static inline int
 227 CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
 228 {
 229     return cref->flags & CREF_FL_PUSHED_BY_EVAL;
 230 }
 231
 232 static inline void
 233 CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
 234 {
 235     cref->flags |= CREF_FL_PUSHED_BY_EVAL;
 236 }
 237
 238 static inline int
 239 CREF_SINGLETON(const rb_cref_t *cref)
 240 {
 241     return cref->flags & CREF_FL_SINGLETON;
 242 }
 243
 244 static inline void
 245 CREF_SINGLETON_SET(rb_cref_t *cref)
 246 {
 247     cref->flags |= CREF_FL_SINGLETON;
 248 }
 249
 250 static inline int
 251 CREF_OMOD_SHARED(const rb_cref_t *cref)
 252 {
 253     return cref->flags & CREF_FL_OMOD_SHARED;
 254 }
 255
 256 static inline void
 257 CREF_OMOD_SHARED_SET(rb_cref_t *cref)
 258 {
 259     cref->flags |= CREF_FL_OMOD_SHARED;
 260 }
 261
 262 static inline void
 263 CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
 264 {
 265     cref->flags &= ~CREF_FL_OMOD_SHARED;
 266 }
 267
 268 enum {
 269     RAISED_EXCEPTION = 1,
 270     RAISED_STACKOVERFLOW = 2,
 271     RAISED_NOMEMORY = 4
 272 };
 273 #define rb_ec_raised_set(ec, f)   ((ec)->raised_flag |= (f))
 274 #define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
 275 #define rb_ec_raised_p(ec, f)    (((ec)->raised_flag & (f)) != 0)
 276 #define rb_ec_raised_clear(ec)    ((ec)->raised_flag = 0)
 277 int rb_ec_set_raised(rb_execution_context_t *ec);
 278 int rb_ec_reset_raised(rb_execution_context_t *ec);
 279 int rb_ec_stack_check(rb_execution_context_t *ec);
 280
 281 VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
 282 VALUE rb_make_exception(int argc, const VALUE *argv);
 283
 284 NORETURN(void rb_method_name_error(VALUE, VALUE));
 285
 286 void rb_fiber_start(rb_fiber_t*);
 287
 288 NORETURN(void rb_print_undef(VALUE, ID, rb_method_visibility_t));
 289 NORETURN(void rb_print_undef_str(VALUE, VALUE));
 290 NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
 291 NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
 292 NORETURN(void rb_vm_jump_tag_but_local_jump(int));
 293
 294 VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
 295 rb_cref_t *rb_vm_cref(void);
 296 rb_cref_t *rb_vm_cref_replace_with_duplicated_cref(void);
 297 VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename);
 298 void rb_vm_set_progname(VALUE filename);
 299 VALUE rb_vm_cbase(void);
 300
 301 /* vm_backtrace.c */
 302 VALUE rb_ec_backtrace_object(const rb_execution_context_t *ec);
 303 VALUE rb_ec_backtrace_str_ary(const rb_execution_context_t *ec, long lev, long n);
 304 VALUE rb_ec_backtrace_location_ary(const rb_execution_context_t *ec, long lev, long n, bool skip_internal);
 305
 306 #ifndef CharNext                /* defined as CharNext[AW] on Windows. */
 307 # ifdef HAVE_MBLEN
 308 #  define CharNext(p) rb_char_next(p)
 309 static inline char *
 310 rb_char_next(const char *p)
 311 {
 312     if (p) {
 313         int len = mblen(p, RUBY_MBCHAR_MAXSIZE);
 314         p += len > 0 ? len : 1;
 315     }
 316     return (char *)p;
 317 }
 318 # else
 319 #  define CharNext(p) ((p) + 1)
 320 # endif
 321 #endif
 322
 323 #if defined DOSISH || defined __CYGWIN__
 324 static inline void
 325 translit_char(char *p, int from, int to)
 326 {
 327     while (*p) {
 328         if ((unsigned char)*p == from)
 329             *p = to;
 330         p = CharNext(p);
 331     }
 332 }
 333 #endif
 334
 335 #endif /* RUBY_EVAL_INTERN_H */