Module: Debugger

Defined in:
ext/ruby_debug/ruby_debug.c

Constant Summary collapse

VERSION = 
rb_str_new2(DEBUG_VERSION)

Class Method Summary collapse

Class Method Details

.add_breakpoint(source, pos, condition = nil) ⇒ Object

Adds a new breakpoint. source is a name of a file or a class. pos is a line number or a method name if source is a class name. condition is a string which is evaluated to true when this breakpoint is activated.



2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
 
# File 'ext/ruby_debug/ruby_debug.c', line 2643

static VALUE
debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
{
    VALUE result;

    debug_check_started();

    result = create_breakpoint_from_args(argc, argv, ++bkp_count);
    rb_ary_push(rdebug_breakpoints, result);
    return result;
}

.catchpoint(string) ⇒ String

Sets catchpoint. Returns the string passed.

Returns:

  • (String) 


249
250
251
252
253
254
255
256
257
258
259
 
# File 'ext/ruby_debug/breakpoint.c', line 249

VALUE
rdebug_add_catchpoint(VALUE self, VALUE value)
{
    debug_check_started();

    if (TYPE(value) != T_STRING) {
        rb_raise(rb_eTypeError, "value of a catchpoint must be String");
    }
    rb_hash_aset(rdebug_catchpoints, rb_str_dup(value), INT2FIX(0));
    return value;
}

.breakpoints ⇒ Array

Returns an array of breakpoints.

Returns:

  • (Array) 


2625
2626
2627
2628
2629
2630
2631
 
# File 'ext/ruby_debug/ruby_debug.c', line 2625

static VALUE
debug_breakpoints(VALUE self)
{
    debug_check_started();

    return rdebug_breakpoints;
}

.catchpoints ⇒ Hash

Returns a current catchpoints, which is a hash exception names that will trigger a debugger when raised. The values are the number of times taht catchpoint was hit, initially 0.

Returns:

  • (Hash) 


235
236
237
238
239
240
241
 
# File 'ext/ruby_debug/breakpoint.c', line 235

VALUE
debug_catchpoints(VALUE self)
{
    debug_check_started();

    return rdebug_catchpoints;
}

.contexts ⇒ Array

Returns an array of all contexts.

Returns:

  • (Array) 


1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
 
# File 'ext/ruby_debug/ruby_debug.c', line 1313

static VALUE
debug_contexts(VALUE self)
{
    volatile VALUE list;
    volatile VALUE new_list;
    VALUE thread, context;
    threads_table_t *threads_table;
    debug_context_t *debug_context;
    int i;

    debug_check_started();

    new_list = rb_ary_new();
    list = rb_funcall(rb_cThread, idList, 0);
    for(i = 0; i < RARRAY_LEN(list); i++)
    {
        thread = rb_ary_entry(list, i);
        thread_context_lookup(thread, &context, NULL, 1);
        rb_ary_push(new_list, context);
    }
    threads_table_clear(rdebug_threads_tbl);
    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);
    for(i = 0; i < RARRAY_LEN(new_list); i++)
    {
        context = rb_ary_entry(new_list, i);
        Data_Get_Struct(context, debug_context_t, debug_context);
        st_insert(threads_table->tbl, debug_context->thread_id, context);
    }

    return new_list;
}

.current_context ⇒ Object

Returns current context. Note: Debugger.current_context.thread == Thread.current



1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
 
# File 'ext/ruby_debug/ruby_debug.c', line 1278

static VALUE
debug_current_context(VALUE self)
{
    VALUE thread, context;

    debug_check_started();

    thread = rb_thread_current();
    thread_context_lookup(thread, &context, NULL, 1);

    return context;
}

.debug ⇒ Object

:nodoc:



1538
1539
1540
1541
1542
 
# File 'ext/ruby_debug/ruby_debug.c', line 1538

static VALUE
debug_debug(VALUE self)
{
    return debug;
}

.debug=(value) ⇒ Object

:nodoc:



1545
1546
1547
1548
1549
1550
 
# File 'ext/ruby_debug/ruby_debug.c', line 1545

static VALUE
debug_set_debug(VALUE self, VALUE value)
{
    debug = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.debug_at_exit { ... } ⇒ Proc

Register at_exit hook which is escaped from the debugger. FOR INTERNAL USE ONLY.

Yields:

Returns:

  • (Proc) 


1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
 
# File 'ext/ruby_debug/ruby_debug.c', line 1675

static VALUE
debug_at_exit(VALUE self)
{
    VALUE proc;
    if (!rb_block_given_p())
        rb_raise(rb_eArgError, "called without a block");
    proc = rb_block_proc();
    rb_set_end_proc(debug_at_exit_i, proc);
    return proc;
}

.debug_load(file, stop = false, increment_start = false) ⇒ nil

Same as Kernel#load but resets current context’s frames. stop parameter forces the debugger to stop at the first line of code in the file increment_start determines if start_count should be incremented. When

control threads are used, they have to be set up before loading the
debugger; so here +increment_start+ will be false.

FOR INTERNAL USE ONLY.

Returns:

  • (nil) 


1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
 
# File 'ext/ruby_debug/ruby_debug.c', line 1570

static VALUE
debug_debug_load(int argc, VALUE *argv, VALUE self)
{
    VALUE file, stop, context, increment_start;
    debug_context_t *debug_context;
    int state = 0;
    
    if(rb_scan_args(argc, argv, "12", &file, &stop, &increment_start) == 1) 
    {
        stop = Qfalse;
        increment_start = Qtrue;
    }

    debug_start(self);
    if (Qfalse == increment_start) start_count--;
    
    context = debug_current_context(self);
    Data_Get_Struct(context, debug_context_t, debug_context);
    debug_context->stack_size = 0;
    if(RTEST(stop))
        debug_context->stop_next = 1;
    /* Initializing $0 to the script's path */
    ruby_script(RSTRING_PTR(file));
    rb_load_protect(file, 0, &state);
    if (0 != state) 
    {
        VALUE errinfo = rb_errinfo();
        debug_suspend(self);
        reset_stepping_stop_points(debug_context);
        rb_set_errinfo(Qnil);
        return errinfo;
    }

    /* We should run all at_exit handler's in order to provide, 
     * for instance, a chance to run all defined test cases */
    rb_exec_end_proc();

    /* We could have issued a Debugger.stop inside the debug
       session. */
    if (start_count > 0)
        debug_stop(self);

    return Qnil;
}

.keep_frame_binding=(bool) ⇒ Object

Setting to true will make the debugger create frame bindings.



1505
1506
1507
1508
1509
1510
 
# File 'ext/ruby_debug/ruby_debug.c', line 1505

static VALUE
debug_set_keep_frame_binding(VALUE self, VALUE value)
{
    keep_frame_binding = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.keep_frame_binding? ⇒ Boolean

Returns true if the debugger will collect frame bindings.

Returns:

  • (Boolean) 


1493
1494
1495
1496
1497
 
# File 'ext/ruby_debug/ruby_debug.c', line 1493

static VALUE
debug_keep_frame_binding(VALUE self)
{
    return keep_frame_binding;
}

.last_interrupted ⇒ Object

Returns last debugged context.



1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
 
# File 'ext/ruby_debug/ruby_debug.c', line 1257

static VALUE
debug_last_interrupted(VALUE self)
{
    VALUE result = Qnil;
    threads_table_t *threads_table;

    debug_check_started();

    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);

    st_foreach(threads_table->tbl, find_last_context_func, (st_data_t)&result);
    return result;
}

.post_mortem=(bool) ⇒ Object

Sets post-moterm flag. FOR INTERNAL USE ONLY.



1453
1454
1455
1456
1457
1458
1459
1460
 
# File 'ext/ruby_debug/ruby_debug.c', line 1453

static VALUE
debug_set_post_mortem(VALUE self, VALUE value)
{
    debug_check_started();

    post_mortem = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.post_mortem? ⇒ Boolean

Returns true if post-moterm debugging is enabled.

Returns:

  • (Boolean) 


1440
1441
1442
1443
1444
 
# File 'ext/ruby_debug/ruby_debug.c', line 1440

static VALUE
debug_post_mortem(VALUE self)
{
    return post_mortem;
}

.remove_breakpoint(id) ⇒ Object

Removes breakpoint by its id. id is an identificator of a breakpoint.



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'ext/ruby_debug/breakpoint.c', line 204

VALUE
rdebug_remove_breakpoint(VALUE self, VALUE id_value)
{
    int i;
    int id;
    VALUE breakpoint;
    debug_breakpoint_t *debug_breakpoint;

    id = FIX2INT(id_value);

    for( i = 0; i < RARRAY_LEN(rdebug_breakpoints); i += 1 )
    {
        breakpoint = rb_ary_entry(rdebug_breakpoints, i);
        Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
        if(debug_breakpoint->id == id)
        {
            rb_ary_delete_at(rdebug_breakpoints, i);
            return breakpoint;
        }
    }
    return Qnil;
}

.resolve_symlinks=(bool) ⇒ Object

Setting to true will make the debugger resolve symlinks when checking breakpoint.



1530
1531
1532
1533
1534
1535
 
# File 'ext/ruby_debug/ruby_debug.c', line 1530

static VALUE
debug_set_resolve_symlinks(VALUE self, VALUE value)
{
    resolve_symlinks = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.resolve_symlinks? ⇒ Boolean

Returns true if the debugger will resolve symlinks when checking breakpoint.

Returns:

  • (Boolean) 


1518
1519
1520
1521
1522
 
# File 'ext/ruby_debug/ruby_debug.c', line 1518

static VALUE
debug_resolve_symlinks(VALUE self)
{
    return resolve_symlinks;
}

.resume ⇒ Debugger

Resumes all contexts.

Returns:



1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
 
# File 'ext/ruby_debug/ruby_debug.c', line 1382

static VALUE
debug_resume(VALUE self)
{
    VALUE current, context;
    VALUE context_list;
    debug_context_t *debug_context;
    int i;

    debug_check_started();

    context_list = debug_contexts(self);

    thread_context_lookup(rb_thread_current(), &current, NULL, 1);
    for(i = 0; i < RARRAY_LEN(context_list); i++)
    {
        context = rb_ary_entry(context_list, i);
        if(current == context)
            continue;
        Data_Get_Struct(context, debug_context_t, debug_context);
        context_resume_0(debug_context);
    }

    rb_thread_schedule();

    return self;
}

.skip { ... } ⇒ Object?

The code inside of the block is escaped from the debugger.

Yields:

Returns:

  • (Object, nil) 


1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
 
# File 'ext/ruby_debug/ruby_debug.c', line 1636

static VALUE
debug_skip(VALUE self)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "called without a block");
    }
    if(!IS_STARTED)
        return rb_yield(Qnil);
    set_current_skipped_status(Qtrue);
    return rb_ensure(rb_yield, Qnil, set_current_skipped_status, Qfalse);
}

