Ttyjukl

I'm working on a project using nlohmann's json C++ implementation.

How can one easily explore nlohmann's JSON keys/vals in GDB ?

I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
But I don't find it convenient.

Here is a simple use case:

json foo;

foo["flex"] = 0.2;

foo["awesome_str"] = "bleh";

foo["nested"] = {{"bar", "barz"}}; 

What I would like to have in GDB:

(gdb) p foo

{

    "flex" : 0.2,

    "awesome_str": "bleh",

    "nested": etc.

}

Current behavior

(gdb) p foo

$1 = {

  m_type = nlohmann::detail::value_t::object, 

  m_value = {

    object = 0x129ccdd0, 

    array = 0x129ccdd0, 

    string = 0x129ccdd0, 

    boolean = 208, 

    number_integer = 312266192, 

    number_unsigned = 312266192, 

    number_float = 1.5427999782486669e-315

  }

}

(gdb) p foo.at("flex")

Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.

(gdb) p *foo.m_value.object

$2 = {

  _M_t = {

    _M_impl = {

      <std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = {

        <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = {<No data fields>}, <No data fields>}, 

      <std::_Rb_tree_key_compare<std::less<void> >> = {

        _M_key_compare = {<No data fields>}

      }, 

      <std::_Rb_tree_header> = {

        _M_header = {

          _M_color = std::_S_red, 

          _M_parent = 0x4d72d0, 

          _M_left = 0x4d7210, 

          _M_right = 0x4d7270

        }, 

        _M_node_count = 5

      }, <No data fields>}

  }

}

I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.

Short path

I simply defined a gdb command as follows:

# this is a gdb script

# can be loaded from gdb using

# source my_script.txt (or. gdb or whatever you like)

define pjson

# use the lohmann's builtin dump method, ident 4 and use space separator

printf "%sn", $arg0.dump(4, ' ', true).c_str()

end

# configure command helper (text displayed when typing 'help pjson' in gdb)

document pjson

Prints a lohmann's JSON C++ variable as a human-readable JSON string

end

Using it in gdb:

(gdb) source my_custom_script.gdb

(gdb) pjson foo

{

    "flex" : 0.2,

    "awesome_str": "bleh",

    "nested": {

        "bar": "barz"

    }

}

Over the top

The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.

Basically, when in gdb you would type:

(gdb) p foo

and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).

Quoting:

A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.

Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.

class StdStringPrinter(object):

    "Print a std::string"



    def __init__(self, val):

        self.val = val



    def to_string(self):

        return self.val['_M_dataplus']['_M_p']



    def display_hint(self):

        return 'string'

Still quoting for the sake of completness:

And here is an example showing how a lookup function for the printer example above might be written.

def str_lookup_function(val):

    lookup_tag = val.type.tag

    if lookup_tag == None:

        return None

    regex = re.compile("^std::basic_string<char,.*>$")

    if regex.match(lookup_tag):

        return StdStringPrinter(val)

    return None