byebug 0.0.1

data/ext/byebug/byebug.h

@@ -0,0 +1,131 @@
+#ifndef RUBY_DEBUG
+#define RUBY_DEBUG
+
+#include <ruby.h>
+#include <ruby/debug.h>
+
+typedef struct rb_trace_arg_struct rb_trace_point_t;
+
+/* Byebug::Context */
+
+/* flags */
+#define CTX_FL_SUSPEND      (1<<1)
+#define CTX_FL_TRACING      (1<<2)
+#define CTX_FL_SKIPPED      (1<<3)
+#define CTX_FL_IGNORE       (1<<4)
+#define CTX_FL_DEAD         (1<<5)
+#define CTX_FL_WAS_RUNNING  (1<<6)
+#define CTX_FL_ENABLE_BKPT  (1<<7)
+#define CTX_FL_STEPPED      (1<<8)
+#define CTX_FL_FORCE_MOVE   (1<<9)
+#define CTX_FL_CATCHING     (1<<10)
+
+/* macro functions */
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+
+#define IS_THREAD_ALIVE(t) (rb_funcall((t), idAlive, 0) == Qtrue)
+
+/* types */
+typedef enum {
+  CTX_STOP_NONE,
+  CTX_STOP_STEP,
+  CTX_STOP_BREAKPOINT,
+  CTX_STOP_CATCHPOINT
+} ctx_stop_reason;
+
+typedef struct debug_frame_t {
+    struct debug_frame_t *prev;
+    char *file;
+    int line;
+    VALUE method_id;
+    VALUE defined_class;
+    VALUE binding;
+    VALUE self;
+} debug_frame_t;
+
+typedef struct {
+  debug_frame_t *stack;
+  int stack_size;
+
+  VALUE thread;
+  int thnum;
+  int flags;
+
+  ctx_stop_reason stop_reason;
+  int stop_next;
+  int dest_frame;
+  int stop_line;
+  int stop_frame;
+
+  char *last_file;
+  int last_line;
+} debug_context_t;
+
+/* functions */
+extern VALUE Init_context(VALUE mByebug);
+extern VALUE context_create(VALUE thread, VALUE cDebugThread);
+extern void reset_stepping_stop_points(debug_context_t *context);
+extern VALUE Context_ignored(VALUE self);
+
+extern void push_frame(VALUE context_object, char* file, int lineno,
+                       VALUE method_id, VALUE defined_class, VALUE binding,
+                       VALUE self);
+
+extern void pop_frame(VALUE context_object);
+
+extern void update_frame(VALUE context_object, char* file, int lineno,
+                         VALUE method_id, VALUE defined_class, VALUE binding,
+                         VALUE self);
+
+
+/* locked threads container */
+typedef struct locked_thread_t {
+  VALUE thread;
+  struct locked_thread_t *next;
+} locked_thread_t;
+
+extern int is_in_locked(VALUE thread_id);
+extern void add_to_locked(VALUE thread);
+extern VALUE remove_from_locked();
+
+/* utility functions */
+static inline int
+classname_cmp(VALUE name, VALUE klass)
+{
+    VALUE mod_name;
+    VALUE class_name = (Qnil == name) ? rb_str_new2("main") : name;
+    if (klass == Qnil) return(0);
+    mod_name = rb_mod_name(klass);
+    return (mod_name != Qnil && rb_str_cmp(class_name, mod_name) == 0);
+}
+
+/* breakpoints & catchpoints */
+enum bp_type {BP_POS_TYPE, BP_METHOD_TYPE};
+enum hit_condition {HIT_COND_NONE, HIT_COND_GE, HIT_COND_EQ, HIT_COND_MOD};
+
+typedef struct {
+  int id;
+  enum bp_type type;
+  VALUE source;
+  union
+  {
+      int line;
+      ID  mid;
+  } pos;
+  VALUE expr;
+  VALUE enabled;
+  int hit_count;
+  int hit_value;
+  enum hit_condition hit_condition;
+} breakpoint_t;
+
+extern VALUE catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name);
+extern VALUE find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
+                                    VALUE binding);
+extern VALUE find_breakpoint_by_method(VALUE breakpoints, VALUE klass,
+                                       VALUE mid, VALUE binding, VALUE self);
+extern void Init_breakpoint(VALUE mByebug);
+
+#endif

data/ext/byebug/context.c

@@ -0,0 +1,424 @@
+#include <byebug.h>
+
+static VALUE cContext;
+static int thnum_current = 0;
+
+static VALUE idAlive;
+
+/* "Step", "Next" and "Finish" do their work by saving information about where
+ * to stop next. reset_stepping_stop_points removes/resets this information. */
+extern void
+reset_stepping_stop_points(debug_context_t *context)
+{
+  context->dest_frame = -1;
+  context->stop_line  = -1;
+  context->stop_next  = -1;
+}
+
+static inline VALUE
+Context_thnum(VALUE self) {
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return INT2FIX(context->thnum);
+}
+
+static inline void
+delete_frame(debug_context_t *context)
+{
+  debug_frame_t *frame;
+
+  frame = context->stack;
+  context->stack = frame->prev;
+  context->stack_size--;
+  xfree(frame);
+}
+
+static inline void
+fill_frame(debug_frame_t *frame, char* file, int lineno, VALUE method_id,
+                                 VALUE defined_class, VALUE binding, VALUE self)
+{
+  frame->file = file;
+  frame->line = lineno;
+  frame->method_id = method_id;
+  frame->defined_class = defined_class;
+  frame->binding = binding;
+  frame->self = self;
+}
+
+static inline VALUE
+Context_stack_size(VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return INT2FIX(context->stack_size);
+}
+
+static inline VALUE
+Context_thread(VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return context->thread;
+}
+
+static inline VALUE
+Context_dead(VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return IS_THREAD_ALIVE(context->thread) ? Qfalse : Qtrue;
+}
+
+extern VALUE
+Context_ignored(VALUE self)
+{
+  debug_context_t *context;
+
+  if (self == Qnil) return Qtrue;
+  Data_Get_Struct(self, debug_context_t, context);
+  return CTX_FL_TEST(context, CTX_FL_IGNORE) ? Qtrue : Qfalse;
+}
+
+extern void
+push_frame(VALUE context_object, char* file, int lineno, VALUE method_id,
+           VALUE defined_class, VALUE binding, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  frame = ALLOC(debug_frame_t);
+  fill_frame(frame, file, lineno, method_id, defined_class, binding, self);
+  frame->prev = context->stack;
+  context->stack = frame;
+  context->stack_size++;
+}
+
+extern void
+pop_frame(VALUE context_object)
+{
+  debug_context_t *context;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  if (context->stack_size > 0) {
+    delete_frame(context);
+  }
+}
+
+extern void
+update_frame(VALUE context_object, char* file, int lineno, VALUE method_id,
+             VALUE defined_class, VALUE binding, VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  if (context->stack_size == 0) {
+    push_frame(context_object, file, lineno, method_id, defined_class, binding,
+                               self);
+    return;
+  }
+  fill_frame(context->stack, file, lineno, method_id, defined_class, binding,
+                             self);
+
+}
+
+static void
+Context_mark(debug_context_t *context)
+{
+  debug_frame_t *frame;
+
+  rb_gc_mark(context->thread);
+  frame = context->stack;
+  while (frame != NULL) {
+    rb_gc_mark(frame->self);
+    rb_gc_mark(frame->binding);
+    frame = frame->prev;
+  }
+}
+
+static void
+Context_free(debug_context_t *context) {
+  while(context->stack_size > 0) {
+    delete_frame(context);
+  }
+  xfree(context);
+}
+
+extern VALUE
+context_create(VALUE thread, VALUE cDebugThread) {
+  debug_context_t *context;
+
+  context = ALLOC(debug_context_t);
+  context->stack_size = 0;
+  context->stack = NULL;
+  context->thnum = ++thnum_current;
+  context->thread = thread;
+  context->flags = 0;
+  context->last_file = NULL;
+  context->last_line = -1;
+  context->stop_frame = -1;
+  reset_stepping_stop_points(context);
+  if (rb_obj_class(thread) == cDebugThread) CTX_FL_SET(context, CTX_FL_IGNORE);
+  return Data_Wrap_Struct(cContext, Context_mark, Context_free, context);
+}
+
+static inline void
+check_frame_number_valid(debug_context_t *context, int frame_no)
+{
+  if (frame_no < 0 || frame_no >= context->stack_size) {
+    rb_raise(rb_eArgError, "Invalid frame number %d, stack (0...%d)",
+        frame_no, context->stack_size);
+  }
+}
+
+static debug_frame_t*
+get_frame_no(debug_context_t *context, int frame_n)
+{
+  debug_frame_t *frame;
+  int i;
+
+  check_frame_number_valid(context, frame_n);
+  frame = context->stack;
+  for (i = 0; i < frame_n; i++) {
+    frame = frame->prev;
+  }
+  return frame;
+}
+
+static VALUE
+Context_frame_file(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return rb_str_new2(frame->file);
+}
+
+static VALUE
+Context_frame_line(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return INT2FIX(frame->line);
+}
+
+static VALUE
+Context_frame_method(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return frame->method_id;
+}
+
+static VALUE
+Context_frame_binding(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return frame->binding;
+}
+
+static VALUE
+Context_frame_self(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return frame->self;
+}
+
+/*
+static VALUE
+Context_frame_args(int argc, VALUE *argv, VALUE self)
+{
+    debug_context_t *context;
+    debug_frame_t *frame;
+    VALUE frame_no;
+    int frame_n;
+
+    Data_Get_Struct(self, debug_context_t, context);
+    frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+    frame = get_frame_no(context, frame_n);
+
+    return frame->arg_ary;
+}
+*/
+
+static VALUE
+Context_tracing(VALUE self)
+{
+    debug_context_t *context;
+
+    Data_Get_Struct(self, debug_context_t, context);
+    return CTX_FL_TEST(context, CTX_FL_TRACING) ? Qtrue : Qfalse;
+}
+
+static VALUE
+Context_set_tracing(VALUE self, VALUE value)
+{
+    debug_context_t *context;
+
+    Data_Get_Struct(self, debug_context_t, context);
+
+    if (RTEST(value))
+        CTX_FL_SET(context, CTX_FL_TRACING);
+    else
+        CTX_FL_UNSET(context, CTX_FL_TRACING);
+    return value;
+}
+
+static VALUE
+Context_stop_reason(VALUE self)
+{
+    debug_context_t *context;
+    const char *symbol;
+
+    Data_Get_Struct(self, debug_context_t, context);
+
+    switch(context->stop_reason)
+    {
+        case CTX_STOP_STEP:
+            symbol = "step";
+            break;
+        case CTX_STOP_BREAKPOINT:
+            symbol = "breakpoint";
+            break;
+        case CTX_STOP_CATCHPOINT:
+            symbol = "catchpoint";
+            break;
+        case CTX_STOP_NONE:
+        default:
+            symbol = "none";
+    }
+    if(CTX_FL_TEST(context, CTX_FL_DEAD))
+        symbol = "post-mortem";
+
+    return ID2SYM(rb_intern(symbol));
+}
+
+static VALUE
+Context_stop_next(int argc, VALUE *argv, VALUE self)
+{
+  VALUE steps;
+  VALUE force;
+  debug_context_t *context;
+
+  rb_scan_args(argc, argv, "11", &steps, &force);
+  if(FIX2INT(steps) < 0) rb_raise(rb_eRuntimeError, "Steps argument can't be negative.");
+
+  Data_Get_Struct(self, debug_context_t, context);
+  context->stop_next = FIX2INT(steps);
+  if(RTEST(force))
+      CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
+  else
+      CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
+
+  return steps;
+}
+
+static VALUE
+Context_step_over(int argc, VALUE *argv, VALUE self)
+{
+  VALUE lines, frame, force;
+  debug_context_t *context;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  if(context->stack_size == 0)
+    rb_raise(rb_eRuntimeError, "No frames collected.");
+
+  rb_scan_args(argc, argv, "12", &lines, &frame, &force);
+  context->stop_line = FIX2INT(lines);
+  CTX_FL_UNSET(context, CTX_FL_STEPPED);
+  if(frame == Qnil)
+  {
+    context->dest_frame = context->stack_size;
+  }
+  else
+  {
+    if(FIX2INT(frame) < 0 && FIX2INT(frame) >= context->stack_size)
+      rb_raise(rb_eRuntimeError, "Destination frame is out of range.");
+    context->dest_frame = context->stack_size - FIX2INT(frame);
+  }
+  if(RTEST(force))
+    CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
+  else
+    CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
+
+  return Qnil;
+}
+
+static VALUE
+Context_stop_frame(VALUE self, VALUE frame)
+{
+  debug_context_t *debug_context;
+
+  Data_Get_Struct(self, debug_context_t, debug_context);
+  if(FIX2INT(frame) < 0 && FIX2INT(frame) >= debug_context->stack_size)
+    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+  debug_context->stop_frame = debug_context->stack_size - FIX2INT(frame);
+
+  return frame;
+}
+
+/*
+ *   Document-class: Context
+ *
+ *   == Summary
+ *
+ *   Byebug keeps a single instance of this class for each Ruby thread.
+ */
+VALUE
+Init_context(VALUE mByebug)
+{
+  cContext = rb_define_class_under(mByebug, "Context", rb_cObject);
+  rb_define_method(cContext, "stack_size", Context_stack_size, 0);
+  rb_define_method(cContext, "thread", Context_thread, 0);
+  rb_define_method(cContext, "dead?", Context_dead, 0);
+  rb_define_method(cContext, "ignored?", Context_ignored, 0);
+  rb_define_method(cContext, "thnum", Context_thnum, 0);
+  rb_define_method(cContext, "stop_reason", Context_stop_reason, 0);
+  rb_define_method(cContext, "tracing", Context_tracing, 0);
+  rb_define_method(cContext, "tracing=", Context_set_tracing, 1);
+  rb_define_method(cContext, "frame_file", Context_frame_file, -1);
+  rb_define_method(cContext, "frame_line", Context_frame_line, -1);
+  rb_define_method(cContext, "frame_method", Context_frame_method, -1);
+  rb_define_method(cContext, "frame_binding", Context_frame_binding, -1);
+  rb_define_method(cContext, "frame_self", Context_frame_self, -1);
+//rb_define_method(cContext, "frame_args", Context_frame_args, -1);
+  rb_define_method(cContext, "stop_next=", Context_stop_next, -1);
+  rb_define_method(cContext, "step", Context_stop_next, -1);
+  rb_define_method(cContext, "step_over", Context_step_over, -1);
+  rb_define_method(cContext, "stop_frame=", Context_stop_frame, 1);
+
+  idAlive = rb_intern("alive?");
+
+  return cContext;
+}