better_caller 0.0.1

data/ext/eval_intern.h

@@ -0,0 +1,215 @@
+#ifndef RUBY_EVAL_INTERN_H
+#define RUBY_EVAL_INTERN_H
+
+#include "ruby/ruby.h"
+#include "vm_core.h"
+
+#define PASS_PASSED_BLOCK_TH(th) do { \
+    (th)->passed_block = GC_GUARDED_PTR_REF((rb_block_t *)(th)->cfp->lfp[0]); \
+    (th)->cfp->flag |= VM_FRAME_FLAG_PASSED; \
+} while (0)
+
+#define PASS_PASSED_BLOCK() do { \
+    rb_thread_t * const __th__ = GET_THREAD(); \
+    PASS_PASSED_BLOCK_TH(__th__); \
+} while (0)
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+#include <stdio.h>
+#include <setjmp.h>
+
+#ifdef __APPLE__
+#include <crt_externs.h>
+#endif
+
+/* Make alloca work the best possible way.  */
+#ifdef __GNUC__
+# ifndef atarist
+#  ifndef alloca
+#   define alloca __builtin_alloca
+#  endif
+# endif	/* atarist */
+#else
+# ifdef HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+#pragma alloca
+#  else
+#   ifndef alloca		/* predefined by HP cc +Olibcalls */
+void *alloca();
+#   endif
+#  endif /* AIX */
+# endif	/* HAVE_ALLOCA_H */
+#endif /* __GNUC__ */
+
+#ifndef HAVE_STRING_H
+char *strrchr(const char *, const char);
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_NET_SOCKET_H
+#include <net/socket.h>
+#endif
+
+#define ruby_setjmp(env) RUBY_SETJMP(env)
+#define ruby_longjmp(env,val) RUBY_LONGJMP(env,val)
+#ifdef __CYGWIN__
+# ifndef _setjmp
+int _setjmp(jmp_buf);
+# endif
+# ifndef _longjmp
+NORETURN(void _longjmp(jmp_buf, int));
+# endif
+#endif
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+/*
+  Solaris sys/select.h switches select to select_large_fdset to support larger
+  file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
+  But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
+  So following definition is required to use select_large_fdset.
+*/
+#ifdef HAVE_SELECT_LARGE_FDSET
+#define select(n, r, w, e, t) select_large_fdset(n, r, w, e, t)
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#include <sys/stat.h>
+
+#define SAVE_ROOT_JMPBUF(th, stmt) do \
+  if (ruby_setjmp((th)->root_jmpbuf) == 0) { \
+      stmt; \
+  } \
+  else { \
+      rb_fiber_start(); \
+  } while (0)
+
+#define TH_PUSH_TAG(th) do { \
+  rb_thread_t * const _th = th; \
+  struct rb_vm_tag _tag; \
+  _tag.tag = 0; \
+  _tag.prev = _th->tag; \
+  _th->tag = &_tag;
+
+#define TH_POP_TAG() \
+  _th->tag = _tag.prev; \
+} while (0)
+
+#define TH_POP_TAG2() \
+  _th->tag = _tag.prev
+
+#define PUSH_TAG() TH_PUSH_TAG(GET_THREAD())
+#define POP_TAG()      TH_POP_TAG()
+
+#define TH_EXEC_TAG() ruby_setjmp(_th->tag->buf)
+
+#define EXEC_TAG() \
+  TH_EXEC_TAG()
+
+#define TH_JUMP_TAG(th, st) do { \
+  ruby_longjmp(th->tag->buf,(st)); \
+} while (0)
+
+#define JUMP_TAG(st) TH_JUMP_TAG(GET_THREAD(), st)
+
+enum ruby_tag_type {
+    RUBY_TAG_RETURN	= 0x1,
+    RUBY_TAG_BREAK	= 0x2,
+    RUBY_TAG_NEXT	= 0x3,
+    RUBY_TAG_RETRY	= 0x4,
+    RUBY_TAG_REDO	= 0x5,
+    RUBY_TAG_RAISE	= 0x6,
+    RUBY_TAG_THROW	= 0x7,
+    RUBY_TAG_FATAL	= 0x8,
+    RUBY_TAG_MASK	= 0xf
+};
+#define TAG_RETURN	RUBY_TAG_RETURN
+#define TAG_BREAK	RUBY_TAG_BREAK
+#define TAG_NEXT	RUBY_TAG_NEXT
+#define TAG_RETRY	RUBY_TAG_RETRY
+#define TAG_REDO	RUBY_TAG_REDO
+#define TAG_RAISE	RUBY_TAG_RAISE
+#define TAG_THROW	RUBY_TAG_THROW
+#define TAG_FATAL	RUBY_TAG_FATAL
+#define TAG_MASK	RUBY_TAG_MASK
+
+#define NEW_THROW_OBJECT(val, pt, st) \
+  ((VALUE)NEW_NODE(NODE_LIT, (val), (pt), (st)))
+#define SET_THROWOBJ_CATCH_POINT(obj, val) \
+  (RNODE((obj))->u2.value = (val))
+#define SET_THROWOBJ_STATE(obj, val) \
+  (RNODE((obj))->u3.value = (val))
+
+#define GET_THROWOBJ_VAL(obj)         ((VALUE)RNODE((obj))->u1.value)
+#define GET_THROWOBJ_CATCH_POINT(obj) ((VALUE*)RNODE((obj))->u2.value)
+#define GET_THROWOBJ_STATE(obj)       ((int)RNODE((obj))->u3.value)
+
+#define SCOPE_TEST(f)  (rb_vm_cref()->nd_visi & (f))
+#define SCOPE_CHECK(f) (rb_vm_cref()->nd_visi == (f))
+#define SCOPE_SET(f)   (rb_vm_cref()->nd_visi = (f))
+
+#define CHECK_STACK_OVERFLOW(cfp, margin) do \
+  if (((VALUE *)(cfp)->sp) + (margin) + sizeof(rb_control_frame_t) >= ((VALUE *)cfp)) { \
+      rb_exc_raise(sysstack_error); \
+  } \
+while (0)
+
+void rb_thread_cleanup(void);
+void rb_thread_wait_other_threads(void);
+
+enum {
+    RAISED_EXCEPTION = 1,
+    RAISED_STACKOVERFLOW = 2,
+    RAISED_NOMEMORY = 4
+};
+int rb_thread_set_raised(rb_thread_t *th);
+int rb_thread_reset_raised(rb_thread_t *th);
+#define rb_thread_raised_set(th, f)   ((th)->raised_flag |= (f))
+#define rb_thread_raised_reset(th, f) ((th)->raised_flag &= ~(f))
+#define rb_thread_raised_p(th, f)     (((th)->raised_flag & (f)) != 0)
+#define rb_thread_raised_clear(th)    ((th)->raised_flag = 0)
+
+VALUE rb_f_eval(int argc, VALUE *argv, VALUE self);
+VALUE rb_make_exception(int argc, VALUE *argv);
+
+NORETURN(void rb_fiber_start(void));
+
+NORETURN(void rb_print_undef(VALUE, ID, int));
+NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
+NORETURN(void rb_vm_jump_tag_but_local_jump(int, VALUE));
+NORETURN(void rb_raise_method_missing(rb_thread_t *th, int argc, VALUE *argv,
+				      VALUE obj, int call_status));
+
+VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
+NODE *rb_vm_cref(void);
+VALUE rb_obj_is_proc(VALUE);
+VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename);
+void rb_thread_terminate_all(void);
+VALUE rb_vm_top_self();
+VALUE rb_vm_cbase(void);
+void rb_trap_restore_mask(void);
+
+#endif /* RUBY_EVAL_INTERN_H */

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile 'better_caller'

data/ext/gc.h

@@ -0,0 +1,75 @@
+
+#ifndef RUBY_GC_H
+#define RUBY_GC_H 1
+
+#if defined(__i386) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__("mov %%esp, %0" : "=r" (*p))
+#else
+NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
+#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
+#define USE_CONSERVATIVE_STACK_END
+#endif
+
+/* for GC debug */
+
+#ifndef RUBY_MARK_FREE_DEBUG
+#define RUBY_MARK_FREE_DEBUG 0
+#endif
+
+#if RUBY_MARK_FREE_DEBUG
+extern int ruby_gc_debug_indent;
+
+static void
+rb_gc_debug_indent(void)
+{
+    printf("%*s", ruby_gc_debug_indent, "");
+}
+
+static void
+rb_gc_debug_body(char *mode, char *msg, int st, void *ptr)
+{
+    if (st == 0) {
+	ruby_gc_debug_indent--;
+    }
+    rb_gc_debug_indent();
+    printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
+
+    if (st) {
+	ruby_gc_debug_indent++;
+    }
+
+    fflush(stdout);
+}
+
+#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", msg, 1, ptr)
+#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", msg, 0, ptr)
+#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", msg, 1, ptr)
+#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", msg, 0, ptr)
+#define RUBY_GC_INFO         rb_gc_debug_indent(); printf
+
+#else
+#define RUBY_MARK_ENTER(msg)
+#define RUBY_MARK_LEAVE(msg)
+#define RUBY_FREE_ENTER(msg)
+#define RUBY_FREE_LEAVE(msg)
+#define RUBY_GC_INFO if(0)printf
+#endif
+
+#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
+#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);}
+
+#if STACK_GROW_DIRECTION > 0
+# define STACK_UPPER(x, a, b) a
+#elif STACK_GROW_DIRECTION < 0
+# define STACK_UPPER(x, a, b) b
+#else
+RUBY_EXTERN int ruby_stack_grow_direction;
+int ruby_get_stack_grow_direction(VALUE *addr);
+# define stack_growup_p(x) (			\
+	(ruby_stack_grow_direction ?		\
+	 ruby_stack_grow_direction :		\
+	 ruby_get_stack_grow_direction(x)) > 0)
+# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? a : b)
+#endif
+
+#endif /* RUBY_GC_H */

data/ext/id.h

@@ -0,0 +1,163 @@
+/* DO NOT EDIT THIS FILE DIRECTLY */
+/**********************************************************************
+
+  id.h - 
+
+  $Author: nobu $
+  created at: Sun Oct 19 21:12:51 2008
+
+  Copyright (C) 2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_ID_H
+#define RUBY_ID_H
+
+#define ID_SCOPE_SHIFT 3
+#define ID_SCOPE_MASK 0x07
+#define ID_LOCAL      0x00
+#define ID_INSTANCE   0x01
+#define ID_GLOBAL     0x03
+#define ID_ATTRSET    0x04
+#define ID_CONST      0x05
+#define ID_CLASS      0x06
+#define ID_JUNK       0x07
+#define ID_INTERNAL   ID_JUNK
+
+#ifdef USE_PARSE_H
+#include "parse.h"
+#endif
+
+#define symIFUNC ID2SYM(idIFUNC)
+#define symCFUNC ID2SYM(idCFUNC)
+
+#if !defined tLAST_TOKEN && defined YYTOKENTYPE
+#define tLAST_TOKEN tLAST_TOKEN
+#endif
+
+enum ruby_method_ids {
+#ifndef tLAST_TOKEN
+    tUPLUS = 321,
+    tUMINUS = 322,
+    tPOW = 323,
+    tCMP = 324,
+    tEQ = 325,
+    tEQQ = 326,
+    tNEQ = 327,
+    tGEQ = 328,
+    tLEQ = 329,
+    tANDOP = 330,
+    tOROP = 331,
+    tMATCH = 332,
+    tNMATCH = 333,
+    tDOT2 = 334,
+    tDOT3 = 335,
+    tAREF = 336,
+    tASET = 337,
+    tLSHFT = 338,
+    tRSHFT = 339,
+    tLAMBDA = 352,
+    idNULL = 365,
+    idRespond_to = 366,
+    idIFUNC = 367,
+    idCFUNC = 368,
+    idThrowState = 369,
+    id_core_set_method_alias = 370,
+    id_core_set_variable_alias = 371,
+    id_core_undef_method = 372,
+    id_core_define_method = 373,
+    id_core_define_singleton_method = 374,
+    id_core_set_postexe = 375,
+    tLAST_TOKEN = 376,
+#endif
+    idPLUS = '+',
+    idMINUS = '-',
+    idMULT = '*',
+    idDIV = '/',
+    idMOD = '%',
+    idLT = '<',
+    idLTLT = tLSHFT,
+    idLE = tLEQ,
+    idGT = '>',
+    idGE = tGEQ,
+    idEq = tEQ,
+    idEqq = tEQQ,
+    idNeq = tNEQ,
+    idNot = '!',
+    idBackquote = '`',
+    idEqTilde = tMATCH,
+    idAREF = tAREF,
+    idASET = tASET,
+    idLAST_TOKEN = tLAST_TOKEN >> ID_SCOPE_SHIFT,
+    tIntern,
+    tMethodMissing,
+    tLength,
+    tGets,
+    tSucc,
+    tEach,
+    tLambda,
+    tSend,
+    t__send__,
+    tInitialize,
+#if SUPPORT_JOKE
+    tBitblt,
+    tAnswer,
+#endif
+    tLAST_ID,
+#define TOKEN2ID(n) id##n = ((t##n<<ID_SCOPE_SHIFT)|ID_LOCAL)
+#if SUPPORT_JOKE
+    TOKEN2ID(Bitblt),
+    TOKEN2ID(Answer),
+#endif
+    TOKEN2ID(Intern),
+    TOKEN2ID(MethodMissing),
+    TOKEN2ID(Length),
+    TOKEN2ID(Gets),
+    TOKEN2ID(Succ),
+    TOKEN2ID(Each),
+    TOKEN2ID(Lambda),
+    TOKEN2ID(Send),
+    TOKEN2ID(__send__),
+    TOKEN2ID(Initialize)
+};
+
+#ifdef tLAST_TOKEN
+struct ruby_method_ids_check {
+#define ruby_method_id_check_for(name, value) \
+    int checking_for_##name[name == value ? 1 : -1]
+ruby_method_id_check_for(tUPLUS, 321);
+ruby_method_id_check_for(tUMINUS, 322);
+ruby_method_id_check_for(tPOW, 323);
+ruby_method_id_check_for(tCMP, 324);
+ruby_method_id_check_for(tEQ, 325);
+ruby_method_id_check_for(tEQQ, 326);
+ruby_method_id_check_for(tNEQ, 327);
+ruby_method_id_check_for(tGEQ, 328);
+ruby_method_id_check_for(tLEQ, 329);
+ruby_method_id_check_for(tANDOP, 330);
+ruby_method_id_check_for(tOROP, 331);
+ruby_method_id_check_for(tMATCH, 332);
+ruby_method_id_check_for(tNMATCH, 333);
+ruby_method_id_check_for(tDOT2, 334);
+ruby_method_id_check_for(tDOT3, 335);
+ruby_method_id_check_for(tAREF, 336);
+ruby_method_id_check_for(tASET, 337);
+ruby_method_id_check_for(tLSHFT, 338);
+ruby_method_id_check_for(tRSHFT, 339);
+ruby_method_id_check_for(tLAMBDA, 352);
+ruby_method_id_check_for(idNULL, 365);
+ruby_method_id_check_for(idRespond_to, 366);
+ruby_method_id_check_for(idIFUNC, 367);
+ruby_method_id_check_for(idCFUNC, 368);
+ruby_method_id_check_for(idThrowState, 369);
+ruby_method_id_check_for(id_core_set_method_alias, 370);
+ruby_method_id_check_for(id_core_set_variable_alias, 371);
+ruby_method_id_check_for(id_core_undef_method, 372);
+ruby_method_id_check_for(id_core_define_method, 373);
+ruby_method_id_check_for(id_core_define_singleton_method, 374);
+ruby_method_id_check_for(id_core_set_postexe, 375);
+ruby_method_id_check_for(tLAST_TOKEN, 376);
+};
+#endif
+
+#endif /* RUBY_ID_H */