C++ debug/print custom type with GDB : the case of nlohmann json libraryHow to inspect std::string in GDB with no source code?How to pass normal param as well as template param in a template function in C++?How do I get my IDE to provide the C++ libraries?Why can I not call reserve on a vector of const elements?Cannot get min_element to work in C++Linker error trying to embed v8LNK2019: unresolved external symbol in C++Valgrind complaining possible memory leak in std string's new operatorName mangling confusion in LLVMclang++ memory sanitizer reports use-of-uninitialized-valueDebug std containers with gdb not working
Redundant comparison & "if" before assignment
Delivering sarcasm
250 Floor Tower
lightning-datatable row number error
What percentage of fillings performed today are done with mercury amalgam?
Added a new user on Ubuntu, set password not working?
C++ debug/print custom type with GDB : the case of nlohmann json library
Are paving bricks differently sized for sand bedding vs mortar bedding?
Multiplicative persistence
Travelling outside the UK without a passport
If magnesium reacts with oxygen to produce magnesium oxide only on the application of heat, then why isn't it categorised as an endothermic reaction?
How do I color the graph in datavisualization?
Is there any references on the tensor product of presentable (1-)categories?
Biological Blimps: Propulsion
Closed-form expression for certain product
What are the purposes of autoencoders?
Why did the Mercure fail?
Count the occurrence of each unique word in the file
Is it safe to use olive oil to clean the ear wax?
How much character growth crosses the line into breaking the character
The IT department bottlenecks progress. How should I handle this?
Does an advisor owe his/her student anything? Will an advisor keep a PhD student only out of pity?
Is it better practice to read straight from sheet music rather than memorize it?
Creepy dinosaur pc game identification
C++ debug/print custom type with GDB : the case of nlohmann json library
How to inspect std::string in GDB with no source code?How to pass normal param as well as template param in a template function in C++?How do I get my IDE to provide the C++ libraries?Why can I not call reserve on a vector of const elements?Cannot get min_element to work in C++Linker error trying to embed v8LNK2019: unresolved external symbol in C++Valgrind complaining possible memory leak in std string's new operatorName mangling confusion in LLVMclang++ memory sanitizer reports use-of-uninitialized-valueDebug std containers with gdb not working
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>
c++ json gdb pretty-print nlohmann-json
add a comment |
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>
c++ json gdb pretty-print nlohmann-json
add a comment |
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>
c++ json gdb pretty-print nlohmann-json
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>
c++ json gdb pretty-print nlohmann-json
c++ json gdb pretty-print nlohmann-json
edited 12 mins ago
LoneWanderer
asked 6 hours ago
LoneWandererLoneWanderer
1,112825
1,112825
add a comment |
add a comment |
1 Answer
1
active
oldest
votes
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
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
add a comment |
Your Answer
StackExchange.ifUsing("editor", function ()
StackExchange.using("externalEditor", function ()
StackExchange.using("snippets", function ()
StackExchange.snippets.init();
);
);
, "code-snippets");
StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "1"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);
else
createEditor();
);
function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);
);
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55316620%2fc-debug-print-custom-type-with-gdb-the-case-of-nlohmann-json-library%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
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
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
add a comment |
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
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
add a comment |
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
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
edited 5 mins ago
answered 6 hours ago
LoneWandererLoneWanderer
1,112825
1,112825
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
add a comment |
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
That looks pretty useful. Unfortunately I am out of votes ATM.
– πάντα ῥεῖ
5 hours ago
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55316620%2fc-debug-print-custom-type-with-gdb-the-case-of-nlohmann-json-library%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown