rake-builder 0.0.19 → 0.7.0

data/examples/04_zlib/vendor/bundle/gems/binding_of_caller-0.6.8/ext/binding_of_caller/binding_of_caller.c

@@ -0,0 +1,224 @@
+/* (c) 2011 John Mair (banisterfiend), MIT license */
+
+#include <ruby.h>
+#include "vm_core.h"
+#include "gc.h"
+
+typedef enum { false, true } bool;
+
+static VALUE
+string2sym(const char * string)
+{
+  return ID2SYM(rb_intern(string));
+}
+
+static inline const rb_data_type_t *
+threadptr_data_type(void)
+{
+  static const rb_data_type_t *thread_data_type;
+  if (!thread_data_type) {
+    VALUE current_thread = rb_thread_current();
+    thread_data_type = RTYPEDDATA_TYPE(current_thread);
+  }
+  return thread_data_type;
+}
+
+#define ruby_thread_data_type *threadptr_data_type()
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+
+static size_t
+binding_memsize(const void *ptr)
+{
+  return ptr ? sizeof(rb_binding_t) : 0;
+}
+
+static void
+binding_free(void *ptr)
+{
+  rb_binding_t *bind;
+  RUBY_FREE_ENTER("binding");
+  if (ptr) {
+    bind = ptr;
+    ruby_xfree(ptr);
+  }
+  RUBY_FREE_LEAVE("binding");
+}
+
+static void
+binding_mark(void *ptr)
+{
+  rb_binding_t *bind;
+  RUBY_MARK_ENTER("binding");
+  if (ptr) {
+    bind = ptr;
+    RUBY_MARK_UNLESS_NULL(bind->env);
+
+#ifdef RUBY_192
+    RUBY_MARK_UNLESS_NULL(bind->filename);
+#endif
+
+  }
+  RUBY_MARK_LEAVE("binding");
+}
+
+static const rb_data_type_t binding_data_type = {
+  "binding",
+  binding_mark,
+  binding_free,
+  binding_memsize,
+};
+
+static VALUE
+binding_alloc(VALUE klass)
+{
+  VALUE obj;
+  rb_binding_t *bind;
+  obj = TypedData_Make_Struct(klass, rb_binding_t, &binding_data_type, bind);
+  return obj;
+}
+
+static bool ifunc_p(rb_control_frame_t * cfp) {
+  return (cfp->flag & VM_FRAME_MAGIC_MASK) == VM_FRAME_MAGIC_IFUNC;
+}
+
+static bool valid_frame_p(rb_control_frame_t * cfp, rb_control_frame_t * limit_cfp) {
+  return cfp->iseq && !ifunc_p(cfp) && !NIL_P(cfp->self);
+}
+
+static rb_control_frame_t * find_valid_frame(rb_control_frame_t * cfp, rb_control_frame_t * limit_cfp) {
+  while (cfp < limit_cfp) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      return NULL;
+
+    if (valid_frame_p(cfp, limit_cfp))
+      return cfp;
+  }
+
+  // beyond end of stack
+  return NULL;
+}
+
+static VALUE
+frametype_name(VALUE flag)
+{
+  switch (flag & VM_FRAME_MAGIC_MASK) {
+  case VM_FRAME_MAGIC_METHOD: return string2sym("method");
+  case VM_FRAME_MAGIC_BLOCK:  return string2sym("block");
+  case VM_FRAME_MAGIC_CLASS:  return string2sym("class");
+  case VM_FRAME_MAGIC_TOP:    return string2sym("top");
+  case VM_FRAME_MAGIC_FINISH: return string2sym("finish");
+  case VM_FRAME_MAGIC_CFUNC:  return string2sym("cfunc");
+  case VM_FRAME_MAGIC_PROC:   return string2sym("proc");
+  case VM_FRAME_MAGIC_IFUNC:  return string2sym("ifunc");
+  case VM_FRAME_MAGIC_EVAL:   return string2sym("eval");
+  case VM_FRAME_MAGIC_LAMBDA: return string2sym("lambda");
+  default:
+    rb_raise(rb_eRuntimeError, "Unknown frame type! got flag: %d", FIX2INT(flag));
+  }
+}
+
+static VALUE binding_of_caller(VALUE self, VALUE rb_level)
+{
+  rb_thread_t *th;
+  GetThreadPtr(rb_thread_current(), th);
+
+  rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+  rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
+  int level = FIX2INT(rb_level);
+
+  // attempt to locate the nth parent control frame
+  for (int i = 0; i < level; i++) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      rb_raise(rb_eRuntimeError, "Invalid frame, gone beyond end of stack!");
+
+    // skip invalid frames
+    if (!valid_frame_p(cfp, limit_cfp))
+      cfp = find_valid_frame(cfp, limit_cfp);
+  }
+
+  VALUE bindval = binding_alloc(rb_cBinding);
+  rb_binding_t *bind;
+
+  if (cfp == 0)
+    rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
+
+  GetBindingPtr(bindval, bind);
+  bind->env = rb_vm_make_env_object(th, cfp);
+  bind->filename = cfp->iseq->filename;
+  bind->line_no = rb_vm_get_sourceline(cfp);
+
+  rb_iv_set(bindval, "@frame_type", frametype_name(cfp->flag));
+  rb_iv_set(bindval, "@frame_description", cfp->iseq->name);
+
+  return bindval;
+}
+
+static VALUE
+frame_type(VALUE self)
+{
+  return rb_iv_get(self, "@frame_type");
+}
+
+static VALUE
+frame_description(VALUE self)
+{
+  return rb_iv_get(self, "@frame_description");
+}
+
+static VALUE frame_count(VALUE self)
+{
+  rb_thread_t *th;
+  GetThreadPtr(rb_thread_current(), th);
+
+  rb_control_frame_t *cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+  rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
+
+  int i = 1;
+  while (cfp < limit_cfp) {
+    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+    if (cfp >= limit_cfp)
+      return INT2FIX(i);
+
+    // skip invalid frames
+    if (!valid_frame_p(cfp, limit_cfp))
+      cfp = find_valid_frame(cfp, limit_cfp);
+
+    if (!cfp)
+      break;
+
+    i++;
+  }
+
+  return INT2FIX(i);
+}
+
+static VALUE
+callers(VALUE self)
+{
+  VALUE ary = rb_ary_new();
+
+  for (int i = 0; i < FIX2INT(frame_count(self)); i++)
+    rb_ary_push(ary, binding_of_caller(self, INT2FIX(i)));
+
+  return ary;
+}
+
+void
+Init_binding_of_caller()
+{
+  VALUE mBindingOfCaller = rb_define_module("BindingOfCaller");
+
+  rb_define_method(mBindingOfCaller, "of_caller", binding_of_caller, 1);
+  rb_define_method(mBindingOfCaller, "frame_count", frame_count, 0);
+  rb_define_method(mBindingOfCaller, "frame_type", frame_type, 0);
+  rb_define_method(mBindingOfCaller, "frame_description", frame_description, 0);
+  rb_define_method(mBindingOfCaller, "callers", callers, 0);
+  rb_include_module(rb_cBinding, mBindingOfCaller);
+}
+

data/examples/04_zlib/vendor/bundle/gems/binding_of_caller-0.6.8/ext/binding_of_caller/ruby_headers/192/debug.h

@@ -0,0 +1,36 @@
+/**********************************************************************
+
+  debug.h - YARV Debug function interface
+
+  $Author$
+  created at: 04/08/25 02:33:49 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_DEBUG_H
+#define RUBY_DEBUG_H
+
+#include "ruby/ruby.h"
+#include "node.h"
+
+#define dpv(h,v) ruby_debug_print_value(-1, 0, h, v)
+#define dp(v)    ruby_debug_print_value(-1, 0, "", v)
+#define dpi(i)   ruby_debug_print_id(-1, 0, "", i)
+#define dpn(n)   ruby_debug_print_node(-1, 0, "", n)
+
+#define bp()     ruby_debug_breakpoint()
+
+VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);
+ID    ruby_debug_print_id(int level, int debug_level, const char *header, ID id);
+NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);
+int   ruby_debug_print_indent(int level, int debug_level, int indent_level);
+void  ruby_debug_breakpoint(void);
+void  ruby_debug_gc_check_func(void);
+
+#ifdef RUBY_DEBUG_ENV
+void ruby_set_debug_option(const char *str);
+#endif
+
+#endif /* RUBY_DEBUG_H */

data/examples/04_zlib/vendor/bundle/gems/binding_of_caller-0.6.8/ext/binding_of_caller/ruby_headers/192/dln.h

@@ -0,0 +1,41 @@
+/**********************************************************************
+
+  dln.h -
+
+  $Author$
+  created at: Wed Jan 19 16:53:09 JST 1994
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef DLN_H
+#define DLN_H
+
+#ifdef __cplusplus
+# ifndef  HAVE_PROTOTYPES
+#  define HAVE_PROTOTYPES 1
+# endif
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+
+#undef _
+#ifdef HAVE_PROTOTYPES
+# define _(args) args
+#else
+# define _(args) ()
+#endif
+
+DEPRECATED(char *dln_find_exe(const char*,const char*));
+DEPRECATED(char *dln_find_file(const char*,const char*));
+char *dln_find_exe_r(const char*,const char*,char*,size_t);
+char *dln_find_file_r(const char*,const char*,char*,size_t);
+
+#ifdef USE_DLN_A_OUT
+extern char *dln_argv0;
+#endif
+
+void *dln_load(const char*);
+#endif

data/examples/04_zlib/vendor/bundle/gems/binding_of_caller-0.6.8/ext/binding_of_caller/ruby_headers/192/eval_intern.h

@@ -0,0 +1,232 @@
+#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)rb_node_newnode(NODE_LIT, (VALUE)(val), (VALUE)(pt), (VALUE)(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_threadptr_set_raised(rb_thread_t *th);
+int rb_threadptr_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_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename, VALUE filepath);
+void rb_vm_set_progname(VALUE filename);
+void rb_thread_terminate_all(void);
+VALUE rb_vm_top_self();
+VALUE rb_vm_cbase(void);
+int rb_vm_get_sourceline(const rb_control_frame_t *);
+void rb_trap_restore_mask(void);
+
+#ifndef CharNext		/* defined as CharNext[AW] on Windows. */
+#define CharNext(p) ((p) + mblen(p, RUBY_MBCHAR_MAXSIZE))
+#endif
+
+#if defined DOSISH || defined __CYGWIN__
+static inline void
+translit_char(char *p, int from, int to)
+{
+    while (*p) {
+	if ((unsigned char)*p == from)
+	    *p = to;
+	p = CharNext(p);
+    }
+}
+#endif
+
+#endif /* RUBY_EVAL_INTERN_H */

data/examples/04_zlib/vendor/bundle/gems/binding_of_caller-0.6.8/ext/binding_of_caller/ruby_headers/192/gc.h

@@ -0,0 +1,77 @@
+
+#ifndef RUBY_GC_H
+#define RUBY_GC_H 1
+
+#if defined(__x86_64__) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__("movq\t%%rsp, %0" : "=r" (*p))
+#elif defined(__i386) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__("movl\t%%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(const char *mode, const 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(volatile 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 */