Hfrxdjt

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