Add a new disassembly-format specification so that the disassembler
output style can be customized. Change the built-in default to be
more similar to gdb's disassembly formatting.
The disassembly-format for a gdb-like output is
${addr-file-or-load} <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>:
The disassembly-format for the lldb style output is
{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
The two backticks in the lldb style formatter triggers the sub-expression evaluation in
CommandInterpreter::PreprocessCommand() so you can't use that one as-is ... changing to
use ' characters instead of ` would work around that.
<rdar://problem/9885398>
llvm-svn: 219544
diff --git a/lldb/source/Core/Address.cpp b/lldb/source/Core/Address.cpp
index fa9197d..8f5e19f 100644
--- a/lldb/source/Core/Address.cpp
+++ b/lldb/source/Core/Address.cpp
@@ -465,6 +465,7 @@
case DumpStyleResolvedDescription:
case DumpStyleResolvedDescriptionNoModule:
+ case DumpStyleResolvedDescriptionNoFunctionArguments:
if (IsSectionOffset())
{
uint32_t pointer_size = 4;
@@ -550,7 +551,7 @@
#endif
Address cstr_addr(*this);
cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
- func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false);
+ func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false, true);
if (ReadAddress (exe_scope, cstr_addr, pointer_size, so_addr))
{
#if VERBOSE_OUTPUT
@@ -633,7 +634,7 @@
if (pointer_sc.function || pointer_sc.symbol)
{
s->PutCString(": ");
- pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false);
+ pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false, true);
}
}
}
@@ -658,6 +659,7 @@
const bool show_module = (style == DumpStyleResolvedDescription);
const bool show_fullpaths = false;
const bool show_inlined_frames = true;
+ const bool show_function_arguments = (style != DumpStyleResolvedDescriptionNoFunctionArguments);
if (sc.function == NULL && sc.symbol != NULL)
{
// If we have just a symbol make sure it is in the right section
@@ -679,7 +681,8 @@
*this,
show_fullpaths,
show_module,
- show_inlined_frames);
+ show_inlined_frames,
+ show_function_arguments);
}
else
{
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
index 5fb60cf..5a910a9 100644
--- a/lldb/source/Core/Debugger.cpp
+++ b/lldb/source/Core/Debugger.cpp
@@ -45,6 +45,8 @@
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/CPPLanguageRuntime.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/TargetList.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
@@ -122,12 +124,14 @@
FILE_AND_LINE\
"\\n"
+#define DEFAULT_DISASSEMBLY_FORMAT "${addr-file-or-load} <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>: "
static PropertyDefinition
g_properties[] =
{
{ "auto-confirm", OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." },
+{ "disassembly-format", OptionValue::eTypeString , true, 0 , DEFAULT_DISASSEMBLY_FORMAT, NULL, "The default disassembly format string to use when disassembling instruction sequences." },
{ "frame-format", OptionValue::eTypeString , true, 0 , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." },
{ "notify-void", OptionValue::eTypeBoolean, true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." },
{ "prompt", OptionValue::eTypeString , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." },
@@ -148,6 +152,7 @@
enum
{
ePropertyAutoConfirm = 0,
+ ePropertyDisassemblyFormat,
ePropertyFrameFormat,
ePropertyNotiftVoid,
ePropertyPrompt,
@@ -231,6 +236,13 @@
}
const char *
+Debugger::GetDisassemblyFormat() const
+{
+ const uint32_t idx = ePropertyDisassemblyFormat;
+ return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
+}
+
+const char *
Debugger::GetFrameFormat() const
{
const uint32_t idx = ePropertyFrameFormat;
@@ -1128,6 +1140,8 @@
StreamString s;
const char *prompt_format =
"{addr = '${addr}'\n}"
+ "{addr-file-or-load = '${addr-file-or-load}'\n}"
+ "{current-pc-arrow = '${current-pc-arrow}'\n}"
"{process.id = '${process.id}'\n}"
"{process.name = '${process.name}'\n}"
"{process.file.basename = '${process.file.basename}'\n}"
@@ -1155,9 +1169,13 @@
"{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}"
"{frame.reg.carp = '${frame.reg.carp}'\n}"
"{function.id = '${function.id}'\n}"
+ "{function.changed = '${function.changed}'\n}"
+ "{function.initial-function = '${function.initial-function}'\n}"
"{function.name = '${function.name}'\n}"
+ "{function.name-without-args = '${function.name-without-args}'\n}"
"{function.name-with-args = '${function.name-with-args}'\n}"
"{function.addr-offset = '${function.addr-offset}'\n}"
+ "{function.concrete-only-addr-offset-no-padding = '${function.concrete-only-addr-offset-no-padding}'\n}"
"{function.line-offset = '${function.line-offset}'\n}"
"{function.pc-offset = '${function.pc-offset}'\n}"
"{line.file.basename = '${line.file.basename}'\n}"
@@ -1555,7 +1573,9 @@
const Address *addr,
Stream &s,
const char **end,
- ValueObject* valobj
+ ValueObject* valobj,
+ bool function_changed,
+ bool initial_function
)
{
ValueObject* realvalobj = NULL; // makes it super-easy to parse pointers
@@ -1597,7 +1617,7 @@
++p; // Skip the '{'
- if (FormatPromptRecurse (p, sc, exe_ctx, addr, sub_strm, &p, valobj))
+ if (FormatPromptRecurse (p, sc, exe_ctx, addr, sub_strm, &p, valobj, function_changed, initial_function))
{
// The stream had all it needed
s.Write(sub_strm.GetData(), sub_strm.GetSize());
@@ -1631,6 +1651,12 @@
const char *cstr = NULL;
std::string token_format;
Address format_addr;
+
+ // normally "addr" means print a raw address but
+ // "file-addr-or-load-addr" means print a module + file addr if there's no load addr
+ bool print_file_addr_or_load_addr = false;
+ bool addr_offset_concrete_func_only = false;
+ bool addr_offset_print_with_no_padding = false;
bool calculate_format_addr_function_offset = false;
// Set reg_kind and reg_num to invalid values
RegisterKind reg_kind = kNumRegisterKinds;
@@ -1941,7 +1967,7 @@
if (!special_directions)
var_success &= item->DumpPrintableRepresentation(s,val_obj_display, custom_format);
else
- var_success &= FormatPromptRecurse(special_directions, sc, exe_ctx, addr, s, NULL, item);
+ var_success &= FormatPromptRecurse(special_directions, sc, exe_ctx, addr, s, NULL, item, function_changed, initial_function);
if (--max_num_children == 0)
{
@@ -1957,7 +1983,12 @@
}
break;
case 'a':
- if (IsToken (var_name_begin, "addr}"))
+ if (IsToken (var_name_begin, "addr-file-or-load}"))
+ {
+ print_file_addr_or_load_addr = true;
+ }
+ if (IsToken (var_name_begin, "addr}")
+ || IsToken (var_name_begin, "addr-file-or-load}"))
{
if (addr && addr->IsValid())
{
@@ -2159,8 +2190,7 @@
}
}
break;
-
-
+
case 'm':
if (IsToken (var_name_begin, "module."))
{
@@ -2288,6 +2318,14 @@
var_success = true;
}
+ if (IsToken (var_name_begin, "changed}") && function_changed)
+ {
+ var_success = true;
+ }
+ if (IsToken (var_name_begin, "initial-function}") && initial_function)
+ {
+ var_success = true;
+ }
else if (IsToken (var_name_begin, "name}"))
{
if (sc->function)
@@ -2314,6 +2352,19 @@
var_success = true;
}
}
+ else if (IsToken (var_name_begin, "name-without-args}"))
+ {
+ ConstString name;
+ if (sc->function)
+ name = sc->function->GetMangled().GetName (Mangled::ePreferDemangledWithoutArguments);
+ else if (sc->symbol)
+ name = sc->symbol->GetMangled().GetName (Mangled::ePreferDemangledWithoutArguments);
+ if (name)
+ {
+ s.PutCString(name.GetCString());
+ var_success = true;
+ }
+ }
else if (IsToken (var_name_begin, "name-with-args}"))
{
// Print the function name with arguments in it
@@ -2457,8 +2508,14 @@
}
}
}
- else if (IsToken (var_name_begin, "addr-offset}"))
+ else if (IsToken (var_name_begin, "addr-offset}")
+ || IsToken (var_name_begin, "concrete-only-addr-offset-no-padding}"))
{
+ if (IsToken (var_name_begin, "concrete-only-addr-offset-no-padding}"))
+ {
+ addr_offset_print_with_no_padding = true;
+ addr_offset_concrete_func_only = true;
+ }
var_success = addr != NULL;
if (var_success)
{
@@ -2529,6 +2586,34 @@
}
}
break;
+ case 'c':
+ if (IsToken (var_name_begin, "current-pc-arrow"))
+ {
+ if (addr && exe_ctx && exe_ctx->GetFramePtr())
+ {
+ RegisterContextSP reg_ctx = exe_ctx->GetFramePtr()->GetRegisterContextSP();
+ if (reg_ctx.get())
+ {
+ addr_t pc_loadaddr = reg_ctx->GetPC();
+ if (pc_loadaddr != LLDB_INVALID_ADDRESS)
+ {
+ Address pc;
+ pc.SetLoadAddress (pc_loadaddr, exe_ctx->GetTargetPtr());
+ if (pc == *addr)
+ {
+ s.Printf ("->");
+ var_success = true;
+ }
+ else
+ {
+ s.Printf(" ");
+ var_success = true;
+ }
+ }
+ }
+ }
+ }
+ break;
}
if (var_success)
@@ -2586,7 +2671,7 @@
if (sc->function)
{
func_addr = sc->function->GetAddressRange().GetBaseAddress();
- if (sc->block)
+ if (sc->block && addr_offset_concrete_func_only == false)
{
// Check to make sure we aren't in an inline
// function. If we are, use the inline block
@@ -2604,14 +2689,19 @@
if (func_addr.IsValid())
{
+ const char *addr_offset_padding = " ";
+ if (addr_offset_print_with_no_padding)
+ {
+ addr_offset_padding = "";
+ }
if (func_addr.GetSection() == format_addr.GetSection())
{
addr_t func_file_addr = func_addr.GetFileAddress();
addr_t addr_file_addr = format_addr.GetFileAddress();
if (addr_file_addr > func_file_addr)
- s.Printf(" + %" PRIu64, addr_file_addr - func_file_addr);
+ s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding, addr_file_addr - func_file_addr);
else if (addr_file_addr < func_file_addr)
- s.Printf(" - %" PRIu64, func_file_addr - addr_file_addr);
+ s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding, func_file_addr - addr_file_addr);
var_success = true;
}
else
@@ -2622,9 +2712,9 @@
addr_t func_load_addr = func_addr.GetLoadAddress (target);
addr_t addr_load_addr = format_addr.GetLoadAddress (target);
if (addr_load_addr > func_load_addr)
- s.Printf(" + %" PRIu64, addr_load_addr - func_load_addr);
+ s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding, addr_load_addr - func_load_addr);
else if (addr_load_addr < func_load_addr)
- s.Printf(" - %" PRIu64, func_load_addr - addr_load_addr);
+ s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding, func_load_addr - addr_load_addr);
var_success = true;
}
}
@@ -2641,10 +2731,21 @@
if (vaddr != LLDB_INVALID_ADDRESS)
{
- int addr_width = target->GetArchitecture().GetAddressByteSize() * 2;
+ int addr_width = 0;
+ if (exe_ctx && target)
+ {
+ target->GetArchitecture().GetAddressByteSize() * 2;
+ }
if (addr_width == 0)
addr_width = 16;
- s.Printf("0x%*.*" PRIx64, addr_width, addr_width, vaddr);
+ if (print_file_addr_or_load_addr)
+ {
+ format_addr.Dump (&s, exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress, 0);
+ }
+ else
+ {
+ s.Printf("0x%*.*" PRIx64, addr_width, addr_width, vaddr);
+ }
var_success = true;
}
}
@@ -2758,9 +2859,55 @@
std::string format_str = lldb_utility::ansi::FormatAnsiTerminalCodes (format, use_color);
if (format_str.length())
format = format_str.c_str();
- return FormatPromptRecurse (format, sc, exe_ctx, addr, s, NULL, valobj);
+ return FormatPromptRecurse (format, sc, exe_ctx, addr, s, NULL, valobj, false, false);
}
+bool
+Debugger::FormatDisassemblerAddress (const char *format,
+ const SymbolContext *sc,
+ const SymbolContext *prev_sc,
+ const ExecutionContext *exe_ctx,
+ const Address *addr,
+ Stream &s)
+{
+ if (format == NULL && exe_ctx != NULL && exe_ctx->HasTargetScope())
+ {
+ format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
+ }
+ bool function_changed = false;
+ bool initial_function = false;
+ if (prev_sc && (prev_sc->function || prev_sc->symbol))
+ {
+ if (sc && (sc->function || sc->symbol))
+ {
+ if (prev_sc->symbol && sc->symbol)
+ {
+ if (!sc->symbol->Compare (prev_sc->symbol->GetName(), prev_sc->symbol->GetType()))
+ {
+ function_changed = true;
+ }
+ }
+ else if (prev_sc->function && sc->function)
+ {
+ if (prev_sc->function->GetMangled() != sc->function->GetMangled())
+ {
+ function_changed = true;
+ }
+ }
+ }
+ }
+ // The first context on a list of instructions will have a prev_sc that
+ // has no Function or Symbol -- if SymbolContext had an IsValid() method, it
+ // would return false. But we do get a prev_sc pointer.
+ if ((sc && (sc->function || sc->symbol))
+ && prev_sc && (prev_sc->function == NULL && prev_sc->symbol == NULL))
+ {
+ initial_function = true;
+ }
+ return FormatPromptRecurse (format, sc, exe_ctx, addr, s, NULL, NULL, function_changed, initial_function);
+}
+
+
void
Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
{
diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index 1d2b8cf..649f0c5 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -410,17 +410,18 @@
SymbolContext prev_sc;
AddressRange sc_range;
const Address *pc_addr_ptr = NULL;
- ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope();
StackFrame *frame = exe_ctx.GetFramePtr();
TargetSP target_sp (exe_ctx.GetTargetSP());
SourceManager &source_manager = target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager();
if (frame)
+ {
pc_addr_ptr = &frame->GetFrameCodeAddress();
+ }
const uint32_t scope = eSymbolContextLineEntry | eSymbolContextFunction | eSymbolContextSymbol;
const bool use_inline_block_range = false;
- for (size_t i=0; i<num_instructions_found; ++i)
+ for (size_t i = 0; i < num_instructions_found; ++i)
{
Instruction *inst = disasm_ptr->GetInstructionList().GetInstructionAtIndex (i).get();
if (inst)
@@ -447,7 +448,7 @@
if (offset != 0)
strm.EOL();
- sc.DumpStopContext(&strm, exe_ctx.GetProcessPtr(), addr, false, true, false);
+ sc.DumpStopContext(&strm, exe_ctx.GetProcessPtr(), addr, false, true, false, false);
strm.EOL();
if (sc.comp_unit && sc.line_entry.IsValid())
@@ -462,23 +463,6 @@
}
}
}
- else if ((sc.function || sc.symbol) && (sc.function != prev_sc.function || sc.symbol != prev_sc.symbol))
- {
- if (prev_sc.function || prev_sc.symbol)
- strm.EOL();
-
- bool show_fullpaths = false;
- bool show_module = true;
- bool show_inlined_frames = true;
- sc.DumpStopContext (&strm,
- exe_scope,
- addr,
- show_fullpaths,
- show_module,
- show_inlined_frames);
-
- strm << ":\n";
- }
}
else
{
@@ -486,12 +470,13 @@
}
}
- if ((options & eOptionMarkPCAddress) && pc_addr_ptr)
- {
- strm.PutCString(inst_is_at_pc ? "-> " : " ");
- }
const bool show_bytes = (options & eOptionShowBytes) != 0;
- inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx);
+ const char *disassembly_format = "${addr-file-or-load}: ";
+ if (exe_ctx.HasTargetScope())
+ {
+ disassembly_format = exe_ctx.GetTargetRef().GetDebugger().GetDisassemblyFormat ();
+ }
+ inst->Dump (&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc, &prev_sc, disassembly_format);
strm.EOL();
}
else
@@ -578,7 +563,10 @@
uint32_t max_opcode_byte_size,
bool show_address,
bool show_bytes,
- const ExecutionContext* exe_ctx)
+ const ExecutionContext* exe_ctx,
+ const SymbolContext *sym_ctx,
+ const SymbolContext *prev_sym_ctx,
+ const char *disassembly_addr_format_spec)
{
size_t opcode_column_width = 7;
const size_t operand_column_width = 25;
@@ -589,13 +577,7 @@
if (show_address)
{
- m_address.Dump(&ss,
- exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL,
- Address::DumpStyleLoadAddress,
- Address::DumpStyleModuleWithFileAddress,
- 0);
-
- ss.PutCString(": ");
+ Debugger::FormatDisassemblerAddress (disassembly_addr_format_spec, sym_ctx, prev_sym_ctx, exe_ctx, &m_address, ss);
}
if (show_bytes)
@@ -621,7 +603,7 @@
}
}
- const size_t opcode_pos = ss.GetSize();
+ const size_t opcode_pos = ss.GetSizeOfLastLine();
// The default opcode size of 7 characters is plenty for most architectures
// but some like arm can pull out the occasional vqrshrun.s16. We won't get
@@ -1003,13 +985,18 @@
{
const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize();
collection::const_iterator pos, begin, end;
+ const char *disassemble_format = "${addr-file-or-load}: ";
+ if (exe_ctx)
+ {
+ disassemble_format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat ();
+ }
for (begin = m_instructions.begin(), end = m_instructions.end(), pos = begin;
pos != end;
++pos)
{
if (pos != begin)
s->EOL();
- (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx);
+ (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx, NULL, NULL, disassemble_format);
}
}
diff --git a/lldb/source/Core/Mangled.cpp b/lldb/source/Core/Mangled.cpp
index c4fa10f..a7dbc5f 100644
--- a/lldb/source/Core/Mangled.cpp
+++ b/lldb/source/Core/Mangled.cpp
@@ -4986,10 +4986,12 @@
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Timer.h"
+#include "lldb/Target/CPPLanguageRuntime.h"
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
+
using namespace lldb_private;
static inline bool
@@ -5000,6 +5002,58 @@
return false;
}
+static const ConstString &
+get_demangled_name_without_arguments (const Mangled *obj)
+{
+ // This pair is <mangled name, demangled name without function arguments>
+ static std::pair<ConstString, ConstString> g_most_recent_mangled_to_name_sans_args;
+
+ // Need to have the mangled & demangled names we're currently examining as statics
+ // so we can return a const ref to them at the end of the func if we don't have
+ // anything better.
+ static ConstString g_last_mangled;
+ static ConstString g_last_demangled;
+
+ ConstString mangled = obj->GetMangledName ();
+ ConstString demangled = obj->GetDemangledName ();
+
+ if (mangled && g_most_recent_mangled_to_name_sans_args.first == mangled)
+ {
+ return g_most_recent_mangled_to_name_sans_args.second;
+ }
+
+ g_last_demangled = demangled;
+ g_last_mangled = mangled;
+
+ const char *mangled_name_cstr = mangled.GetCString();
+ const char *demangled_name_cstr = demangled.GetCString();
+
+ if (demangled && mangled_name_cstr && mangled_name_cstr[0])
+ {
+ if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
+ (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure, typeinfo structure, and typeinfo mangled_name
+ mangled_name_cstr[2] != 'G' && // avoid guard variables
+ mangled_name_cstr[2] != 'Z')) // named local entities (if we eventually handle eSymbolTypeData, we will want this back)
+ {
+ CPPLanguageRuntime::MethodName cxx_method (demangled);
+ if (!cxx_method.GetBasename().empty() && !cxx_method.GetContext().empty())
+ {
+ std::string shortname = cxx_method.GetContext().str();
+ shortname += "::";
+ shortname += cxx_method.GetBasename().str();
+ ConstString result(shortname.c_str());
+ g_most_recent_mangled_to_name_sans_args.first = mangled;
+ g_most_recent_mangled_to_name_sans_args.second = result;
+ return g_most_recent_mangled_to_name_sans_args.second;
+ }
+ }
+ }
+
+ if (demangled)
+ return g_last_demangled;
+ return g_last_mangled;
+}
+
#pragma mark Mangled
//----------------------------------------------------------------------
// Default constructor
@@ -5215,6 +5269,14 @@
const ConstString&
Mangled::GetName (Mangled::NamePreference preference) const
{
+ if (preference == ePreferDemangledWithoutArguments)
+ {
+ // Call the accessor to make sure we get a demangled name in case
+ // it hasn't been demangled yet...
+ GetDemangledName();
+
+ return get_demangled_name_without_arguments (this);
+ }
if (preference == ePreferDemangled)
{
// Call the accessor to make sure we get a demangled name in case
diff --git a/lldb/source/Core/StreamString.cpp b/lldb/source/Core/StreamString.cpp
index 8d7d039..ef2b705 100644
--- a/lldb/source/Core/StreamString.cpp
+++ b/lldb/source/Core/StreamString.cpp
@@ -65,6 +65,22 @@
return m_packet.size();
}
+size_t
+StreamString::GetSizeOfLastLine () const
+{
+ const size_t length = m_packet.size();
+ size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
+ if (last_line_begin_pos == std::string::npos)
+ {
+ return length;
+ }
+ else
+ {
+ ++last_line_begin_pos;
+ return length - last_line_begin_pos;
+ }
+}
+
std::string &
StreamString::GetString()
{