.start_ ⇒ Boolean .start_ { ... } ⇒ Boolean

This method is internal and activates the debugger. Use Debugger.start (from lib/ruby-debug-base.rb) instead.

The return value is the value of !Debugger.started? before issuing the start; That is, true is returned, unless debugger was previously started.

If a block is given, it starts debugger and yields to block. When the block is finished executing it stops the debugger with Debugger.stop method. Inside the block you will probably want to have a call to Debugger.debugger. For example:

Debugger.start{debugger; foo}  # Stop inside of foo

Also, ruby-debug only allows one invocation of debugger at a time; nested Debugger.start’s have no effect and you can’t use this inside the debugger itself.

Note that if you want to completely remove the debugger hook, you must call Debugger.stop as many times as you called Debugger.start method.

Overloads:

  • .start_ ⇒ Boolean

    Returns:

    • (Boolean)
  • .start_ { ... } ⇒ Boolean

    Yields:

    Returns:

    • (Boolean) 


1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
 
# File 'ext/ruby_debug/ruby_debug.c', line 1180

static VALUE
debug_start(VALUE self)
{
    VALUE result;
    start_count++;

    if(IS_STARTED)
        result = Qfalse;
    else
    {
        locker             = Qnil;
        rdebug_breakpoints = rb_ary_new();
        rdebug_catchpoints = rb_hash_new();
        rdebug_threads_tbl = threads_table_create();

        rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL, Qnil);
        result = Qtrue;
    }

    if(rb_block_given_p()) 
      rb_ensure(rb_yield, self, debug_stop_i, self);

    return result;
}

.started? ⇒ Boolean

Returns true the debugger is started.

Returns:

  • (Boolean) 


324
325
326
327
328
 
# File 'ext/ruby_debug/ruby_debug.c', line 324

static VALUE
debug_is_started(VALUE self)
{
    return IS_STARTED ? Qtrue : Qfalse;
}

.stop ⇒ Boolean

This method disables the debugger. It returns true if the debugger is disabled, otherwise it returns false.

Note that if you want to complete remove the debugger hook, you must call Debugger.stop as many times as you called Debugger.start method.

Returns:

  • (Boolean) 


1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
 
# File 'ext/ruby_debug/ruby_debug.c', line 1216

static VALUE
debug_stop(VALUE self)
{
    debug_check_started();

    start_count--;
    if(start_count)
        return Qfalse;

    rb_remove_event_hook(debug_event_hook);

    locker             = Qnil;
    rdebug_breakpoints = Qnil;
    rdebug_threads_tbl = Qnil;

    return Qtrue;
}

.suspend ⇒ Debugger

Suspends all contexts.

Returns:



1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
 
# File 'ext/ruby_debug/ruby_debug.c', line 1351

static VALUE
debug_suspend(VALUE self)
{
    VALUE current, context;
    VALUE context_list;
    debug_context_t *debug_context;
    int i;

    debug_check_started();

    context_list = debug_contexts(self);
    thread_context_lookup(rb_thread_current(), &current, NULL, 1);

    for(i = 0; i < RARRAY_LEN(context_list); i++)
    {
        context = rb_ary_entry(context_list, i);
        if(current == context)
            continue;
        Data_Get_Struct(context, debug_context_t, debug_context);
        context_suspend_0(debug_context);
    }

    return self;
}

.thread_context(thread) ⇒ Object

Returns context of the thread passed as an argument.



1297
1298
1299
1300
1301
1302
1303
1304
1305
 
# File 'ext/ruby_debug/ruby_debug.c', line 1297

static VALUE
debug_thread_context(VALUE self, VALUE thread)
{
    VALUE context;

    debug_check_started();
    thread_context_lookup(thread, &context, NULL, 1);
    return context;
}

.tracing ⇒ Boolean

Returns true if the global tracing is activated.

Returns:

  • (Boolean) 


1415
1416
1417
1418
1419
 
# File 'ext/ruby_debug/ruby_debug.c', line 1415

static VALUE
debug_tracing(VALUE self)
{
    return tracing;
}

.tracing=(bool) ⇒ Object

Sets the global tracing flag.



1427
1428
1429
1430
1431
1432
 
# File 'ext/ruby_debug/ruby_debug.c', line 1427

static VALUE
debug_set_tracing(VALUE self, VALUE value)
{
    tracing = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.track_frame_args=(bool) ⇒ Object

Setting to true will make the debugger save argument info on calls.



1480
1481
1482
1483
1484
1485
 
# File 'ext/ruby_debug/ruby_debug.c', line 1480

static VALUE
debug_set_track_frame_args(VALUE self, VALUE value)
{
    track_frame_args = RTEST(value) ? Qtrue : Qfalse;
    return value;
}

.track_fame_args? ⇒ Boolean

Returns true if the debugger track frame argument values on calls.

Returns:

  • (Boolean) 


1468
1469
1470
1471
1472
 
# File 'ext/ruby_debug/ruby_debug.c', line 1468

static VALUE
debug_track_frame_args(VALUE self)
{
    return track_frame_args;
}