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.



2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
 
# File 'ext/ruby_debug/ruby_debug.c', line 2547

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) 


2529
2530
2531
2532
2533
2534
2535
 
# File 'ext/ruby_debug/ruby_debug.c', line 2529

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) 


1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
 
# File 'ext/ruby_debug/ruby_debug.c', line 1272

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



1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
 
# File 'ext/ruby_debug/ruby_debug.c', line 1237

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:



1472
1473
1474
1475
1476
 
# File 'ext/ruby_debug/ruby_debug.c', line 1472

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

.debug=(value) ⇒ Object

:nodoc:



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

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) 


1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
 
# File 'ext/ruby_debug/ruby_debug.c', line 1609

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) 


1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
 
# File 'ext/ruby_debug/ruby_debug.c', line 1504

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.



1464
1465
1466
1467
1468
1469
 
# File 'ext/ruby_debug/ruby_debug.c', line 1464

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) 


1452
1453
1454
1455
1456
 
# File 'ext/ruby_debug/ruby_debug.c', line 1452

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

.last_interrupted ⇒ Object

Returns last debugged context.



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

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.



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

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) 


1399
1400
1401
1402
1403
 
# File 'ext/ruby_debug/ruby_debug.c', line 1399

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;
}

.resume ⇒ Debugger

Resumes all contexts.

Returns:



1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
 
# File 'ext/ruby_debug/ruby_debug.c', line 1341

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) 


1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
 
# File 'ext/ruby_debug/ruby_debug.c', line 1570

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) 


1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
 
# File 'ext/ruby_debug/ruby_debug.c', line 1143

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) 


337
338
339
340
341
 
# File 'ext/ruby_debug/ruby_debug.c', line 337

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) 


1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
 
# File 'ext/ruby_debug/ruby_debug.c', line 1179

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:



1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
 
# File 'ext/ruby_debug/ruby_debug.c', line 1310

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.



1256
1257
1258
1259
1260
1261
1262
1263
1264
 
# File 'ext/ruby_debug/ruby_debug.c', line 1256

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) 


1374
1375
1376
1377
1378
 
# File 'ext/ruby_debug/ruby_debug.c', line 1374

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

.tracing=(bool) ⇒ Object

Sets the global tracing flag.



1386
1387
1388
1389
1390
1391
 
# File 'ext/ruby_debug/ruby_debug.c', line 1386

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.



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

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) 


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

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