e8daa2f843
Rationale: Pretty simply, the idea is that sometimes type names are way too long and contain way too many details for the average developer to care about. For instance, a plain ol' vector of int might be shown as std::__1::vector<int, std::__1::allocator<.... rather than the much simpler std::vector<int> form, which is what most developers would actually type in their code Proposed solution: Introduce a notion of "display name" and a corresponding API GetDisplayTypeName() to return such a crafted for visual representation type name Obviously, the display name and the fully qualified (or "true") name are not necessarily the same - that's the whole point LLDB could choose to pick the "display name" as its one true notion of a type name, and if somebody really needs the fully qualified version of it, let them deal with the problem Or, LLDB could rename what it currently calls the "type name" to be the "display name", and add new APIs for the fully qualified name, making the display name the default choice The choice that I am making here is that the type name will keep meaning the same, and people who want a type name suited for display will explicitly ask for one It is the less risky/disruptive choice - and it should eventually make it fairly obvious when someone is asking for the wrong type Caveats: - for now, GetDisplayTypeName() == GetTypeName(), there is no logic to produce customized display type names yet. - while the fully-qualified type name is still the main key to the kingdom of data formatters, if we start showing custom names to people, those should match formatters llvm-svn: 209072
627 lines
19 KiB
C++
627 lines
19 KiB
C++
//===-- ValueObjectPrinter.cpp -------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/DataFormatters/ValueObjectPrinter.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/DataFormatters/DataVisualization.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
|
|
Stream* s,
|
|
const DumpValueObjectOptions& options)
|
|
{
|
|
Init(valobj,s,options,options.m_max_ptr_depth,0);
|
|
}
|
|
|
|
ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
|
|
Stream* s,
|
|
const DumpValueObjectOptions& options,
|
|
uint32_t ptr_depth,
|
|
uint32_t curr_depth)
|
|
{
|
|
Init(valobj,s,options,ptr_depth,curr_depth);
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::Init (ValueObject* valobj,
|
|
Stream* s,
|
|
const DumpValueObjectOptions& options,
|
|
uint32_t ptr_depth,
|
|
uint32_t curr_depth)
|
|
{
|
|
m_orig_valobj = valobj;
|
|
m_valobj = nullptr;
|
|
m_stream = s;
|
|
this->options = options;
|
|
m_ptr_depth = ptr_depth;
|
|
m_curr_depth = curr_depth;
|
|
assert (m_orig_valobj && "cannot print a NULL ValueObject");
|
|
assert (m_stream && "cannot print to a NULL Stream");
|
|
m_should_print = eLazyBoolCalculate;
|
|
m_is_nil = eLazyBoolCalculate;
|
|
m_is_ptr = eLazyBoolCalculate;
|
|
m_is_ref = eLazyBoolCalculate;
|
|
m_is_aggregate = eLazyBoolCalculate;
|
|
m_summary_formatter = {nullptr,false};
|
|
m_value.assign("");
|
|
m_summary.assign("");
|
|
m_error.assign("");
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintValueObject ()
|
|
{
|
|
if (!GetDynamicValueIfNeeded () || m_valobj == nullptr)
|
|
return false;
|
|
|
|
if (ShouldPrintValueObject())
|
|
{
|
|
PrintLocationIfNeeded();
|
|
m_stream->Indent();
|
|
|
|
bool show_type = PrintTypeIfNeeded();
|
|
|
|
PrintNameIfNeeded(show_type);
|
|
}
|
|
|
|
bool value_printed = false;
|
|
bool summary_printed = false;
|
|
|
|
bool val_summary_ok = PrintValueAndSummaryIfNeeded (value_printed,summary_printed);
|
|
|
|
if (val_summary_ok)
|
|
PrintChildrenIfNeeded (value_printed, summary_printed);
|
|
else
|
|
m_stream->EOL();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::GetDynamicValueIfNeeded ()
|
|
{
|
|
if (m_valobj)
|
|
return true;
|
|
bool update_success = m_orig_valobj->UpdateValueIfNeeded (true);
|
|
if (!update_success)
|
|
{
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
else
|
|
{
|
|
if (m_orig_valobj->IsDynamic())
|
|
{
|
|
if (options.m_use_dynamic == eNoDynamicValues)
|
|
{
|
|
ValueObject *static_value = m_orig_valobj->GetStaticValue().get();
|
|
if (static_value)
|
|
m_valobj = static_value;
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
else
|
|
{
|
|
if (options.m_use_dynamic != eNoDynamicValues)
|
|
{
|
|
ValueObject *dynamic_value = m_orig_valobj->GetDynamicValue(options.m_use_dynamic).get();
|
|
if (dynamic_value)
|
|
m_valobj = dynamic_value;
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
else
|
|
m_valobj = m_orig_valobj;
|
|
}
|
|
}
|
|
m_clang_type = m_valobj->GetClangType();
|
|
m_type_flags = m_clang_type.GetTypeInfo ();
|
|
return true;
|
|
}
|
|
|
|
const char*
|
|
ValueObjectPrinter::GetDescriptionForDisplay ()
|
|
{
|
|
const char* str = m_valobj->GetObjectDescription();
|
|
if (!str)
|
|
str = m_valobj->GetSummaryAsCString();
|
|
if (!str)
|
|
str = m_valobj->GetValueAsCString();
|
|
return str;
|
|
}
|
|
|
|
const char*
|
|
ValueObjectPrinter::GetRootNameForDisplay (const char* if_fail)
|
|
{
|
|
const char *root_valobj_name = options.m_root_valobj_name.empty() ?
|
|
m_valobj->GetName().AsCString() :
|
|
options.m_root_valobj_name.c_str();
|
|
return root_valobj_name ? root_valobj_name : if_fail;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::ShouldPrintValueObject ()
|
|
{
|
|
if (m_should_print == eLazyBoolCalculate)
|
|
m_should_print = (options.m_flat_output == false || m_type_flags.Test (ClangASTType::eTypeHasValue)) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_should_print == eLazyBoolYes;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::IsNil ()
|
|
{
|
|
if (m_is_nil == eLazyBoolCalculate)
|
|
m_is_nil = m_valobj->IsObjCNil() ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_nil == eLazyBoolYes;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::IsPtr ()
|
|
{
|
|
if (m_is_ptr == eLazyBoolCalculate)
|
|
m_is_ptr = m_type_flags.Test (ClangASTType::eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_ptr == eLazyBoolYes;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::IsRef ()
|
|
{
|
|
if (m_is_ref == eLazyBoolCalculate)
|
|
m_is_ref = m_type_flags.Test (ClangASTType::eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_ref == eLazyBoolYes;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::IsAggregate ()
|
|
{
|
|
if (m_is_aggregate == eLazyBoolCalculate)
|
|
m_is_aggregate = m_type_flags.Test (ClangASTType::eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
|
|
return m_is_aggregate == eLazyBoolYes;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintLocationIfNeeded ()
|
|
{
|
|
if (options.m_show_location)
|
|
{
|
|
m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintTypeIfNeeded ()
|
|
{
|
|
bool show_type = true;
|
|
// if we are at the root-level and been asked to hide the root's type, then hide it
|
|
if (m_curr_depth == 0 && options.m_hide_root_type)
|
|
show_type = false;
|
|
else
|
|
// otherwise decide according to the usual rules (asked to show types - always at the root level)
|
|
show_type = options.m_show_types || (m_curr_depth == 0 && !options.m_flat_output);
|
|
|
|
if (show_type)
|
|
{
|
|
// Some ValueObjects don't have types (like registers sets). Only print
|
|
// the type if there is one to print
|
|
ConstString qualified_type_name;
|
|
if (options.m_be_raw)
|
|
qualified_type_name = m_valobj->GetQualifiedTypeName();
|
|
else
|
|
qualified_type_name = m_valobj->GetDisplayTypeName();
|
|
if (qualified_type_name)
|
|
m_stream->Printf("(%s) ", qualified_type_name.GetCString());
|
|
else
|
|
show_type = false;
|
|
}
|
|
return show_type;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintNameIfNeeded (bool show_type)
|
|
{
|
|
if (options.m_flat_output)
|
|
{
|
|
// If we are showing types, also qualify the C++ base classes
|
|
const bool qualify_cxx_base_classes = show_type;
|
|
if (!options.m_hide_name)
|
|
{
|
|
m_valobj->GetExpressionPath(*m_stream, qualify_cxx_base_classes);
|
|
m_stream->PutCString(" =");
|
|
return true;
|
|
}
|
|
}
|
|
else if (!options.m_hide_name)
|
|
{
|
|
const char *name_cstr = GetRootNameForDisplay("");
|
|
m_stream->Printf ("%s =", name_cstr);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::CheckScopeIfNeeded ()
|
|
{
|
|
if (options.m_scope_already_checked)
|
|
return true;
|
|
return m_valobj->IsInScope();
|
|
}
|
|
|
|
TypeSummaryImpl*
|
|
ValueObjectPrinter::GetSummaryFormatter ()
|
|
{
|
|
if (m_summary_formatter.second == false)
|
|
{
|
|
TypeSummaryImpl* entry = options.m_summary_sp ? options.m_summary_sp.get() : m_valobj->GetSummaryFormat().get();
|
|
|
|
if (options.m_omit_summary_depth > 0)
|
|
entry = NULL;
|
|
m_summary_formatter.first = entry;
|
|
m_summary_formatter.second = true;
|
|
}
|
|
return m_summary_formatter.first;
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::GetValueSummaryError (std::string& value,
|
|
std::string& summary,
|
|
std::string& error)
|
|
{
|
|
if (options.m_format != eFormatDefault && options.m_format != m_valobj->GetFormat())
|
|
{
|
|
m_valobj->GetValueAsCString(options.m_format,
|
|
value);
|
|
}
|
|
else
|
|
{
|
|
const char* val_cstr = m_valobj->GetValueAsCString();
|
|
if (val_cstr)
|
|
value.assign(val_cstr);
|
|
}
|
|
const char* err_cstr = m_valobj->GetError().AsCString();
|
|
if (err_cstr)
|
|
error.assign(err_cstr);
|
|
|
|
if (ShouldPrintValueObject())
|
|
{
|
|
if (IsNil())
|
|
summary.assign("nil");
|
|
else if (options.m_omit_summary_depth == 0)
|
|
{
|
|
TypeSummaryImpl* entry = GetSummaryFormatter();
|
|
if (entry)
|
|
m_valobj->GetSummaryAsCString(entry, summary);
|
|
else
|
|
{
|
|
const char* sum_cstr = m_valobj->GetSummaryAsCString();
|
|
if (sum_cstr)
|
|
summary.assign(sum_cstr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintValueAndSummaryIfNeeded (bool& value_printed,
|
|
bool& summary_printed)
|
|
{
|
|
bool error_printed = false;
|
|
if (ShouldPrintValueObject())
|
|
{
|
|
if (!CheckScopeIfNeeded())
|
|
m_error.assign("out of scope");
|
|
if (m_error.empty())
|
|
{
|
|
GetValueSummaryError(m_value, m_summary, m_error);
|
|
}
|
|
if (m_error.size())
|
|
{
|
|
error_printed = true;
|
|
m_stream->Printf (" <%s>\n", m_error.c_str());
|
|
}
|
|
else
|
|
{
|
|
// Make sure we have a value and make sure the summary didn't
|
|
// specify that the value should not be printed - and do not print
|
|
// the value if this thing is nil
|
|
// (but show the value if the user passes a format explicitly)
|
|
TypeSummaryImpl* entry = GetSummaryFormatter();
|
|
if (!IsNil() && !m_value.empty() && (entry == NULL || (entry->DoesPrintValue(m_valobj) || options.m_format != eFormatDefault) || m_summary.empty()) && !options.m_hide_value)
|
|
{
|
|
m_stream->Printf(" %s", m_value.c_str());
|
|
value_printed = true;
|
|
}
|
|
|
|
if (m_summary.size())
|
|
{
|
|
m_stream->Printf(" %s", m_summary.c_str());
|
|
summary_printed = true;
|
|
}
|
|
}
|
|
}
|
|
return !error_printed;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintObjectDescriptionIfNeeded (bool value_printed,
|
|
bool summary_printed)
|
|
{
|
|
if (ShouldPrintValueObject())
|
|
{
|
|
// let's avoid the overly verbose no description error for a nil thing
|
|
if (options.m_use_objc && !IsNil())
|
|
{
|
|
if (!options.m_hide_value || !options.m_hide_name)
|
|
m_stream->Printf(" ");
|
|
const char *object_desc = nullptr;
|
|
if (value_printed || summary_printed)
|
|
object_desc = m_valobj->GetObjectDescription();
|
|
else
|
|
object_desc = GetDescriptionForDisplay();
|
|
if (object_desc && *object_desc)
|
|
{
|
|
m_stream->Printf("%s\n", object_desc);
|
|
return true;
|
|
}
|
|
else if (value_printed == false && summary_printed == false)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::ShouldPrintChildren (bool is_failed_description,
|
|
uint32_t& curr_ptr_depth)
|
|
{
|
|
const bool is_ref = IsRef ();
|
|
const bool is_ptr = IsPtr ();
|
|
|
|
if (is_failed_description || m_curr_depth < options.m_max_depth)
|
|
{
|
|
// We will show children for all concrete types. We won't show
|
|
// pointer contents unless a pointer depth has been specified.
|
|
// We won't reference contents unless the reference is the
|
|
// root object (depth of zero).
|
|
|
|
// Use a new temporary pointer depth in case we override the
|
|
// current pointer depth below...
|
|
|
|
if (is_ptr || is_ref)
|
|
{
|
|
// We have a pointer or reference whose value is an address.
|
|
// Make sure that address is not NULL
|
|
AddressType ptr_address_type;
|
|
if (m_valobj->GetPointerValue (&ptr_address_type) == 0)
|
|
return false;
|
|
|
|
else if (is_ref && m_curr_depth == 0 && curr_ptr_depth == 0)
|
|
{
|
|
// If this is the root object (depth is zero) that we are showing
|
|
// and it is a reference, and no pointer depth has been supplied
|
|
// print out what it references. Don't do this at deeper depths
|
|
// otherwise we can end up with infinite recursion...
|
|
curr_ptr_depth = 1;
|
|
}
|
|
|
|
return (curr_ptr_depth > 0);
|
|
}
|
|
|
|
TypeSummaryImpl* entry = GetSummaryFormatter();
|
|
|
|
return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ValueObject*
|
|
ValueObjectPrinter::GetValueObjectForChildrenGeneration ()
|
|
{
|
|
ValueObjectSP synth_valobj_sp = m_valobj->GetSyntheticValue (options.m_use_synthetic);
|
|
return (synth_valobj_sp ? synth_valobj_sp.get() : m_valobj);
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::PrintChildrenPreamble ()
|
|
{
|
|
if (options.m_flat_output)
|
|
{
|
|
if (ShouldPrintValueObject())
|
|
m_stream->EOL();
|
|
}
|
|
else
|
|
{
|
|
if (ShouldPrintValueObject())
|
|
m_stream->PutCString(IsRef () ? ": {\n" : " {\n");
|
|
m_stream->IndentMore();
|
|
}
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::PrintChild (ValueObjectSP child_sp,
|
|
uint32_t curr_ptr_depth)
|
|
{
|
|
DumpValueObjectOptions child_options(options);
|
|
child_options.SetFormat(options.m_format).SetSummary().SetRootValueObjectName();
|
|
child_options.SetScopeChecked(true).SetHideName(options.m_hide_name).SetHideValue(options.m_hide_value)
|
|
.SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1 ? child_options.m_omit_summary_depth - 1 : 0);
|
|
if (child_sp.get())
|
|
{
|
|
ValueObjectPrinter child_printer(child_sp.get(),
|
|
m_stream,
|
|
child_options,
|
|
(IsPtr() || IsRef()) && curr_ptr_depth >= 1 ? curr_ptr_depth - 1 : curr_ptr_depth,
|
|
m_curr_depth + 1);
|
|
child_printer.PrintValueObject();
|
|
}
|
|
|
|
}
|
|
|
|
uint32_t
|
|
ValueObjectPrinter::GetMaxNumChildrenToPrint (bool& print_dotdotdot)
|
|
{
|
|
ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
size_t num_children = synth_m_valobj->GetNumChildren();
|
|
print_dotdotdot = false;
|
|
if (num_children)
|
|
{
|
|
const size_t max_num_children = m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
|
|
|
|
if (num_children > max_num_children && !options.m_ignore_cap)
|
|
{
|
|
print_dotdotdot = true;
|
|
return max_num_children;
|
|
}
|
|
}
|
|
return num_children;
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::PrintChildrenPostamble (bool print_dotdotdot)
|
|
{
|
|
if (!options.m_flat_output)
|
|
{
|
|
if (print_dotdotdot)
|
|
{
|
|
m_valobj->GetTargetSP()->GetDebugger().GetCommandInterpreter().ChildrenTruncated();
|
|
m_stream->Indent("...\n");
|
|
}
|
|
m_stream->IndentLess();
|
|
m_stream->Indent("}\n");
|
|
}
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::PrintChildren (uint32_t curr_ptr_depth)
|
|
{
|
|
ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
bool print_dotdotdot = false;
|
|
size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
|
|
if (num_children)
|
|
{
|
|
PrintChildrenPreamble ();
|
|
|
|
for (size_t idx=0; idx<num_children; ++idx)
|
|
{
|
|
ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
|
|
PrintChild (child_sp, curr_ptr_depth);
|
|
}
|
|
|
|
PrintChildrenPostamble (print_dotdotdot);
|
|
}
|
|
else if (IsAggregate())
|
|
{
|
|
// Aggregate, no children...
|
|
if (ShouldPrintValueObject())
|
|
m_stream->PutCString(" {}\n");
|
|
}
|
|
else
|
|
{
|
|
if (ShouldPrintValueObject())
|
|
m_stream->EOL();
|
|
}
|
|
}
|
|
|
|
bool
|
|
ValueObjectPrinter::PrintChildrenOneLiner (bool hide_names)
|
|
{
|
|
if (!GetDynamicValueIfNeeded () || m_valobj == nullptr)
|
|
return false;
|
|
|
|
ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
|
|
|
|
bool print_dotdotdot = false;
|
|
size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
|
|
|
|
if (num_children)
|
|
{
|
|
m_stream->PutChar('(');
|
|
|
|
for (uint32_t idx=0; idx<num_children; ++idx)
|
|
{
|
|
lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
|
|
lldb::ValueObjectSP child_dyn_sp = child_sp.get() ? child_sp->GetDynamicValue(options.m_use_dynamic) : child_sp;
|
|
if (child_dyn_sp)
|
|
child_sp = child_dyn_sp;
|
|
if (child_sp)
|
|
{
|
|
if (idx)
|
|
m_stream->PutCString(", ");
|
|
if (!hide_names)
|
|
{
|
|
const char* name = child_sp.get()->GetName().AsCString();
|
|
if (name && *name)
|
|
{
|
|
m_stream->PutCString(name);
|
|
m_stream->PutCString(" = ");
|
|
}
|
|
}
|
|
child_sp->DumpPrintableRepresentation(*m_stream,
|
|
ValueObject::eValueObjectRepresentationStyleSummary,
|
|
lldb::eFormatInvalid,
|
|
ValueObject::ePrintableRepresentationSpecialCasesDisable);
|
|
}
|
|
}
|
|
|
|
if (print_dotdotdot)
|
|
m_stream->PutCString(", ...)");
|
|
else
|
|
m_stream->PutChar(')');
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
ValueObjectPrinter::PrintChildrenIfNeeded (bool value_printed,
|
|
bool summary_printed)
|
|
{
|
|
// this flag controls whether we tried to display a description for this object and failed
|
|
// if that happens, we want to display the children, if any
|
|
bool is_failed_description = !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
|
|
|
|
uint32_t curr_ptr_depth = m_ptr_depth;
|
|
bool print_children = ShouldPrintChildren (is_failed_description,curr_ptr_depth);
|
|
bool print_oneline = (curr_ptr_depth > 0 || options.m_show_types || options.m_be_raw) ? false : DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
|
|
|
|
if (print_children)
|
|
{
|
|
if (print_oneline)
|
|
{
|
|
m_stream->PutChar(' ');
|
|
PrintChildrenOneLiner (false);
|
|
m_stream->EOL();
|
|
}
|
|
else
|
|
PrintChildren (curr_ptr_depth);
|
|
}
|
|
else if (m_curr_depth >= options.m_max_depth && IsAggregate() && ShouldPrintValueObject())
|
|
{
|
|
m_stream->PutCString("{...}\n");
|
|
}
|
|
else
|
|
m_stream->EOL();
|
|
}
|