nemiver r722 - in trunk: . src/dbgengine
- From: dodji svn gnome org
- To: svn-commits-list gnome org
- Subject: nemiver r722 - in trunk: . src/dbgengine
- Date: Sun, 3 Feb 2008 11:05:46 +0000 (GMT)
Author: dodji
Date: Sun Feb 3 11:05:46 2008
New Revision: 722
URL: http://svn.gnome.org/viewvc/nemiver?rev=722&view=rev
Log:
[gdbmi-parser] make memory/register handling comply with project coding style
Modified:
trunk/ChangeLog
trunk/src/dbgengine/nmv-gdbmi-parser.cc
Modified: trunk/src/dbgengine/nmv-gdbmi-parser.cc
==============================================================================
--- trunk/src/dbgengine/nmv-gdbmi-parser.cc (original)
+++ trunk/src/dbgengine/nmv-gdbmi-parser.cc Sun Feb 3 11:05:46 2008
@@ -25,14 +25,14 @@
#include <sstream>
#include "nmv-gdbmi-parser.h"
-using nemiver::common::UString ;
+using nemiver::common::UString;
static const UString GDBMI_PARSING_DOMAIN = "gdbmi-parsing-domain";
-static const UString GDBMI_OUTPUT_DOMAIN = "gdbmi-output-domain" ;
+static const UString GDBMI_OUTPUT_DOMAIN = "gdbmi-output-domain";
#define LOG_PARSING_ERROR(a_buf, a_from) \
{ \
-Glib::ustring str_01 (a_buf, (a_from), a_buf.size () - (a_from)) ;\
+Glib::ustring str_01 (a_buf, (a_from), a_buf.size () - (a_from));\
LOG_ERROR ("parsing failed for buf: >>>" \
<< a_buf << "<<<" \
<< " cur index was: " << (int)(a_from)); \
@@ -40,30 +40,30 @@
#define CHECK_END(a_input, a_current, a_end) \
if ((a_current) >= (a_end)) {\
-LOG_ERROR ("hit end index " << (int) a_end) ; \
-return false ;\
+LOG_ERROR ("hit end index " << (int) a_end); \
+return false;\
}
#define CHECK_END_BREAK(a_input, a_current, a_end) \
if ((a_current) >= (a_end)) {\
-LOG_ERROR ("hit end index " << (int) a_end) ; \
-G_BREAKPOINT() ;\
+LOG_ERROR ("hit end index " << (int) a_end); \
+G_BREAKPOINT();\
}
#define SKIP_WS(a_input, a_from, a_to) \
while (a_from < a_input.bytes () && isspace (a_input.c_str ()[a_from])) { \
CHECK_END (a_input, a_from, end);++a_from; \
} \
-a_to = a_from ;
+a_to = a_from;
#define SKIP_BLANK(a_input, a_from, a_to) \
while (a_from < a_input.bytes () && isblank (a_input.c_str ()[a_from])) { \
CHECK_END (a_input, a_from, end);++a_from; \
} \
-a_to = a_from ;
+a_to = a_from;
-using namespace std ;
-using namespace nemiver::common ;
+using namespace std;
+using namespace nemiver::common;
NEMIVER_BEGIN_NAMESPACE (nemiver)
@@ -92,9 +92,9 @@
bool parse_c_string_body (const UString &a_input,
UString::size_type a_from,
UString::size_type &a_to,
- UString &a_string) ;
+ UString &a_string);
-static bool is_string_start (gunichar a_c) ;
+static bool is_string_start (gunichar a_c);
bool
parse_attribute (const UString &a_input,
@@ -103,21 +103,21 @@
UString &a_name,
UString &a_value)
{
- UString::size_type cur = a_from, end = a_input.size () ;
+ UString::size_type cur = a_from, end = a_input.size ();
if (cur >= end || !is_string_start (a_input.c_str ()[cur])) {return false;}
- GDBMIResultSafePtr result ;
+ GDBMIResultSafePtr result;
if (!parse_gdbmi_result (a_input, cur, a_to, result)
|| !result
|| !result->value ()
|| result->value ()->content_type () != GDBMIValue::STRING_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_name = result->variable () ;
- a_value = result->value ()->get_string_content () ;
- return true ;
+ a_name = result->variable ();
+ a_value = result->value ()->get_string_content ();
+ return true;
}
/// \brief parses an attribute list
@@ -132,26 +132,26 @@
UString::size_type &a_to,
map<UString, UString> &a_attrs)
{
- UString::size_type cur = a_from, end = a_input.size () ;
+ UString::size_type cur = a_from, end = a_input.size ();
if (cur == end) {return false;}
- UString name, value ;
- map<UString, UString> attrs ;
+ UString name, value;
+ map<UString, UString> attrs;
while (true) {
- if (!parse_attribute (a_input, cur, cur, name, value)) {break ;}
+ if (!parse_attribute (a_input, cur, cur, name, value)) {break;}
if (!name.empty () && !value.empty ()) {
- attrs[name] = value ;
- name.clear (); value.clear () ;
+ attrs[name] = value;
+ name.clear (); value.clear ();
}
- while (isspace (a_input[cur])) {++cur ;}
+ while (isspace (a_input[cur])) {++cur;}
if (cur >= end || a_input[cur] != ',') {break;}
if (++cur >= end) {break;}
}
- a_attrs = attrs ;
- a_to = cur ;
- return true ;
+ a_attrs = attrs;
+ a_to = cur;
+ return true;
}
/// \brief parses a breakpoint definition as returned by gdb.
@@ -173,61 +173,61 @@
Glib::ustring::size_type &a_to,
IDebugger::BreakPoint &a_bkpt)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- Glib::ustring::size_type cur = a_from, end = a_input.size () ;
+ Glib::ustring::size_type cur = a_from, end = a_input.size ();
if (a_input.compare (cur, strlen (PREFIX_BKPT), PREFIX_BKPT)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur += 6 ;
+ cur += 6;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- map<UString, UString> attrs ;
- bool is_ok = parse_attributes (a_input, cur, cur, attrs) ;
+ map<UString, UString> attrs;
+ bool is_ok = parse_attributes (a_input, cur, cur, attrs);
if (!is_ok) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input.c_str ()[cur] != '}') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- ++cur ;
+ ++cur;
if (attrs["addr"] == "<PENDING>") {
- UString pending = attrs["pending"] ;
+ UString pending = attrs["pending"];
if (pending == "") {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
LOG_D ("got pending breakpoint: '" << pending << "'",
- GDBMI_OUTPUT_DOMAIN) ;
- vector<UString> str_tab = pending.split (":") ;
- LOG_D ("filepath: '" << str_tab[0] << "'", GDBMI_OUTPUT_DOMAIN) ;
- LOG_D ("linenum: '" << str_tab[1] << "'", GDBMI_OUTPUT_DOMAIN) ;
+ GDBMI_OUTPUT_DOMAIN);
+ vector<UString> str_tab = pending.split (":");
+ LOG_D ("filepath: '" << str_tab[0] << "'", GDBMI_OUTPUT_DOMAIN);
+ LOG_D ("linenum: '" << str_tab[1] << "'", GDBMI_OUTPUT_DOMAIN);
if (str_tab.size () != 2) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- string path = Glib::locale_from_utf8 (str_tab[0]) ;
+ string path = Glib::locale_from_utf8 (str_tab[0]);
if (Glib::path_is_absolute (path)) {
attrs["file"] = Glib::locale_to_utf8
- (Glib::path_get_basename (path)) ;
- attrs["fullname"] = Glib::locale_to_utf8 (path) ;
+ (Glib::path_get_basename (path));
+ attrs["fullname"] = Glib::locale_to_utf8 (path);
} else {
- attrs["file"] = Glib::locale_to_utf8 (path) ;;
+ attrs["file"] = Glib::locale_to_utf8 (path);;
}
- attrs["line"] = str_tab[1] ;
+ attrs["line"] = str_tab[1];
}
- map<UString, UString>::iterator iter, null_iter = attrs.end () ;
+ map<UString, UString>::iterator iter, null_iter = attrs.end ();
//we use to require that the "fullname" property be present as
//well, but it seems that a lot debug info set got shipped without
//that property. Client code should do what they can with the
@@ -241,30 +241,30 @@
//|| (iter = attrs.find ("line"))== null_iter => ditto
|| (iter = attrs.find ("times")) == null_iter
) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_bkpt.number (atoi (attrs["number"].c_str ())) ;
+ a_bkpt.number (atoi (attrs["number"].c_str ()));
if (attrs["enabled"] == "y") {
- a_bkpt.enabled (true) ;
+ a_bkpt.enabled (true);
} else {
- a_bkpt.enabled (false) ;
+ a_bkpt.enabled (false);
}
- a_bkpt.address (attrs["addr"]) ;
+ a_bkpt.address (attrs["addr"]);
if (!attrs["func"].empty ()) {
- a_bkpt.function (attrs["func"]) ;
+ a_bkpt.function (attrs["func"]);
} else if (!attrs["what"].empty ()) {
// catchpoints don't have a 'func' field, but they have a 'what' field
// that says something like "Exception throw"
- a_bkpt.function (attrs["what"]) ;
+ a_bkpt.function (attrs["what"]);
}
- a_bkpt.file_name (attrs["file"]) ; //may be nil
- a_bkpt.file_full_name (attrs["fullname"]) ; //may be nil
- a_bkpt.line (atoi (attrs["line"].c_str ())) ; //may be nil
+ a_bkpt.file_name (attrs["file"]); //may be nil
+ a_bkpt.file_full_name (attrs["fullname"]); //may be nil
+ a_bkpt.line (atoi (attrs["line"].c_str ())); //may be nil
//TODO: get the 'at' attribute that is present on targets that
//are not compiled with -g.
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -274,80 +274,80 @@
UString::size_type &a_to,
map<int, IDebugger::BreakPoint> &a_breakpoints)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur=a_from, end=a_input.bytes () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur=a_from, end=a_input.bytes ();
if (a_input.compare (cur, strlen (PREFIX_BREAKPOINT_TABLE), PREFIX_BREAKPOINT_TABLE)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur += strlen (PREFIX_BREAKPOINT_TABLE) ;
+ cur += strlen (PREFIX_BREAKPOINT_TABLE);
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
//skip table headers and go to table body.
- cur = a_input.find ("body=[", 0) ;
+ cur = a_input.find ("body=[", 0) ;
if (!cur) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur += 6 ;
+ cur += 6;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- map<int, IDebugger::BreakPoint> breakpoint_table ;
+ map<int, IDebugger::BreakPoint> breakpoint_table;
if (a_input.c_str ()[cur] == ']') {
//there are zero breakpoints ...
} else if (!a_input.compare (cur, strlen (PREFIX_BKPT), PREFIX_BKPT)){
//there are some breakpoints
- IDebugger::BreakPoint breakpoint ;
+ IDebugger::BreakPoint breakpoint;
while (true) {
if (a_input.compare (cur, strlen (PREFIX_BKPT), PREFIX_BKPT)) {break;}
if (!parse_breakpoint (a_input, cur, cur, breakpoint)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- breakpoint_table[breakpoint.number ()] = breakpoint ;
+ breakpoint_table[breakpoint.number ()] = breakpoint;
if (a_input[cur] == ',') {
- ++cur ;
+ ++cur;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
}
- breakpoint.clear () ;
+ breakpoint.clear ();
}
if (breakpoint_table.empty ()) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
} else {
//weird things are happening, get out.
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur] != ']') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- ++cur ;
+ ++cur;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input.c_str ()[cur] != '}') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- ++cur ;
+ ++cur;
- a_to = cur ;
- a_breakpoints = breakpoint_table ;
+ a_to = cur;
+ a_breakpoints = breakpoint_table;
return true;
}
@@ -360,48 +360,48 @@
UString::size_type &a_to,
GDBMITupleSafePtr &a_tuple)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
if (a_input.c_str ()[cur] != '{') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
if (a_input.c_str ()[cur] == '}') {
- ++cur ;
- a_to = cur ;
- return true ;
+ ++cur;
+ a_to = cur;
+ return true;
}
- GDBMITupleSafePtr tuple ;
- GDBMIResultSafePtr result ;
+ GDBMITupleSafePtr tuple;
+ GDBMIResultSafePtr result;
for (;;) {
if (parse_gdbmi_result (a_input, cur, cur, result)) {
- THROW_IF_FAIL (result) ;
- SKIP_BLANK (a_input, cur, cur) ;
- CHECK_END (a_input, cur, end) ;
+ THROW_IF_FAIL (result);
+ SKIP_BLANK (a_input, cur, cur);
+ CHECK_END (a_input, cur, end);
if (!tuple) {
- tuple = GDBMITupleSafePtr (new GDBMITuple) ;
- THROW_IF_FAIL (tuple) ;
+ tuple = GDBMITupleSafePtr (new GDBMITuple);
+ THROW_IF_FAIL (tuple);
}
- tuple->append (result) ;
+ tuple->append (result);
if (a_input.c_str ()[cur] == ',') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- SKIP_BLANK (a_input, cur, cur) ;
- continue ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ SKIP_BLANK (a_input, cur, cur);
+ continue;
}
if (a_input.c_str ()[cur] == '}') {
- ++cur ;
+ ++cur;
}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
LOG_D ("getting out at char '"
<< (char)a_input.c_str ()[cur]
@@ -410,14 +410,14 @@
<< "' for text >>>"
<< a_input
<< "<<<",
- GDBMI_PARSING_DOMAIN) ;
- break ;
+ GDBMI_PARSING_DOMAIN);
+ break;
}
- SKIP_BLANK (a_input, cur, cur) ;
- a_to = cur ;
- a_tuple = tuple ;
- return true ;
+ SKIP_BLANK (a_input, cur, cur);
+ a_to = cur;
+ a_tuple = tuple;
+ return true;
}
/// Parse a GDB/MI LIST. A list is either a list of GDB/MI Results
@@ -429,78 +429,78 @@
UString::size_type &a_to,
GDBMIListSafePtr &a_list)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
- GDBMIListSafePtr return_list ;
+ GDBMIListSafePtr return_list;
if (a_input.c_str ()[cur] != '[') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- CHECK_END (a_input, cur + 1, end) ;
+ CHECK_END (a_input, cur + 1, end);
if (a_input.c_str ()[cur + 1] == ']') {
a_list = GDBMIListSafePtr (new GDBMIList);
cur += 2;
- a_to = cur ;
- return true ;
+ a_to = cur;
+ return true;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- SKIP_BLANK (a_input, cur, cur) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ SKIP_BLANK (a_input, cur, cur);
- GDBMIValueSafePtr value ;
- GDBMIResultSafePtr result ;
+ GDBMIValueSafePtr value;
+ GDBMIResultSafePtr result;
if ((isalpha (a_input.c_str ()[cur]) || a_input.c_str ()[cur] == '_')
&& parse_gdbmi_result (a_input, cur, cur, result)) {
- CHECK_END (a_input, cur, end) ;
- THROW_IF_FAIL (result) ;
- return_list = GDBMIListSafePtr (new GDBMIList (result)) ;
+ CHECK_END (a_input, cur, end);
+ THROW_IF_FAIL (result);
+ return_list = GDBMIListSafePtr (new GDBMIList (result));
for (;;) {
if (a_input.c_str ()[cur] == ',') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- result.reset () ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ result.reset ();
if (parse_gdbmi_result (a_input, cur, cur, result)) {
- THROW_IF_FAIL (result) ;
- return_list->append (result) ;
- continue ;
+ THROW_IF_FAIL (result);
+ return_list->append (result);
+ continue;
}
}
- break ;
+ break;
}
} else if (parse_gdbmi_value (a_input, cur, cur, value)) {
- CHECK_END (a_input, cur, end) ;
+ CHECK_END (a_input, cur, end);
THROW_IF_FAIL (value);
- return_list = GDBMIListSafePtr (new GDBMIList (value)) ;
+ return_list = GDBMIListSafePtr (new GDBMIList (value));
for (;;) {
if (a_input.c_str ()[cur] == ',') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
value.reset ();
if (parse_gdbmi_value (a_input, cur, cur, value)) {
- THROW_IF_FAIL (value) ;
- return_list->append (value) ;
- continue ;
+ THROW_IF_FAIL (value);
+ return_list->append (value);
+ continue;
}
}
- break ;
+ break;
}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur] != ']') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
+ ++cur;
- a_to = cur ;
- a_list = return_list ;
- return true ;
+ a_to = cur;
+ a_list = return_list;
+ return true;
}
/// parse a GDB/MI Result data structure.
@@ -514,37 +514,37 @@
UString::size_type &a_to,
GDBMIResultSafePtr &a_value)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
- UString variable ;
+ UString variable;
if (!parse_string (a_input, cur, cur, variable)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- CHECK_END (a_input, cur, end) ;
- SKIP_BLANK (a_input, cur, cur) ;
+ CHECK_END (a_input, cur, end);
+ SKIP_BLANK (a_input, cur, cur);
if (a_input.c_str ()[cur] != '=') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- LOG_D ("got gdbmi variable: " << variable, GDBMI_PARSING_DOMAIN) ;
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ LOG_D ("got gdbmi variable: " << variable, GDBMI_PARSING_DOMAIN);
+ ++cur;
+ CHECK_END (a_input, cur, end);
GDBMIValueSafePtr value;
if (!parse_gdbmi_value (a_input, cur, cur, value)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- THROW_IF_FAIL (value) ;
+ THROW_IF_FAIL (value);
- GDBMIResultSafePtr result (new GDBMIResult (variable, value)) ;
- THROW_IF_FAIL (result) ;
- a_to = cur ;
- a_value = result ;
- return true ;
+ GDBMIResultSafePtr result (new GDBMIResult (variable, value));
+ THROW_IF_FAIL (result);
+ a_to = cur;
+ a_value = result;
+ return true;
}
/// \brief parse a GDB/MI value.
@@ -567,141 +567,141 @@
UString::size_type &a_to,
GDBMIValueSafePtr &a_value)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
- GDBMIValueSafePtr value ;
+ GDBMIValueSafePtr value;
if (a_input.c_str ()[cur] == '"') {
- UString const_string ;
+ UString const_string;
if (parse_c_string (a_input, cur, cur, const_string)) {
- value = GDBMIValueSafePtr (new GDBMIValue (const_string)) ;
+ value = GDBMIValueSafePtr (new GDBMIValue (const_string));
LOG_D ("got str gdbmi value: '"
<< const_string
<< "'",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
}
} else if (a_input.c_str ()[cur] == '{') {
- GDBMITupleSafePtr tuple ;
+ GDBMITupleSafePtr tuple;
if (parse_gdbmi_tuple (a_input, cur, cur, tuple)) {
if (!tuple) {
- value = GDBMIValueSafePtr (new GDBMIValue ()) ;
+ value = GDBMIValueSafePtr (new GDBMIValue ());
} else {
- value = GDBMIValueSafePtr (new GDBMIValue (tuple)) ;
+ value = GDBMIValueSafePtr (new GDBMIValue (tuple));
}
}
} else if (a_input.c_str ()[cur] == '[') {
- GDBMIListSafePtr list ;
+ GDBMIListSafePtr list;
if (parse_gdbmi_list (a_input, cur, cur, list)) {
- THROW_IF_FAIL (list) ;
- value = GDBMIValueSafePtr (new GDBMIValue (list)) ;
+ THROW_IF_FAIL (list);
+ value = GDBMIValueSafePtr (new GDBMIValue (list));
}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!value) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_value = value ;
- a_to = cur ;
- return true ;
+ a_value = value;
+ a_to = cur;
+ return true;
}
ostream&
operator<< (ostream &a_out, const GDBMIResultSafePtr &a_result)
{
if (!a_result) {
- a_out << "<result nilpointer/>" ;
- return a_out ;
+ a_out << "<result nilpointer/>";
+ return a_out;
}
- a_out << "<result variable='" ;
- a_out << Glib::locale_from_utf8 (a_result->variable ()) << "'>" ;
- a_out << a_result->value () ;
- a_out << "</result>" ;
- return a_out ;
+ a_out << "<result variable='";
+ a_out << Glib::locale_from_utf8 (a_result->variable ()) << "'>";
+ a_out << a_result->value ();
+ a_out << "</result>";
+ return a_out;
}
ostream&
operator<< (ostream &a_out, const GDBMITupleSafePtr &a_tuple)
{
if (!a_tuple) {
- a_out << "<tuple nilpointer/>" ;
- return a_out ;
+ a_out << "<tuple nilpointer/>";
+ return a_out;
}
- list<GDBMIResultSafePtr>::const_iterator iter ;
- a_out << "<tuple>" ;
- for (iter=a_tuple->content ().begin () ; iter!=a_tuple->content ().end(); ++iter) {
- a_out << *iter ;
+ list<GDBMIResultSafePtr>::const_iterator iter;
+ a_out << "<tuple>" ;
+ for (iter=a_tuple->content ().begin (); iter!=a_tuple->content ().end(); ++iter) {
+ a_out << *iter;
}
a_out << "</tuple>";
- return a_out ;
+ return a_out;
}
ostream&
operator<< (ostream &a_out, const GDBMIListSafePtr a_list)
{
if (!a_list) {
- a_out << "<list nilpointer/>" ;
- return a_out ;
+ a_out << "<list nilpointer/>";
+ return a_out;
}
if (a_list->content_type () == GDBMIList::RESULT_TYPE) {
- a_out << "<list type='result'>" ;
- list<GDBMIResultSafePtr>::const_iterator iter ;
- list<GDBMIResultSafePtr> result_list ;
- a_list->get_result_content (result_list) ;
- for (iter = result_list.begin () ;
+ a_out << "<list type='result'>";
+ list<GDBMIResultSafePtr>::const_iterator iter;
+ list<GDBMIResultSafePtr> result_list;
+ a_list->get_result_content (result_list);
+ for (iter = result_list.begin ();
iter != result_list.end ();
++iter) {
- a_out << *iter ;
+ a_out << *iter;
}
- a_out << "</list>" ;
+ a_out << "</list>";
} else if (a_list->content_type () == GDBMIList::VALUE_TYPE) {
- a_out << "<list type='value'>" ;
- list<GDBMIValueSafePtr>::const_iterator iter ;
+ a_out << "<list type='value'>";
+ list<GDBMIValueSafePtr>::const_iterator iter;
list<GDBMIValueSafePtr> value_list;
- a_list->get_value_content (value_list) ;
- for (iter = value_list.begin () ;
+ a_list->get_value_content (value_list);
+ for (iter = value_list.begin ();
iter != value_list.end ();
++iter) {
- a_out << *iter ;
+ a_out << *iter;
}
- a_out << "</list>" ;
+ a_out << "</list>";
} else {
- THROW_IF_FAIL ("assert not reached") ;
+ THROW_IF_FAIL ("assert not reached");
}
- return a_out ;
+ return a_out;
}
ostream&
operator<< (ostream &a_out, const GDBMIValueSafePtr &a_val)
{
if (!a_val) {
- a_out << "<value nilpointer/>" ;
- return a_out ;
+ a_out << "<value nilpointer/>";
+ return a_out;
}
switch (a_val->content_type ()) {
case GDBMIValue::EMPTY_TYPE:
- a_out << "<value type='empty'/>" ;
- break ;
+ a_out << "<value type='empty'/>";
+ break;
case GDBMIValue::TUPLE_TYPE :
a_out << "<value type='tuple'>"
<< a_val->get_tuple_content ()
<< "</value>";
- break ;
+ break;
case GDBMIValue::LIST_TYPE :
a_out << "<value type='list'>\n"
- << a_val->get_list_content ()<< "</value>" ;
- break ;
+ << a_val->get_list_content ()<< "</value>";
+ break;
case GDBMIValue::STRING_TYPE:
a_out << "<value type='string'>"
<< Glib::locale_from_utf8 (a_val->get_string_content ())
- << "</value>" ;
- break ;
+ << "</value>";
+ break;
}
- return a_out ;
+ return a_out;
}
std::ostream&
@@ -710,18 +710,18 @@
a_out << "<variable>"
<< "<name>"<< a_var.name () << "</name>"
<< "<type>"<< a_var.type () << "</type>"
- << "<members>" ;
+ << "<members>";
if (!a_var.members ().empty ()) {
- list<IDebugger::VariableSafePtr>::const_iterator it ;
- for (it = a_var.members ().begin () ;
- it != a_var.members ().end () ;
+ list<IDebugger::VariableSafePtr>::const_iterator it;
+ for (it = a_var.members ().begin ();
+ it != a_var.members ().end ();
++it) {
- a_out << *(*it) ;
+ a_out << *(*it);
}
}
- a_out << "</members></variable>" ;
- return a_out ;
+ a_out << "</members></variable>";
+ return a_out;
}
@@ -743,73 +743,73 @@
UString::size_type &a_to,
IDebugger::Frame &a_frame)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
if (a_input.compare (a_from, strlen (PREFIX_FRAME), PREFIX_FRAME)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- GDBMIResultSafePtr result ;
+ GDBMIResultSafePtr result;
if (!parse_gdbmi_result (a_input, cur, cur, result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- THROW_IF_FAIL (result) ;
- //CHECK_END (a_input, cur, end) ;
+ THROW_IF_FAIL (result);
+ //CHECK_END (a_input, cur, end);
if (result->variable () != "frame") {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!result->value ()
||result->value ()->content_type ()
!= GDBMIValue::TUPLE_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
GDBMITupleSafePtr result_value_tuple =
- result->value ()->get_tuple_content () ;
+ result->value ()->get_tuple_content ();
if (!result_value_tuple) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- list<GDBMIResultSafePtr>::const_iterator res_it ;
- GDBMIResultSafePtr tmp_res ;
- IDebugger::Frame frame ;
- UString name, value ;
- for (res_it = result_value_tuple->content ().begin () ;
+ list<GDBMIResultSafePtr>::const_iterator res_it;
+ GDBMIResultSafePtr tmp_res;
+ IDebugger::Frame frame;
+ UString name, value;
+ for (res_it = result_value_tuple->content ().begin ();
res_it != result_value_tuple->content ().end ();
++res_it) {
if (!(*res_it)) {continue;}
- tmp_res = *res_it ;
+ tmp_res = *res_it;
if (!tmp_res->value ()
||tmp_res->value ()->content_type () != GDBMIValue::STRING_TYPE) {
- continue ;
+ continue;
}
- name = tmp_res->variable () ;
- value = tmp_res->value ()->get_string_content () ;
+ name = tmp_res->variable ();
+ value = tmp_res->value ()->get_string_content ();
if (name == "level") {
- frame.level (atoi (value.c_str ())) ;
+ frame.level (atoi (value.c_str ()));
} else if (name == "addr") {
- frame.address (value) ;
+ frame.address (value);
} else if (name == "func") {
- frame.function_name (value) ;
+ frame.function_name (value);
} else if (name == "file") {
- frame.file_name (value) ;
+ frame.file_name (value);
} else if (name == "fullname") {
- frame.file_full_name (value) ;
+ frame.file_full_name (value);
} else if (name == "line") {
- frame.line (atoi (value.c_str ())) ;
+ frame.line (atoi (value.c_str ()));
}
}
- a_frame = frame ;
- a_to = cur ;
- return true ;
+ a_frame = frame;
+ a_to = cur;
+ return true;
}
/// parse a callstack as returned by the gdb/mi command:
@@ -820,82 +820,82 @@
UString::size_type &a_to,
vector<IDebugger::Frame> &a_stack)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
- GDBMIResultSafePtr result ;
+ GDBMIResultSafePtr result;
if (!parse_gdbmi_result (a_input, cur, cur, result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- THROW_IF_FAIL (result) ;
- CHECK_END (a_input, cur, end) ;
+ THROW_IF_FAIL (result);
+ CHECK_END (a_input, cur, end);
if (result->variable () != "stack") {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!result->value ()
||result->value ()->content_type ()
!= GDBMIValue::LIST_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
GDBMIListSafePtr result_value_list =
- result->value ()->get_list_content () ;
+ result->value ()->get_list_content ();
if (!result_value_list) {
- a_to = cur ;
- a_stack.clear () ;
- return true ;
+ a_to = cur;
+ a_stack.clear ();
+ return true;
}
if (result_value_list->content_type () != GDBMIList::RESULT_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- list<GDBMIResultSafePtr> result_list ;
- result_value_list->get_result_content (result_list) ;
+ list<GDBMIResultSafePtr> result_list ;
+ result_value_list->get_result_content (result_list);
- GDBMITupleSafePtr frame_tuple ;
- vector<IDebugger::Frame> stack ;
- list<GDBMIResultSafePtr>::const_iterator iter, frame_part_iter ;
- UString value ;
- for (iter = result_list.begin (); iter != result_list.end () ; ++iter) {
+ GDBMITupleSafePtr frame_tuple;
+ vector<IDebugger::Frame> stack;
+ list<GDBMIResultSafePtr>::const_iterator iter, frame_part_iter;
+ UString value;
+ for (iter = result_list.begin (); iter != result_list.end (); ++iter) {
if (!(*iter)) {continue;}
THROW_IF_FAIL ((*iter)->value ()
&& (*iter)->value ()->content_type ()
- == GDBMIValue::TUPLE_TYPE) ;
+ == GDBMIValue::TUPLE_TYPE);
- frame_tuple = (*iter)->value ()->get_tuple_content () ;
- THROW_IF_FAIL (frame_tuple) ;
- IDebugger::Frame frame ;
+ frame_tuple = (*iter)->value ()->get_tuple_content ();
+ THROW_IF_FAIL (frame_tuple);
+ IDebugger::Frame frame;
for (frame_part_iter = frame_tuple->content ().begin ();
frame_part_iter != frame_tuple->content ().end ();
++frame_part_iter) {
- THROW_IF_FAIL ((*frame_part_iter)->value ()) ;
- value = (*frame_part_iter)->value ()->get_string_content () ;
+ THROW_IF_FAIL ((*frame_part_iter)->value ());
+ value = (*frame_part_iter)->value ()->get_string_content ();
if ((*frame_part_iter)->variable () == "addr") {
- frame.address (value) ;
+ frame.address (value);
} else if ((*frame_part_iter)->variable () == "func") {
- frame.function_name (value) ;
+ frame.function_name (value);
} else if ((*frame_part_iter)->variable () == "file") {
- frame.file_name (value) ;
+ frame.file_name (value);
} else if ((*frame_part_iter)->variable () == "fullname") {
- frame.file_full_name (value) ;
+ frame.file_full_name (value);
} else if ((*frame_part_iter)->variable () == "line") {
- frame.line (atol (value.c_str ())) ;
+ frame.line (atol (value.c_str ()));
}
}
- THROW_IF_FAIL (frame.address () != "") ;
- stack.push_back (frame) ;
- frame.clear () ;
+ THROW_IF_FAIL (frame.address () != "");
+ stack.push_back (frame);
+ frame.clear ();
}
- a_stack = stack ;
- a_to = cur ;
- return true ;
+ a_stack = stack;
+ a_to = cur;
+ return true;
}
/// Parse the arguments of the call stack.
@@ -909,47 +909,47 @@
UString::size_type &a_to,
map<int, list<IDebugger::VariableSafePtr> > &a_params)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
if (a_input.compare (cur, strlen (PREFIX_STACK_ARGS), PREFIX_STACK_ARGS)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- GDBMIResultSafePtr gdbmi_result ;
+ GDBMIResultSafePtr gdbmi_result;
if (!parse_gdbmi_result (a_input, cur, cur, gdbmi_result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
THROW_IF_FAIL (gdbmi_result
- && gdbmi_result->variable () == "stack-args") ;
+ && gdbmi_result->variable () == "stack-args");
if (!gdbmi_result->value ()
|| gdbmi_result->value ()->content_type ()
!= GDBMIValue::LIST_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
GDBMIListSafePtr gdbmi_list =
- gdbmi_result->value ()->get_list_content () ;
+ gdbmi_result->value ()->get_list_content ();
if (!gdbmi_list) {
- a_to = cur ;
- a_params.clear () ;
- return true ;
+ a_to = cur;
+ a_params.clear ();
+ return true;
}
if (gdbmi_list->content_type () != GDBMIList::RESULT_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- list<GDBMIResultSafePtr> frames_params_list ;
- gdbmi_list->get_result_content (frames_params_list) ;
+ list<GDBMIResultSafePtr> frames_params_list;
+ gdbmi_list->get_result_content (frames_params_list);
LOG_D ("number of frames: " << (int) frames_params_list.size (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
list<GDBMIResultSafePtr>::const_iterator frames_iter,
params_records_iter,
@@ -958,41 +958,41 @@
//walk through the list of frames
//each frame is a tuple of the form:
//{level="2", args=[list-of-arguments]}
- for (frames_iter = frames_params_list.begin () ;
+ for (frames_iter = frames_params_list.begin ();
frames_iter != frames_params_list.end ();
++frames_iter) {
if (!(*frames_iter)) {
- LOG_D ("Got a null frmae, skipping", GDBMI_PARSING_DOMAIN) ;
+ LOG_D ("Got a null frmae, skipping", GDBMI_PARSING_DOMAIN);
continue;
}
- THROW_IF_FAIL ((*frames_iter)->variable () != "stack") ;
+ THROW_IF_FAIL ((*frames_iter)->variable () != "stack");
THROW_IF_FAIL ((*frames_iter)->value ()
&& (*frames_iter)->value ()->content_type ()
== GDBMIValue::TUPLE_TYPE)
//params_record is a tuple that has the form:
//{level="2", args=[list-of-arguments]}
- GDBMITupleSafePtr params_record ;
- params_record = (*frames_iter)->value ()->get_tuple_content () ;
- THROW_IF_FAIL (params_record) ;
+ GDBMITupleSafePtr params_record;
+ params_record = (*frames_iter)->value ()->get_tuple_content ();
+ THROW_IF_FAIL (params_record);
//walk through the tuple {level="2", args=[list-of-arguments]}
- int cur_frame_level=-1 ;
+ int cur_frame_level=-1;
for (params_records_iter = params_record->content ().begin ();
- params_records_iter != params_record->content ().end () ;
+ params_records_iter != params_record->content ().end ();
++params_records_iter) {
- THROW_IF_FAIL ((*params_records_iter)->value ()) ;
+ THROW_IF_FAIL ((*params_records_iter)->value ());
if ((*params_records_iter)->variable () == "level") {
THROW_IF_FAIL
((*params_records_iter)->value ()
&& (*params_records_iter)->value ()->content_type ()
- == GDBMIValue::STRING_TYPE) ;
+ == GDBMIValue::STRING_TYPE);
cur_frame_level = atoi
((*params_records_iter)->value
()->get_string_content ().c_str ());
LOG_D ("frame level '" << (int) cur_frame_level << "'",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
} else if ((*params_records_iter)->variable () == "args") {
//this gdbmi result is of the form:
//args=[{name="foo0", value="bar0"},
@@ -1000,54 +1000,54 @@
THROW_IF_FAIL
((*params_records_iter)->value ()
- && (*params_records_iter)->value ()->get_list_content ()) ;
+ && (*params_records_iter)->value ()->get_list_content ());
GDBMIListSafePtr arg_list =
- (*params_records_iter)->value ()->get_list_content () ;
- list<GDBMIValueSafePtr>::const_iterator args_as_value_iter ;
+ (*params_records_iter)->value ()->get_list_content ();
+ list<GDBMIValueSafePtr>::const_iterator args_as_value_iter;
list<IDebugger::VariableSafePtr> cur_frame_args;
if (arg_list && !(arg_list->empty ())) {
LOG_D ("arg list is *not* empty for frame level '"
<< (int)cur_frame_level,
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
//walk each parameter.
//Each parameter is a tuple (in a value)
- list<GDBMIValueSafePtr> arg_as_value_list ;
+ list<GDBMIValueSafePtr> arg_as_value_list;
arg_list->get_value_content (arg_as_value_list);
LOG_D ("arg list size: "
<< (int)arg_as_value_list.size (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
for (args_as_value_iter=arg_as_value_list.begin();
args_as_value_iter!=arg_as_value_list.end();
++args_as_value_iter) {
if (!*args_as_value_iter) {
LOG_D ("got NULL arg, skipping",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
continue;
}
GDBMITupleSafePtr args =
- (*args_as_value_iter)->get_tuple_content () ;
- list<GDBMIResultSafePtr>::const_iterator arg_iter ;
+ (*args_as_value_iter)->get_tuple_content ();
+ list<GDBMIResultSafePtr>::const_iterator arg_iter;
IDebugger::VariableSafePtr parameter
- (new IDebugger::Variable) ;
- THROW_IF_FAIL (parameter) ;
- THROW_IF_FAIL (args) ;
+ (new IDebugger::Variable);
+ THROW_IF_FAIL (parameter);
+ THROW_IF_FAIL (args);
//walk the name and value of the parameter
for (arg_iter = args->content ().begin ();
arg_iter != args->content ().end ();
++arg_iter) {
- THROW_IF_FAIL (*arg_iter) ;
+ THROW_IF_FAIL (*arg_iter);
if ((*arg_iter)->variable () == "name") {
- THROW_IF_FAIL ((*arg_iter)->value ()) ;
+ THROW_IF_FAIL ((*arg_iter)->value ());
parameter->name
((*arg_iter)->value()->get_string_content ());
} else if ((*arg_iter)->variable () == "value") {
- THROW_IF_FAIL ((*arg_iter)->value ()) ;
+ THROW_IF_FAIL ((*arg_iter)->value ());
parameter->value
((*arg_iter)->value
- ()->get_string_content()) ;
+ ()->get_string_content());
UString::size_type pos;
- pos = parameter->value ().find ("{") ;
+ pos = parameter->value ().find ("{");
if (pos != Glib::ustring::npos) {
//in certain cases
//(gdbmi is not strict enough to be sure)
@@ -1066,14 +1066,14 @@
if (parse_member_variable
(parameter->value (),
pos, pos, parameter, true)) {
- parameter->value ("") ;
+ parameter->value ("");
} else {
LOG_ERROR ("Oops, '{' was not for "
- "for an embedded variable") ;
+ "for an embedded variable");
}
}
} else {
- THROW ("should not reach this line") ;
+ THROW ("should not reach this line");
}
}
LOG_D ("pushing arg '"
@@ -1082,33 +1082,33 @@
<<" for frame level='"
<<(int)cur_frame_level
<<"'",
- GDBMI_PARSING_DOMAIN) ;
- cur_frame_args.push_back (parameter) ;
+ GDBMI_PARSING_DOMAIN);
+ cur_frame_args.push_back (parameter);
}
} else {
LOG_D ("arg list is empty for frame level '"
<< (int)cur_frame_level,
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
}
- THROW_IF_FAIL (cur_frame_level >= 0) ;
+ THROW_IF_FAIL (cur_frame_level >= 0);
LOG_D ("cur_frame_level: '"
<< (int) cur_frame_level
<< "', NB Params: "
<< (int) cur_frame_args.size (),
- GDBMI_PARSING_DOMAIN) ;
- all_frames_args[cur_frame_level] = cur_frame_args ;
+ GDBMI_PARSING_DOMAIN);
+ all_frames_args[cur_frame_level] = cur_frame_args;
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
}
}
- a_to = cur ;
- a_params = all_frames_args ;
+ a_to = cur;
+ a_params = all_frames_args;
LOG_D ("number of frames parsed: " << (int)a_params.size (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
return true;
}
@@ -1120,109 +1120,109 @@
UString::size_type &a_to,
list<IDebugger::VariableSafePtr> &a_vars)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
if (a_input.compare (cur, strlen (PREFIX_LOCALS), PREFIX_LOCALS)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- GDBMIResultSafePtr gdbmi_result ;
+ GDBMIResultSafePtr gdbmi_result;
if (!parse_gdbmi_result (a_input, cur, cur, gdbmi_result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
THROW_IF_FAIL (gdbmi_result
- && gdbmi_result->variable () == "locals") ;
+ && gdbmi_result->variable () == "locals");
if (!gdbmi_result->value ()
|| gdbmi_result->value ()->content_type ()
!= GDBMIValue::LIST_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
GDBMIListSafePtr gdbmi_list =
- gdbmi_result->value ()->get_list_content () ;
+ gdbmi_result->value ()->get_list_content ();
if (!gdbmi_list
|| gdbmi_list->content_type () == GDBMIList::UNDEFINED_TYPE) {
- a_to = cur ;
- a_vars.clear () ;
- return true ;
+ a_to = cur;
+ a_vars.clear ();
+ return true;
}
RETURN_VAL_IF_FAIL (gdbmi_list->content_type () == GDBMIList::VALUE_TYPE,
false);
- std::list<GDBMIValueSafePtr> gdbmi_value_list ;
- gdbmi_list->get_value_content (gdbmi_value_list) ;
- RETURN_VAL_IF_FAIL (!gdbmi_value_list.empty (), false) ;
+ std::list<GDBMIValueSafePtr> gdbmi_value_list;
+ gdbmi_list->get_value_content (gdbmi_value_list);
+ RETURN_VAL_IF_FAIL (!gdbmi_value_list.empty (), false);
- std::list<IDebugger::VariableSafePtr> variables ;
+ std::list<IDebugger::VariableSafePtr> variables;
std::list<GDBMIValueSafePtr>::const_iterator value_iter;
- std::list<GDBMIResultSafePtr> tuple_content ;
- std::list<GDBMIResultSafePtr>::const_iterator tuple_iter ;
- for (value_iter = gdbmi_value_list.begin () ;
- value_iter != gdbmi_value_list.end () ;
+ std::list<GDBMIResultSafePtr> tuple_content;
+ std::list<GDBMIResultSafePtr>::const_iterator tuple_iter;
+ for (value_iter = gdbmi_value_list.begin ();
+ value_iter != gdbmi_value_list.end ();
++value_iter) {
if (!(*value_iter)) {continue;}
if ((*value_iter)->content_type () != GDBMIValue::TUPLE_TYPE) {
LOG_ERROR_D ("list of tuple should contain only tuples",
- GDBMI_PARSING_DOMAIN) ;
- continue ;
+ GDBMI_PARSING_DOMAIN);
+ continue;
}
GDBMITupleSafePtr gdbmi_tuple = (*value_iter)->get_tuple_content ();
- RETURN_VAL_IF_FAIL (gdbmi_tuple, false) ;
- RETURN_VAL_IF_FAIL (!gdbmi_tuple->content ().empty (), false) ;
+ RETURN_VAL_IF_FAIL (gdbmi_tuple, false);
+ RETURN_VAL_IF_FAIL (!gdbmi_tuple->content ().empty (), false);
- tuple_content.clear () ;
- tuple_content = gdbmi_tuple->content () ;
- RETURN_VAL_IF_FAIL (!tuple_content.empty (), false) ;
- IDebugger::VariableSafePtr variable (new IDebugger::Variable) ;
- for (tuple_iter = tuple_content.begin () ;
+ tuple_content.clear ();
+ tuple_content = gdbmi_tuple->content ();
+ RETURN_VAL_IF_FAIL (!tuple_content.empty (), false);
+ IDebugger::VariableSafePtr variable (new IDebugger::Variable);
+ for (tuple_iter = tuple_content.begin ();
tuple_iter != tuple_content.end ();
++tuple_iter) {
if (!(*tuple_iter)) {
LOG_ERROR_D ("got and empty tuple member",
- GDBMI_PARSING_DOMAIN) ;
- continue ;
+ GDBMI_PARSING_DOMAIN);
+ continue;
}
if (!(*tuple_iter)->value ()
||(*tuple_iter)->value ()->content_type ()
!= GDBMIValue::STRING_TYPE) {
LOG_ERROR_D ("Got a tuple member which value is not a string",
- GDBMI_PARSING_DOMAIN) ;
- continue ;
+ GDBMI_PARSING_DOMAIN);
+ continue;
}
- UString variable_str = (*tuple_iter)->variable () ;
+ UString variable_str = (*tuple_iter)->variable ();
UString value_str =
- (*tuple_iter)->value ()->get_string_content () ;
- value_str.chomp () ;
+ (*tuple_iter)->value ()->get_string_content ();
+ value_str.chomp ();
if (variable_str == "name") {
- variable->name (value_str) ;
+ variable->name (value_str);
} else if (variable_str == "type") {
- variable->type (value_str) ;
+ variable->type (value_str);
} else if (variable_str == "value") {
- variable->value (value_str) ;
+ variable->value (value_str);
} else {
LOG_ERROR_D ("got an unknown tuple member with name: '"
<< variable_str << "'",
GDBMI_PARSING_DOMAIN)
- continue ;
+ continue;
}
}
- variables.push_back (variable) ;
+ variables.push_back (variable);
}
LOG_D ("got '" << (int)variables.size () << "' variables",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
- a_vars = variables ;
- a_to = cur ;
+ a_vars = variables;
+ a_to = cur;
return true;
}
@@ -1236,48 +1236,48 @@
UString::size_type &a_to,
IDebugger::VariableSafePtr &a_var)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
if (a_input.compare (cur, strlen (PREFIX_VALUE), PREFIX_VALUE)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- cur += 6 ;
- CHECK_END (a_input, cur, end) ;
- CHECK_END (a_input, cur+1, end) ;
+ cur += 6;
+ CHECK_END (a_input, cur, end);
+ CHECK_END (a_input, cur+1, end);
- a_var = IDebugger::VariableSafePtr (new IDebugger::Variable) ;
+ a_var = IDebugger::VariableSafePtr (new IDebugger::Variable);
if (a_input[cur+1] == '{') {
- ++cur ;
+ ++cur;
if (!parse_member_variable (a_input, cur, cur, a_var)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- SKIP_BLANK (a_input, cur, end) ;
+ SKIP_BLANK (a_input, cur, end);
if (a_input[cur] != '"') {
- UString value ;
+ UString value ;
if (!parse_c_string_body (a_input, cur, end, value)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- value = a_var->value () + " " + value ;
- a_var->value (value) ;
+ value = a_var->value () + " " + value;
+ a_var->value (value);
}
} else {
- UString value ;
+ UString value;
if (!parse_c_string (a_input, cur, cur, value)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_var->value (value) ;
+ a_var->value (value);
}
- ++cur ;
- a_to = cur ;
- return true ;
+ ++cur;
+ a_to = cur;
+ return true;
}
bool
@@ -1287,39 +1287,39 @@
IDebugger::VariableSafePtr &a_var,
bool a_in_unnamed_var)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
LOG_D ("in_unnamed_var = " <<(int)a_in_unnamed_var, GDBMI_PARSING_DOMAIN);
- THROW_IF_FAIL (a_var) ;
+ THROW_IF_FAIL (a_var);
- UString::size_type cur = a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ UString::size_type cur = a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
if (a_input.c_str ()[cur] != '{') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
- UString name, value ;
- UString::size_type name_start=0, name_end=0, value_start=0, value_end=0 ;
+ UString name, value;
+ UString::size_type name_start=0, name_end=0, value_start=0, value_end=0;
while (true /*fetch name*/) {
- name_start=0, name_end=0, value_start=0, value_end=0 ;
- name = "#unnamed#" , value = "" ;
+ name_start=0, name_end=0, value_start=0, value_end=0;
+ name = "#unnamed#" , value = "";
- SKIP_BLANK (a_input, cur, cur) ;
- LOG_D ("fetching name ...", GDBMI_PARSING_DOMAIN) ;
+ SKIP_BLANK (a_input, cur, cur);
+ LOG_D ("fetching name ...", GDBMI_PARSING_DOMAIN);
//we should be at the begining of A = B. lets try to parse A
if (a_input.c_str ()[cur] != '{') {
- SKIP_BLANK (a_input, cur, cur) ;
- name_start = cur ;
+ SKIP_BLANK (a_input, cur, cur);
+ name_start = cur;
while (true) {
if (cur < a_input.bytes ()
&& a_input.c_str ()[cur] != '='
&& a_input.c_str ()[cur] != '}') {
- ++cur ;
+ ++cur;
} else {
//if we found an '}' character, make sure
//it is not enclosed in sigle quotes. If it is in
@@ -1331,34 +1331,34 @@
++cur;
continue;
}
- break ;
+ break;
}
}
//we should be at the end of A (as in A = B)
- name_end = cur - 1 ;
- name.assign (a_input, name_start, name_end - name_start + 1) ;
- LOG_D ("got name '" << name << "'", GDBMI_PARSING_DOMAIN) ;
+ name_end = cur - 1;
+ name.assign (a_input, name_start, name_end - name_start + 1);
+ LOG_D ("got name '" << name << "'", GDBMI_PARSING_DOMAIN);
}
- IDebugger::VariableSafePtr cur_var (new IDebugger::Variable) ;
- name.chomp () ;
- cur_var->name (name) ;
+ IDebugger::VariableSafePtr cur_var (new IDebugger::Variable);
+ name.chomp ();
+ cur_var->name (name);
if (a_input.c_str ()[cur] == '}') {
- ++cur ;
- cur_var->value ("") ;
- a_var->append (cur_var) ;
+ ++cur;
+ cur_var->value ("");
+ a_var->append (cur_var);
LOG_D ("reached '}' after '"
<< name << "'",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
break;
}
- SKIP_BLANK (a_input, cur, cur) ;
+ SKIP_BLANK (a_input, cur, cur);
if (a_input.c_str ()[cur] != '{') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- SKIP_BLANK (a_input, cur, cur) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ SKIP_BLANK (a_input, cur, cur);
}
//if we are at a '{', (like in A = {B}),
@@ -1375,34 +1375,34 @@
cur,
cur_var,
in_unnamed)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
} else {
//else, we are at a B, (like in A = B),
//so let's try to parse B
- SKIP_BLANK (a_input, cur, cur) ;
- value_start = cur ;
+ SKIP_BLANK (a_input, cur, cur);
+ value_start = cur;
while (true) {
- UString str ;
+ UString str;
if (a_input.c_str ()[cur] == '"' &&
a_input.c_str()[cur -1] != '\\') {
if (!parse_c_string (a_input, cur, cur, str)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
} else if (cur + 1 < end &&
a_input.c_str ()[cur] == '\\' &&
a_input.c_str ()[cur+1] == '"') {
if (!parse_embedded_c_string (a_input, cur, cur, str)){
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
} else if ((a_input.c_str ()[cur] != ','
|| ((cur+1 < end) && a_input[cur+1] != ' '))
&& a_input.c_str ()[cur] != '}') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
} else {
//if we found an '}' character, make sure
//it is not enclosed in sigle quotes. If it is in
@@ -1416,52 +1416,52 @@
}
//otherwise, getting out condition is either
//", " or "}". check out the the 'if' condition.
- break ;
+ break;
}
}
if (cur != value_start) {
value_end = cur - 1;
value.assign (a_input, value_start,
- value_end - value_start + 1) ;
+ value_end - value_start + 1);
LOG_D ("got value: '"
<< value << "'",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
} else {
- value = "" ;
- LOG_D ("got empty value", GDBMI_PARSING_DOMAIN) ;
+ value = "";
+ LOG_D ("got empty value", GDBMI_PARSING_DOMAIN);
}
- cur_var->value (value) ;
+ cur_var->value (value);
}
- a_var->append (cur_var) ;
+ a_var->append (cur_var);
LOG_D ("cur char: " << (char) a_input.c_str()[cur],
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
LOG_D ("skipping ws ...",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
- SKIP_BLANK (a_input, cur, cur) ;
+ SKIP_BLANK (a_input, cur, cur);
LOG_D ("cur char: " << (char) a_input.c_str()[cur],
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
if (cur == end) {
- break ;
+ break;
} else if (a_input.c_str ()[cur] == '}') {
- ++cur ;
- break ;
+ ++cur;
+ break;
} else if (a_input.c_str ()[cur] == ',') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
LOG_D ("got ',' , going to fetch name",
- GDBMI_PARSING_DOMAIN) ;
- continue /*goto fetch name*/ ;
+ GDBMI_PARSING_DOMAIN);
+ continue /*goto fetch name*/;
}
- LOG_PARSING_ERROR (a_input, cur) ;
- THROW ("should not be reached") ;
+ LOG_PARSING_ERROR (a_input, cur);
+ THROW ("should not be reached");
}//end while
- a_to = cur ;
- return true ;
+ a_to = cur;
+ return true;
}
@@ -1485,18 +1485,18 @@
UString::size_type &a_to,
map<UString, UString> a_args)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
+ CHECK_END (a_input, cur, end);
if (a_input.compare (cur, 1, "{")) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur ++ ;
+ cur ++ ;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
@@ -1505,14 +1505,14 @@
value_start (0),
value_end (0);
- Glib::ustring name, value ;
- map<UString, UString> args ;
+ Glib::ustring name, value;
+ map<UString, UString> args;
while (true) {
if (a_input.compare (cur, 6, "name=\"")) {break;}
- cur += 6 ;
+ cur += 6;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
name_start = cur;
@@ -1521,56 +1521,56 @@
++cur) {
}
if (a_input[cur] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- name_end = cur - 1 ;
+ name_end = cur - 1;
if (++cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input.compare (cur, 8, ",value=\"")) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur += 8 ; if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ cur += 8; if (cur >= end) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- value_start = cur ;
+ value_start = cur;
for (;
cur < end && (a_input[cur] != '"' || a_input[cur-1] == '\\');
++cur) {
}
if (a_input[cur] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- value_end = cur - 1 ;
- name.clear (), value.clear () ;
- name.assign (a_input, name_start, name_end - name_start + 1) ;
- value.assign (a_input, value_start, value_end - value_start + 1) ;
- args[name] = value ;
+ value_end = cur - 1;
+ name.clear (), value.clear ();
+ name.assign (a_input, name_start, name_end - name_start + 1);
+ value.assign (a_input, value_start, value_end - value_start + 1);
+ args[name] = value;
if (++cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input[cur] != '}') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (++cur >= end) {break;}
if (!a_input.compare(cur, 2,",{") ){
- cur += 2 ;
- continue ;
+ cur += 2;
+ continue;
} else {
- break ;
+ break;
}
}
- a_args = args ;
- a_to = cur ;
+ a_args = args;
+ a_to = cur;
return true;
}
@@ -1582,92 +1582,92 @@
UString::size_type &a_to,
std::list<int> &a_thread_ids)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
if (a_input.compare (cur, strlen (PREFIX_THREAD_IDS), PREFIX_THREAD_IDS)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- GDBMIResultSafePtr gdbmi_result ;
+ GDBMIResultSafePtr gdbmi_result;
if (!parse_gdbmi_result (a_input, cur, cur, gdbmi_result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input[cur] != ',') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
if (gdbmi_result->variable () != "thread-ids") {
LOG_ERROR ("expected gdbmi variable 'thread-ids', got: '"
- << gdbmi_result->variable () << "\'") ;
- return false ;
+ << gdbmi_result->variable () << "\'");
+ return false;
}
- THROW_IF_FAIL (gdbmi_result->value ()) ;
+ THROW_IF_FAIL (gdbmi_result->value ());
THROW_IF_FAIL ((gdbmi_result->value ()->content_type ()
== GDBMIValue::TUPLE_TYPE)
||
(gdbmi_result->value ()->content_type ()
- == GDBMIValue::EMPTY_TYPE)) ;
+ == GDBMIValue::EMPTY_TYPE));
- GDBMITupleSafePtr gdbmi_tuple ;
+ GDBMITupleSafePtr gdbmi_tuple;
if (gdbmi_result->value ()->content_type ()
!= GDBMIValue::EMPTY_TYPE) {
- gdbmi_tuple = gdbmi_result->value ()->get_tuple_content () ;
- THROW_IF_FAIL (gdbmi_tuple) ;
+ gdbmi_tuple = gdbmi_result->value ()->get_tuple_content ();
+ THROW_IF_FAIL (gdbmi_tuple);
}
- list<GDBMIResultSafePtr> result_list ;
+ list<GDBMIResultSafePtr> result_list;
if (gdbmi_tuple) {
- result_list = gdbmi_tuple->content () ;
+ result_list = gdbmi_tuple->content ();
}
- list<GDBMIResultSafePtr>::const_iterator it ;
- int thread_id=0 ;
- std::list<int> thread_ids ;
- for (it = result_list.begin () ; it != result_list.end () ; ++it) {
- THROW_IF_FAIL (*it) ;
+ list<GDBMIResultSafePtr>::const_iterator it;
+ int thread_id=0;
+ std::list<int> thread_ids;
+ for (it = result_list.begin (); it != result_list.end (); ++it) {
+ THROW_IF_FAIL (*it);
if ((*it)->variable () != "thread-id") {
LOG_ERROR ("expected a gdbmi value with variable name 'thread-id'"
- ". Got '" << (*it)->variable () << "'") ;
- return false ;
+ ". Got '" << (*it)->variable () << "'");
+ return false;
}
THROW_IF_FAIL ((*it)->value ()
&& ((*it)->value ()->content_type ()
== GDBMIValue::STRING_TYPE));
- thread_id = atoi ((*it)->value ()->get_string_content ().c_str ()) ;
- THROW_IF_FAIL (thread_id) ;
- thread_ids.push_back (thread_id) ;
+ thread_id = atoi ((*it)->value ()->get_string_content ().c_str ());
+ THROW_IF_FAIL (thread_id);
+ thread_ids.push_back (thread_id);
}
if (!parse_gdbmi_result (a_input, cur, cur, gdbmi_result)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (gdbmi_result->variable () != "number-of-threads") {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
THROW_IF_FAIL (gdbmi_result->value ()
&& gdbmi_result->value ()->content_type ()
- == GDBMIValue::STRING_TYPE) ;
+ == GDBMIValue::STRING_TYPE);
unsigned int num_threads =
- atoi (gdbmi_result->value ()->get_string_content ().c_str ()) ;
+ atoi (gdbmi_result->value ()->get_string_content ().c_str ());
if (num_threads != thread_ids.size ()) {
LOG_ERROR ("num_threads: '"
<< (int) num_threads
<< "', thread_ids.size(): '"
<< (int) thread_ids.size ()
- << "'") ;
- return false ;
+ << "'");
+ return false;
}
- a_thread_ids = thread_ids ;
- a_to = cur ;
+ a_thread_ids = thread_ids;
+ a_to = cur;
return true;
}
@@ -1681,9 +1681,9 @@
if (!a_rhs.c_str ()) {return false;}
//this is false for non ascii characters
//but is way faster than UString::compare().
- int res = strncmp (a_lhs.c_str (), a_rhs.c_str (), a_lhs.bytes ()) ;
+ int res = strncmp (a_lhs.c_str (), a_rhs.c_str (), a_lhs.bytes ());
if (res < 0) {return true;}
- return false ;
+ return false;
}
};//end struct QuickUstringLess
@@ -1695,73 +1695,75 @@
UString::size_type &a_to,
std::vector<UString> &a_files)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.bytes () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.bytes ();
if (a_input.compare (cur, strlen (PREFIX_FILES), PREFIX_FILES)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
cur += 7;
std::vector<GDBMITupleSafePtr> tuples;
- while (cur <= end)
- {
+ while (cur <= end) {
GDBMITupleSafePtr tuple;
if (!parse_gdbmi_tuple(a_input, cur, cur, tuple)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
tuples.push_back(tuple);
if (a_input.c_str ()[cur] == ',') {
++cur;
} else if (a_input.c_str ()[cur] == ']') {
- // at the end of the list, just get out
+ //at the end of the list, just get out
break;
} else {
- // unexpected data
- LOG_PARSING_ERROR (a_input, cur) ;
+ //unexpected data
+ LOG_PARSING_ERROR (a_input, cur);
}
}
- std::vector<UString> files ;
- for (vector<GDBMITupleSafePtr>::const_iterator file_iter = tuples.begin();
- file_iter != tuples.end(); ++file_iter)
+ std::vector<UString> files;
+ vector<GDBMITupleSafePtr>::const_iterator file_iter;
+ for (file_iter = tuples.begin();
+ file_iter != tuples.end();
+ ++file_iter)
{
- UString filename ;
- for (list<GDBMIResultSafePtr>::const_iterator attr_it =
- (*file_iter)->content ().begin ();
- attr_it != (*file_iter)->content ().end (); ++attr_it) {
- THROW_IF_FAIL ((*attr_it)->value ()
+ UString filename;
+ list<GDBMIResultSafePtr>::const_iterator attr_it;
+ for (attr_it = (*file_iter)->content ().begin ();
+ attr_it != (*file_iter)->content ().end (); ++attr_it) {
+ THROW_IF_FAIL ((*attr_it)->value ()
&& ((*attr_it)->value ()->content_type ()
== GDBMIValue::STRING_TYPE));
if ((*attr_it)->variable () == "file") {
- // only use the 'file' attribute if the
- // fullname isn't already set
- // FIXME: do we even want to list these at all?
+ //only use the 'file' attribute if the
+ //fullname isn't already set
+ //FIXME: do we even want to list these at all?
if (filename.empty ()) {
filename = (*attr_it)->value ()->get_string_content ();
}
} else if ((*attr_it)->variable () == "fullname") {
- // use the fullname attribute, overwriting the 'file' attribute
- // if necessary
+ //use the fullname attribute,
+ //overwriting the 'file' attribute
+ //if necessary
filename = (*attr_it)->value ()->get_string_content ();
} else {
LOG_ERROR ("expected a gdbmi value with "
"variable name 'file' or 'fullname'"
- ". Got '" << (*attr_it)->variable () << "'") ;
- return false ;
+ ". Got '" << (*attr_it)->variable () << "'");
+ return false;
}
}
- THROW_IF_FAIL (!filename.empty()) ;
- files.push_back (filename) ;
+ THROW_IF_FAIL (!filename.empty());
+ files.push_back (filename);
}
std::sort(files.begin(), files.end(), QuickUStringLess());
std::vector<UString>::iterator last_unique =
- std::unique (files.begin (), files.end ()) ;
- a_files = std::vector<UString>(files.begin (), last_unique) ;
- a_to = cur ;
+ std::unique (files.begin (), files.end ());
+ a_files = std::vector<UString>(files.begin (), last_unique);
+ a_to = cur;
return true;
}
@@ -1771,46 +1773,45 @@
UString::size_type &a_to,
std::map<IDebugger::register_id_t, UString> &a_registers)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
UString::size_type cur = a_from;
if (a_input.compare (cur, strlen (PREFIX_REGISTER_NAMES),
PREFIX_REGISTER_NAMES)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
cur += strlen (PREFIX_REGISTER_NAMES);
GDBMIListSafePtr reg_list;
if (!parse_gdbmi_list (a_input, cur, cur, reg_list)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur-1] != ']') {
- // unexpected data
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ //unexpected data
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- std::map<IDebugger::register_id_t, UString> regs ;
+ std::map<IDebugger::register_id_t, UString> regs;
if (reg_list->content_type () != GDBMIList::VALUE_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
std::list<GDBMIValueSafePtr> value_list;
reg_list->get_value_content (value_list);
IDebugger::register_id_t id = 0;
- for (std::list<GDBMIValueSafePtr>::const_iterator val_iter =
- value_list.begin();
- val_iter != value_list.end();
- ++val_iter, ++id)
- {
+ std::list<GDBMIValueSafePtr>::const_iterator val_iter;
+ for (val_iter = value_list.begin();
+ val_iter != value_list.end();
+ ++val_iter, ++id) {
UString regname = (*val_iter)->get_string_content ();
regs[id] = regname;
}
a_registers = regs;
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -1820,31 +1821,31 @@
UString::size_type &a_to,
std::list<IDebugger::register_id_t> &a_registers)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
UString::size_type cur = a_from;
if (a_input.compare (cur, strlen (PREFIX_CHANGED_REGISTERS),
PREFIX_CHANGED_REGISTERS)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
cur += strlen (PREFIX_CHANGED_REGISTERS);
GDBMIListSafePtr reg_list;
if (!parse_gdbmi_list (a_input, cur, cur, reg_list)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur-1] != ']') {
// unexpected data
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- std::list<IDebugger::register_id_t> regs ;
+ std::list<IDebugger::register_id_t> regs;
if (!reg_list->empty () &&
reg_list->content_type () != GDBMIList::VALUE_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
std::list<GDBMIValueSafePtr> value_list;
@@ -1859,7 +1860,7 @@
}
a_registers = regs;
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -1869,81 +1870,78 @@
UString::size_type &a_to,
std::map<IDebugger::register_id_t, UString> &a_values)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
UString::size_type cur = a_from;
if (a_input.compare (cur, strlen (PREFIX_REGISTER_VALUES),
PREFIX_REGISTER_VALUES)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
cur += strlen (PREFIX_REGISTER_VALUES);
GDBMIListSafePtr gdbmi_list;
if (!parse_gdbmi_list (a_input, cur, cur, gdbmi_list)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur-1] != ']') {
// unexpected data
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- std::map<IDebugger::register_id_t, UString> vals ;
+ std::map<IDebugger::register_id_t, UString> vals;
if (gdbmi_list->content_type () != GDBMIList::VALUE_TYPE) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
std::list<GDBMIValueSafePtr> val_list;
gdbmi_list->get_value_content (val_list);
- for (std::list<GDBMIValueSafePtr>::const_iterator val_iter =
- val_list.begin();
- val_iter != val_list.end();
- ++val_iter)
- {
+ std::list<GDBMIValueSafePtr>::const_iterator val_iter;
+ for (val_iter = val_list.begin ();
+ val_iter != val_list.end ();
+ ++val_iter) {
UString value_str;
-
- if ((*val_iter)->content_type () != GDBMIValue::TUPLE_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ if ((*val_iter)->content_type ()
+ != GDBMIValue::TUPLE_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
GDBMITupleSafePtr tuple = (*val_iter)->get_tuple_content ();
std::list<GDBMIResultSafePtr> result_list = tuple->content ();
- if (result_list.size () != 2)
- {
+ if (result_list.size () != 2) {
// each tuple should have a 'number' and 'value' field
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- std::list<GDBMIResultSafePtr>::const_iterator res_iter = result_list.begin ();
+ std::list<GDBMIResultSafePtr>::const_iterator res_iter =
+ result_list.begin ();
// get register number
GDBMIValueSafePtr reg_number_val = (*res_iter)->value ();
- if ((*res_iter)->variable () != "number" || reg_number_val->content_type () != GDBMIValue::STRING_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ if ((*res_iter)->variable () != "number"
+ || reg_number_val->content_type () != GDBMIValue::STRING_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- IDebugger::register_id_t id = atoi (reg_number_val->get_string_content ().c_str ());
+ IDebugger::register_id_t id =
+ atoi (reg_number_val->get_string_content ().c_str ());
// get the new value of the register
++res_iter;
GDBMIValueSafePtr reg_value_val = (*res_iter)->value ();
- if ((*res_iter)->variable () != "value" || reg_value_val->content_type () != GDBMIValue::STRING_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ if ((*res_iter)->variable () != "value"
+ || reg_value_val->content_type () != GDBMIValue::STRING_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
- }
- else
- {
+ } else {
value_str = reg_value_val->get_string_content ();
}
vals[id] = value_str;
}
a_values = vals;
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -1954,66 +1952,67 @@
size_t& a_start_addr,
std::vector<uint8_t> &a_values)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
UString::size_type cur = a_from;
- if (a_input.compare (cur, strlen (PREFIX_MEMORY_VALUES),
- PREFIX_MEMORY_VALUES)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ if (a_input.compare (cur,
+ strlen (PREFIX_MEMORY_VALUES),
+ PREFIX_MEMORY_VALUES)) {
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- // skip to the actual list of memory values
+ //skip to the actual list of memory values
const char* prefix_memory = "memory=";
cur = a_input.find (prefix_memory);
if (!cur) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
cur += strlen (prefix_memory);
GDBMIListSafePtr mem_gdbmi_list;
if (!parse_gdbmi_list (a_input, cur, cur, mem_gdbmi_list)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur-1] != ']') {
- // unexpected data
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ //unexpected data
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- if (mem_gdbmi_list->content_type () != GDBMIList::VALUE_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ if (mem_gdbmi_list->content_type ()
+ != GDBMIList::VALUE_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
std::list<GDBMIValueSafePtr> mem_value_list;
mem_gdbmi_list->get_value_content (mem_value_list);
- // there should only be one 'row'
- if (mem_value_list.size () != 1)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ //there should only be one 'row'
+ if (mem_value_list.size () != 1) {
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- std::list<GDBMIValueSafePtr>::const_iterator mem_tuple_iter = mem_value_list.begin ();
- if ((*mem_tuple_iter)->content_type () != GDBMIValue::TUPLE_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ std::list<GDBMIValueSafePtr>::const_iterator mem_tuple_iter =
+ mem_value_list.begin ();
+ if ((*mem_tuple_iter)->content_type ()
+ != GDBMIValue::TUPLE_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- const GDBMITupleSafePtr gdbmi_tuple = (*mem_tuple_iter)->get_tuple_content ();
+ const GDBMITupleSafePtr gdbmi_tuple =
+ (*mem_tuple_iter)->get_tuple_content ();
std::list<GDBMIResultSafePtr> result_list;
result_list = gdbmi_tuple->content ();
- if (result_list.size () < 2)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ if (result_list.size () < 2) {
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
std::vector<uint8_t> memory_values;
@@ -2021,61 +2020,61 @@
for (std::list<GDBMIResultSafePtr>::const_iterator result_iter =
result_list.begin();
result_iter != result_list.end();
- ++result_iter)
- {
- if ((*result_iter)->variable () == "addr")
- {
+ ++result_iter) {
+ if ((*result_iter)->variable () == "addr") {
seen_addr = true;
- if ((*result_iter)->value ()->content_type () != GDBMIValue::STRING_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ if ((*result_iter)->value ()->content_type ()
+ != GDBMIValue::STRING_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- std::istringstream istream((*result_iter)->value ()->get_string_content ());
+ std::istringstream istream((*result_iter)->value ()->
+ get_string_content ());
istream >> std::hex >> a_start_addr;
- } else if ((*result_iter)->variable () == "data")
- {
+ } else if ((*result_iter)->variable () == "data") {
seen_data = true;
- if ((*result_iter)->value ()->content_type () != GDBMIValue::LIST_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ if ((*result_iter)->value ()->content_type ()
+ != GDBMIValue::LIST_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- GDBMIListSafePtr gdbmi_list = (*result_iter)->value ()->get_list_content ();
- if (gdbmi_list->content_type () != GDBMIList::VALUE_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ GDBMIListSafePtr gdbmi_list =
+ (*result_iter)->value ()->get_list_content ();
+ if (gdbmi_list->content_type () != GDBMIList::VALUE_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
std::list<GDBMIValueSafePtr> gdbmi_values;
gdbmi_list->get_value_content (gdbmi_values);
- for (std::list<GDBMIValueSafePtr>::const_iterator val_iter = gdbmi_values.begin ();
- val_iter != gdbmi_values.end (); ++val_iter)
- {
- if ((*val_iter)->content_type () != GDBMIValue::STRING_TYPE)
- {
- LOG_PARSING_ERROR (a_input, cur) ;
+ std::list<GDBMIValueSafePtr>::const_iterator val_iter;
+ for (val_iter = gdbmi_values.begin ();
+ val_iter != gdbmi_values.end ();
+ ++val_iter) {
+ if ((*val_iter)->content_type ()
+ != GDBMIValue::STRING_TYPE) {
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- std::istringstream istream((*val_iter)->get_string_content ());
- // if I use a uint8_t type here, it doesn't seem to work, so
- // using a 16-bit value that will be cast down to 8 bits
+ std::istringstream istream
+ ((*val_iter)->get_string_content ());
+ //if I use a uint8_t type here, it doesn't seem to work, so
+ //using a 16-bit value that will be cast down to 8 bits
uint16_t byte_val;
istream >> std::hex >> byte_val;
memory_values.push_back (byte_val);
}
}
- // else ignore it
+ //else ignore it
}
if (!seen_addr || !seen_data)
{
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
a_values = memory_values;
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -2095,56 +2094,56 @@
int &a_thread_id,
IDebugger::Frame &a_frame)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur = a_from, end = a_input.size () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur = a_from, end = a_input.size ();
if (a_input.compare (cur, strlen (PREFIX_NEW_THREAD_ID),
PREFIX_NEW_THREAD_ID)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- GDBMIResultSafePtr gdbmi_result ;
+ GDBMIResultSafePtr gdbmi_result;
if (!parse_gdbmi_result (a_input, cur, cur, gdbmi_result)
|| !gdbmi_result) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (gdbmi_result->variable () != "new-thread-id") {
LOG_ERROR ("expected 'new-thread-id', got '"
- << gdbmi_result->variable () << "'") ;
- return false ;
+ << gdbmi_result->variable () << "'");
+ return false;
}
- THROW_IF_FAIL (gdbmi_result->value ()) ;
+ THROW_IF_FAIL (gdbmi_result->value ());
THROW_IF_FAIL (gdbmi_result->value ()->content_type ()
- == GDBMIValue::STRING_TYPE) ;
- CHECK_END (a_input, cur, end) ;
+ == GDBMIValue::STRING_TYPE);
+ CHECK_END (a_input, cur, end);
int thread_id =
- atoi (gdbmi_result->value ()->get_string_content ().c_str ()) ;
+ atoi (gdbmi_result->value ()->get_string_content ().c_str ());
if (!thread_id) {
- LOG_ERROR ("got null thread id") ;
- return false ;
+ LOG_ERROR ("got null thread id");
+ return false;
}
- SKIP_BLANK (a_input, cur, cur) ;
+ SKIP_BLANK (a_input, cur, cur);
if (a_input[cur] != ',') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
- IDebugger::Frame frame ;
+ IDebugger::Frame frame;
if (!parse_frame (a_input, cur, cur, frame)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_to = cur ;
- a_thread_id = thread_id ;
- a_frame = frame ;
- return true ;
+ a_to = cur;
+ a_thread_id = thread_id;
+ a_frame = frame;
+ return true;
}
/// parses a string that has the form:
@@ -2155,33 +2154,33 @@
UString::size_type &a_to,
UString &a_c_string)
{
- //LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ //LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
if (a_input.c_str ()[cur] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
- UString str ;
+ UString str;
if (!parse_c_string_body (a_input, cur, cur, str)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.c_str ()[cur] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
- a_c_string = str ;
- a_to = cur ;
- return true ;
+ ++cur;
+ a_c_string = str;
+ a_to = cur;
+ return true;
}
/// parse an octal escape.
@@ -2201,24 +2200,24 @@
UString::size_type &a_to,
unsigned char &a_byte_value)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur=a_from, end = a_input.bytes () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur=a_from, end = a_input.bytes ();
if (cur+3 >= end)
- return false ;
+ return false;
if (a_input.c_str ()[cur] != '\\'
|| !isdigit (a_input.c_str ()[cur+1])
|| !isdigit (a_input.c_str ()[cur+2])
|| !isdigit (a_input.c_str ()[cur+3])) {
- return false ;
+ return false;
}
a_byte_value = (a_input.c_str ()[cur+1] - '0') * 64 +
(a_input.c_str ()[cur+2] - '0') * 8 +
- (a_input.c_str ()[cur+3] - '0') ;
+ (a_input.c_str ()[cur+3] - '0');
- a_to = cur + 4 ;
+ a_to = cur + 4;
return true;
}
@@ -2234,32 +2233,32 @@
UString::size_type &a_to,
UString &a_result)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur=a_from, end = a_input.bytes () ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur=a_from, end = a_input.bytes ();
if (cur+3 >= end)
- return false ;
+ return false;
- CHECK_END (a_input, cur, end) ;
- CHECK_END (a_input, cur+1, end) ;
+ CHECK_END (a_input, cur, end);
+ CHECK_END (a_input, cur+1, end);
- unsigned char b=0 ;
- string raw ;
+ unsigned char b=0;
+ string raw;
while (a_input.c_str ()[cur] == '\\') {
if (parse_octal_escape (a_input, cur, cur, b)) {
- raw += b ;
+ raw += b;
} else {
- break ;
+ break;
}
}
- if (raw.empty ()) return false ;
+ if (raw.empty ()) return false;
try {
- a_result = Glib::locale_to_utf8 (raw) ;
+ a_result = Glib::locale_to_utf8 (raw);
} catch (...) {
- a_result.assign (raw.size (), '?') ;
+ a_result.assign (raw.size (), '?');
}
- a_to = cur ;
- return true ;
+ a_to = cur;
+ return true;
}
bool
@@ -2268,79 +2267,79 @@
UString::size_type &a_to,
UString &a_string)
{
- //LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ //LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
UString::value_type ch = a_input.c_str()[cur], prev_ch;
if (ch == '"') {
- a_string = "" ;
- a_to = cur ;
- return true ;
+ a_string = "";
+ a_to = cur;
+ return true;
}
if (!isascii (ch) && ch != '\\') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- UString result ;
+ UString result;
if (ch != '\\') {
- result += ch ;
- ++cur ;
+ result += ch;
+ ++cur;
} else {
- UString seq ;
+ UString seq;
if ((cur+3 < end)
&& isdigit (a_input.c_str ()[cur +1])
&& isdigit (a_input.c_str ()[cur +2])
&& isdigit (a_input.c_str ()[cur +3])
&& parse_octal_escape_sequence (a_input, cur, cur, seq)) {
- result += seq ;
+ result += seq;
} else {
- result += ch ;
- ++cur ;
+ result += ch;
+ ++cur;
}
}
- CHECK_END (a_input, cur, end) ;
+ CHECK_END (a_input, cur, end);
for (;;) {
prev_ch = ch;
ch = a_input.c_str()[cur];
if (isascii (ch)) {
if (ch == '"' && prev_ch != '\\') {
- break ;
+ break;
}
if (ch == '\\') {
- UString seq ;
+ UString seq;
if ((cur+3 < end)
&& isdigit (a_input.c_str ()[cur +1])
&& isdigit (a_input.c_str ()[cur +2])
&& isdigit (a_input.c_str ()[cur +3])
&& parse_octal_escape_sequence (a_input, cur, cur, seq)) {
- ch = seq[seq.size ()-1] ;
- result += seq ;
+ ch = seq[seq.size ()-1];
+ result += seq;
} else {
- result += ch ;
- ++cur ;
+ result += ch;
+ ++cur;
}
} else {
- result += ch ;
- ++cur ;
+ result += ch;
+ ++cur;
}
- CHECK_END (a_input, cur, end) ;
- continue ;
+ CHECK_END (a_input, cur, end);
+ continue;
}
break;
}
if (ch != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_string = result ;
- a_to = cur ;
- return true ;
+ a_string = result;
+ a_to = cur;
+ return true;
}
bool
@@ -2349,63 +2348,63 @@
UString::size_type &a_to,
UString &a_string)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
- CHECK_END (a_input, cur+1, end) ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
+ CHECK_END (a_input, cur+1, end);
if (a_input.c_str ()[cur] != '\\' || a_input.c_str ()[cur+1] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
cur += 2;
- CHECK_END (a_input, cur, end) ;
- UString escaped_str ;
- escaped_str += '"' ;
+ CHECK_END (a_input, cur, end);
+ UString escaped_str;
+ escaped_str += '"';
//first walk the string, and unescape everything we find escaped
- UString::value_type ch=0, prev_ch=0 ;
- bool escaping = false, found_end=false ;
- for (; cur != end ; ++cur) {
- ch = a_input[cur] ;
+ UString::value_type ch=0, prev_ch=0;
+ bool escaping = false, found_end=false;
+ for (; cur != end; ++cur) {
+ ch = a_input[cur];
if (ch == '\\') {
if (escaping) {
- prev_ch = ch ;
- escaped_str += ch ;
- escaping = false ;
+ prev_ch = ch;
+ escaped_str += ch;
+ escaping = false;
} else {
- escaping = true ;
+ escaping = true;
}
} else if (ch == '"') {
if (escaping) {
if (prev_ch != '\\') {
//found the end of string
- found_end = true ;
+ found_end = true;
}
- prev_ch = ch ;
- escaped_str += ch ;
- escaping = false ;
+ prev_ch = ch;
+ escaped_str += ch;
+ escaping = false;
if (found_end) {
- break ;
+ break;
}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
} else {
- escaped_str += ch ;
- prev_ch = ch ;
- escaping = false ;
+ escaped_str += ch;
+ prev_ch = ch;
+ escaping = false;
}
}
if (!found_end) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
//TODO:debug this.
- a_string = escaped_str ;
- a_to = cur ;
+ a_string = escaped_str;
+ a_to = cur;
return true;
}
@@ -2415,30 +2414,30 @@
UString::size_type &a_to,
UString &a_string)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
if (a_input.c_str ()[cur] != '\\' || a_input.c_str ()[cur+1] != '"') {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!parse_embedded_c_string_body (a_input, cur, cur, a_string)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- a_to = ++cur ;
- return true ;
+ a_to = ++cur;
+ return true;
}
static bool
is_string_start (gunichar a_c)
{
if (!isalpha (a_c) && a_c != '_' && a_c != '<' && a_c != '>') {
- return false ;
+ return false;
}
- return true ;
+ return true;
}
/// parses a string that has the form:
@@ -2449,18 +2448,18 @@
UString::size_type &a_to,
UString &a_string)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
- UString::size_type cur=a_from, end = a_input.bytes () ;
- CHECK_END (a_input, cur, end) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
+ UString::size_type cur=a_from, end = a_input.bytes ();
+ CHECK_END (a_input, cur, end);
UString::value_type ch = a_input.c_str ()[cur];
if (!is_string_start (ch)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- UString::size_type str_start (cur), str_end (0) ;
- ++cur ;
- CHECK_END (a_input, cur, end) ;
+ UString::size_type str_start (cur), str_end (0);
+ ++cur;
+ CHECK_END (a_input, cur, end);
for (;;) {
ch = a_input.c_str ()[cur];
@@ -2469,18 +2468,18 @@
|| ch == '-'
|| ch == '>'
|| ch == '<') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- continue ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ continue;
}
- str_end = cur - 1 ;
+ str_end = cur - 1;
break;
}
Glib::ustring str (a_input.c_str () +str_start,
- str_end - str_start + 1) ;
- a_string = str ;
- a_to = cur ;
- return true ;
+ str_end - str_start + 1);
+ a_string = str;
+ a_to = cur;
+ return true;
}
/// remove the trailing chars "\\n" at the end of a string
@@ -2491,11 +2490,11 @@
if (a_str.size () < 2) {return;}
UString::size_type i = a_str.size () - 1;
LOG_D ("stream record: '" << a_str << "' size=" << (int) a_str.size (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
if (a_str[i] == 'n' && a_str[i-1] == '\\') {
- i = i-1 ;
- a_str.erase (i, 2) ;
- a_str.append (1, '\n') ;
+ i = i-1;
+ a_str.erase (i, 2);
+ a_str.append (1, '\n');
}
}
@@ -2505,83 +2504,83 @@
UString::size_type &a_to,
Output::StreamRecord &a_record)
{
- UString::size_type cur=a_from, end = a_input.bytes () ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- UString console, target, log ;
+ UString console, target, log;
if (a_input.raw ()[cur] == '~') {
//console stream output
- ++cur ;
+ ++cur;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!parse_c_string (a_input, cur, cur, console)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- SKIP_WS (a_input, cur, cur) ;
+ SKIP_WS (a_input, cur, cur);
if (cur + 1 < end
&& a_input.raw ()[cur] == '>'
&& isspace (a_input.raw ()[cur+1])) {
- cur += 2 ;
+ cur += 2;
}
- SKIP_BLANK (a_input, cur, cur) ;
+ SKIP_BLANK (a_input, cur, cur);
} else if (a_input.raw ()[cur] == '@') {
//target stream output
- ++cur ;
+ ++cur;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!parse_c_string (a_input, cur, cur, target)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
} else if (a_input.raw ()[cur] == '&') {
//log stream output
- ++cur ;
+ ++cur;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (!parse_c_string (a_input, cur, cur, log)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- for (; cur < end && isspace (a_input.raw ()[cur]) ; ++cur) {}
- bool found (false) ;
+ for (; cur < end && isspace (a_input.raw ()[cur]); ++cur) {}
+ bool found (false);
if (!console.empty ()) {
- found = true ;
- remove_stream_record_trailing_chars (console) ;
- a_record.debugger_console (console) ;
+ found = true;
+ remove_stream_record_trailing_chars (console);
+ a_record.debugger_console (console);
}
if (!target.empty ()) {
- found = true ;
- remove_stream_record_trailing_chars (target) ;
- a_record.target_output (target) ;
+ found = true;
+ remove_stream_record_trailing_chars (target);
+ a_record.target_output (target);
}
if (!log.empty ()) {
- found = true ;
- remove_stream_record_trailing_chars (log) ;
- a_record.debugger_log (log) ;
+ found = true;
+ remove_stream_record_trailing_chars (log);
+ a_record.debugger_log (log);
}
if (!found) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- a_to = cur ;
+ a_to = cur;
return true;
}
@@ -2597,66 +2596,66 @@
IDebugger::Frame &a_frame,
map<UString, UString> &a_attrs)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end=a_input.size () ;
+ UString::size_type cur=a_from, end=a_input.size ();
if (cur >= end) {return false;}
if (a_input.compare (cur, 9,"*stopped,")) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- cur += 9 ; if (cur >= end) {return false;}
+ cur += 9; if (cur >= end) {return false;}
- map<UString, UString> attrs ;
+ map<UString, UString> attrs;
UString name, value;
- bool got_frame (false) ;
- IDebugger::Frame frame ;
+ bool got_frame (false);
+ IDebugger::Frame frame;
while (true) {
if (!a_input.compare (cur, strlen (PREFIX_FRAME), PREFIX_FRAME)) {
if (!parse_frame (a_input, cur, cur, frame)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- got_frame = true ;
+ got_frame = true;
} else {
if (!parse_attribute (a_input, cur, cur, name, value)) {break;}
- attrs[name] = value ;
- name.clear () ; value.clear () ;
+ attrs[name] = value;
+ name.clear (); value.clear ();
}
- if (cur >= end) {break ;}
+ if (cur >= end) {break;}
if (a_input[cur] == ',') {++cur;}
- if (cur >= end) {break ;}
+ if (cur >= end) {break;}
}
- for (; cur < end && a_input[cur] != '\n' ; ++cur) {}
+ for (; cur < end && a_input[cur] != '\n'; ++cur) {}
if (a_input[cur] != '\n') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- ++cur ;
+ ++cur;
- a_got_frame = got_frame ;
+ a_got_frame = got_frame;
if (a_got_frame) {
- a_frame = frame ;
+ a_frame = frame;
}
- a_to = cur ;
- a_attrs = attrs ;
- return true ;
+ a_to = cur;
+ a_attrs = attrs;
+ return true;
}
Output::OutOfBandRecord::StopReason
str_to_stopped_reason (const UString &a_str)
{
if (a_str == "breakpoint-hit") {
- return Output::OutOfBandRecord::BREAKPOINT_HIT ;
+ return Output::OutOfBandRecord::BREAKPOINT_HIT;
} else if (a_str == "watchpoint-trigger") {
- return Output::OutOfBandRecord::WATCHPOINT_TRIGGER ;
+ return Output::OutOfBandRecord::WATCHPOINT_TRIGGER;
} else if (a_str == "read-watchpoint-trigger") {
- return Output::OutOfBandRecord::READ_WATCHPOINT_TRIGGER ;
+ return Output::OutOfBandRecord::READ_WATCHPOINT_TRIGGER;
} else if (a_str == "function-finished") {
return Output::OutOfBandRecord::FUNCTION_FINISHED;
} else if (a_str == "location-reached") {
@@ -2674,7 +2673,7 @@
} else if (a_str == "signal-received") {
return Output::OutOfBandRecord::SIGNAL_RECEIVED;
} else {
- return Output::OutOfBandRecord::UNDEFINED ;
+ return Output::OutOfBandRecord::UNDEFINED;
}
}
@@ -2684,56 +2683,56 @@
UString::size_type &a_to,
Output::OutOfBandRecord &a_record)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end = a_input.bytes () ;
+ UString::size_type cur=a_from, end = a_input.bytes ();
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- Output::OutOfBandRecord record ;
+ Output::OutOfBandRecord record;
if (a_input.raw ()[cur] == '~' ||
a_input.raw ()[cur] == '@' ||
a_input.raw ()[cur] == '&') {
- Output::StreamRecord stream_record ;
+ Output::StreamRecord stream_record;
if (!parse_stream_record (a_input, cur, cur, stream_record)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- record.has_stream_record (true) ;
- record.stream_record (stream_record) ;
+ record.has_stream_record (true);
+ record.stream_record (stream_record);
while (cur < end && isspace (a_input.raw ()[cur])) {++cur;}
}
if (!a_input.raw ().compare (cur, 9,"*stopped,")) {
- map<UString, UString> attrs ;
- bool got_frame (false) ;
- IDebugger::Frame frame ;
+ map<UString, UString> attrs;
+ bool got_frame (false);
+ IDebugger::Frame frame;
if (!parse_stopped_async_output (a_input, cur, cur,
got_frame, frame, attrs)) {
- return false ;
+ return false;
}
- record.is_stopped (true) ;
- record.stop_reason (str_to_stopped_reason (attrs["reason"])) ;
+ record.is_stopped (true);
+ record.stop_reason (str_to_stopped_reason (attrs["reason"]));
if (got_frame) {
- record.frame (frame) ;
+ record.frame (frame);
record.has_frame (true);
}
if (attrs.find ("bkptno") != attrs.end ()) {
- record.breakpoint_number (atoi (attrs["bkptno"].c_str ())) ;
+ record.breakpoint_number (atoi (attrs["bkptno"].c_str ()));
}
- record.thread_id (atoi (attrs["thread-id"].c_str ())) ;
- record.signal_type (attrs["signal-name"]) ;
- record.signal_meaning (attrs["signal-meaning"]) ;
+ record.thread_id (atoi (attrs["thread-id"].c_str ()));
+ record.signal_type (attrs["signal-name"]);
+ record.signal_meaning (attrs["signal-meaning"]);
}
while (cur < end && isspace (a_input.raw ()[cur])) {++cur;}
- a_to = cur ;
- a_record = record ;
- return true ;
+ a_to = cur;
+ a_record = record;
+ return true;
}
/// parse a GDB/MI result record.
@@ -2745,19 +2744,19 @@
UString::size_type &a_to,
Output::ResultRecord &a_record)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end=a_input.bytes () ;
+ UString::size_type cur=a_from, end=a_input.bytes ();
if (cur == end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- UString name, value ;
- Output::ResultRecord result_record ;
+ UString name, value;
+ Output::ResultRecord result_record;
if (!a_input.raw ().compare (cur, strlen (PREFIX_DONE), PREFIX_DONE)) {
- cur += 5 ;
- result_record.kind (Output::ResultRecord::DONE) ;
+ cur += 5;
+ result_record.kind (Output::ResultRecord::DONE);
if (cur < end && a_input.raw ()[cur] == ',') {
@@ -2765,102 +2764,109 @@
fetch_gdbmi_result:
cur++;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- if (!a_input.raw ().compare (cur, strlen (PREFIX_BKPT), PREFIX_BKPT)) {
- IDebugger::BreakPoint breakpoint ;
+ if (!a_input.raw ().compare (cur,
+ strlen (PREFIX_BKPT),
+ PREFIX_BKPT)) {
+ IDebugger::BreakPoint breakpoint;
if (parse_breakpoint (a_input, cur, cur, breakpoint)) {
result_record.breakpoints ()[breakpoint.number ()] =
- breakpoint ;
+ breakpoint;
}
- } else if (!a_input.compare (cur, strlen (PREFIX_BREAKPOINT_TABLE),
- PREFIX_BREAKPOINT_TABLE)) {
- map<int, IDebugger::BreakPoint> breaks ;
+ } else if (!a_input.compare (cur,
+ strlen (PREFIX_BREAKPOINT_TABLE),
+ PREFIX_BREAKPOINT_TABLE)) {
+ map<int, IDebugger::BreakPoint> breaks;
if (parse_breakpoint_table (a_input, cur, cur, breaks)) {
- result_record.breakpoints () = breaks ;
+ result_record.breakpoints () = breaks;
}
} else if (!a_input.compare (cur, strlen (PREFIX_THREAD_IDS),
PREFIX_THREAD_IDS)) {
- std::list<int> thread_ids ;
+ std::list<int> thread_ids;
if (parse_threads_list (a_input, cur, cur, thread_ids)) {
- result_record.thread_list (thread_ids) ;
+ result_record.thread_list (thread_ids);
}
- } else if (!a_input.raw ().compare (cur, strlen (PREFIX_NEW_THREAD_ID),
- PREFIX_NEW_THREAD_ID)) {
- IDebugger::Frame frame ;
- int thread_id=0 ;
+ } else if (!a_input.raw ().compare
+ (cur,
+ strlen (PREFIX_NEW_THREAD_ID),
+ PREFIX_NEW_THREAD_ID)) {
+ IDebugger::Frame frame;
+ int thread_id=0;
if (parse_new_thread_id (a_input, cur, cur,
thread_id, frame)) {
//finish this !
- result_record.thread_id_selected_info (thread_id, frame) ;
+ result_record.thread_id_selected_info (thread_id, frame);
}
} else if (!a_input.compare (cur, strlen (PREFIX_FILES),
PREFIX_FILES)) {
- vector<UString> files ;
+ vector<UString> files;
if (!parse_file_list (a_input, cur, cur, files)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- result_record.file_list (files) ;
+ result_record.file_list (files);
LOG_D ("parsed a list of files: "
<< (int) files.size (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
} else if (!a_input.raw ().compare (cur, strlen (PREFIX_STACK),
PREFIX_STACK)) {
- vector<IDebugger::Frame> call_stack ;
+ vector<IDebugger::Frame> call_stack;
if (!parse_call_stack (a_input, cur, cur, call_stack)) {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- result_record.call_stack (call_stack) ;
+ result_record.call_stack (call_stack);
LOG_D ("parsed a call stack of depth: "
<< (int) call_stack.size (),
- GDBMI_PARSING_DOMAIN) ;
- vector<IDebugger::Frame>::iterator frame_iter ;
- for (frame_iter = call_stack.begin () ;
+ GDBMI_PARSING_DOMAIN);
+ vector<IDebugger::Frame>::iterator frame_iter;
+ for (frame_iter = call_stack.begin ();
frame_iter != call_stack.end ();
++frame_iter) {
LOG_D ("function-name: " << frame_iter->function_name (),
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_FRAME),
PREFIX_FRAME)) {
- IDebugger::Frame frame ;
+ IDebugger::Frame frame;
if (!parse_frame (a_input, cur, cur, frame)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed result", GDBMI_PARSING_DOMAIN) ;
- result_record.current_frame_in_core_stack_trace (frame) ;
- //current_frame_signal.emit (frame, "") ;
+ LOG_D ("parsed result", GDBMI_PARSING_DOMAIN);
+ result_record.current_frame_in_core_stack_trace (frame);
+ //current_frame_signal.emit (frame, "");
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_DEPTH),
PREFIX_DEPTH)) {
- GDBMIResultSafePtr result ;
- parse_gdbmi_result (a_input, cur, cur, result) ;
- THROW_IF_FAIL (result) ;
- LOG_D ("parsed result", GDBMI_PARSING_DOMAIN) ;
- } else if (!a_input.raw ().compare (cur, strlen (PREFIX_STACK_ARGS),
- PREFIX_STACK_ARGS)) {
- map<int, list<IDebugger::VariableSafePtr> > frames_args ;
- if (!parse_stack_arguments (a_input, cur, cur, frames_args)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ GDBMIResultSafePtr result;
+ parse_gdbmi_result (a_input, cur, cur, result);
+ THROW_IF_FAIL (result);
+ LOG_D ("parsed result", GDBMI_PARSING_DOMAIN);
+ } else if (!a_input.raw ().compare (cur,
+ strlen (PREFIX_STACK_ARGS),
+ PREFIX_STACK_ARGS)) {
+ map<int, list<IDebugger::VariableSafePtr> > frames_args;
+ if (!parse_stack_arguments (a_input, cur,
+ cur, frames_args)) {
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed stack args", GDBMI_PARSING_DOMAIN) ;
+ LOG_D ("parsed stack args", GDBMI_PARSING_DOMAIN);
}
- result_record.frames_parameters (frames_args) ;
+ result_record.frames_parameters (frames_args) ;
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_LOCALS),
PREFIX_LOCALS)) {
- list<IDebugger::VariableSafePtr> vars ;
+ list<IDebugger::VariableSafePtr> vars;
if (!parse_local_var_list (a_input, cur, cur, vars)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed local vars", GDBMI_PARSING_DOMAIN) ;
- result_record.local_variables (vars) ;
+ LOG_D ("parsed local vars", GDBMI_PARSING_DOMAIN);
+ result_record.local_variables (vars);
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_VALUE),
@@ -2871,62 +2877,62 @@
// evaluation. Currently all of these cases can be parsed as a
// variable, but there's no guarantee that this is the case.
// Perhaps this needs to be reworked somehow
- IDebugger::VariableSafePtr var ;
+ IDebugger::VariableSafePtr var;
if (!parse_variable_value (a_input, cur, cur, var)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed var value", GDBMI_PARSING_DOMAIN) ;
- THROW_IF_FAIL (var) ;
- result_record.variable_value (var) ;
+ LOG_D ("parsed var value", GDBMI_PARSING_DOMAIN);
+ THROW_IF_FAIL (var);
+ result_record.variable_value (var);
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_REGISTER_NAMES),
PREFIX_REGISTER_NAMES)) {
std::map<IDebugger::register_id_t, UString> regs;
if (!parse_register_names (a_input, cur, cur, regs)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed register names", GDBMI_PARSING_DOMAIN) ;
- result_record.register_names (regs) ;
+ LOG_D ("parsed register names", GDBMI_PARSING_DOMAIN);
+ result_record.register_names (regs);
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_CHANGED_REGISTERS),
PREFIX_CHANGED_REGISTERS)) {
std::list<IDebugger::register_id_t> regs;
if (!parse_changed_registers (a_input, cur, cur, regs)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed changed register", GDBMI_PARSING_DOMAIN) ;
- result_record.changed_registers (regs) ;
+ LOG_D ("parsed changed register", GDBMI_PARSING_DOMAIN);
+ result_record.changed_registers (regs);
}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_REGISTER_VALUES),
PREFIX_REGISTER_VALUES)) {
std::map<IDebugger::register_id_t, UString> values;
if (!parse_register_values (a_input, cur, cur, values)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed register values", GDBMI_PARSING_DOMAIN) ;
- result_record.register_values ( values) ;
+ LOG_D ("parsed register values", GDBMI_PARSING_DOMAIN);
+ result_record.register_values ( values);
}
} else if (!a_input.compare (cur, strlen (PREFIX_MEMORY_VALUES),
PREFIX_MEMORY_VALUES)) {
size_t addr;
std::vector<uint8_t> values;
if (!parse_memory_values (a_input, cur, cur, addr, values)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
- LOG_D ("parsed memory values", GDBMI_PARSING_DOMAIN) ;
- result_record.memory_values (addr, values) ;
+ LOG_D ("parsed memory values", GDBMI_PARSING_DOMAIN);
+ result_record.memory_values (addr, values);
}
} else {
- GDBMIResultSafePtr result ;
+ GDBMIResultSafePtr result;
if (!parse_gdbmi_result (a_input, cur, cur, result)
|| !result) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
} else {
LOG_D ("parsed unknown gdbmi result",
- GDBMI_PARSING_DOMAIN) ;
+ GDBMI_PARSING_DOMAIN);
}
}
@@ -2941,53 +2947,53 @@
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_RUNNING),
PREFIX_RUNNING)) {
- result_record.kind (Output::ResultRecord::RUNNING) ;
- cur += 8 ;
+ result_record.kind (Output::ResultRecord::RUNNING);
+ cur += 8;
for (;cur < end && a_input.raw ()[cur] != '\n';++cur) {}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_EXIT),
PREFIX_EXIT)) {
- result_record.kind (Output::ResultRecord::EXIT) ;
- cur += 5 ;
+ result_record.kind (Output::ResultRecord::EXIT);
+ cur += 5;
for (;cur < end && a_input.raw ()[cur] != '\n';++cur) {}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_CONNECTED),
PREFIX_CONNECTED)) {
- result_record.kind (Output::ResultRecord::CONNECTED) ;
- cur += 10 ;
+ result_record.kind (Output::ResultRecord::CONNECTED);
+ cur += 10;
for (;cur < end && a_input.raw ()[cur] != '\n';++cur) {}
} else if (!a_input.raw ().compare (cur,
strlen (PREFIX_ERROR),
PREFIX_ERROR)) {
- result_record.kind (Output::ResultRecord::ERROR) ;
- cur += 6 ;
- CHECK_END (a_input, cur, end) ;
- if (cur < end && a_input.raw ()[cur] == ',') {++cur ;}
- CHECK_END (a_input, cur, end) ;
+ result_record.kind (Output::ResultRecord::ERROR);
+ cur += 6;
+ CHECK_END (a_input, cur, end);
+ if (cur < end && a_input.raw ()[cur] == ',') {++cur;}
+ CHECK_END (a_input, cur, end);
if (!parse_attribute (a_input, cur, cur, name, value)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (name != "") {
LOG_DD ("got error with attribute: '"
- << name << "':'" << value << "'") ;
- result_record.attrs ()[name] = value ;
+ << name << "':'" << value << "'");
+ result_record.attrs ()[name] = value;
} else {
- LOG_ERROR ("weird, got error with no attribute. continuing.") ;
+ LOG_ERROR ("weird, got error with no attribute. continuing.");
}
for (;cur < end && a_input.raw ()[cur] != '\n';++cur) {}
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
if (a_input.raw ()[cur] != '\n') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- a_record = result_record ;
- a_to = cur ;
+ a_record = result_record;
+ a_to = cur;
return true;
}
@@ -2998,16 +3004,16 @@
UString::size_type &a_to,
Output &a_output)
{
- LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN) ;
+ LOG_FUNCTION_SCOPE_NORMAL_D (GDBMI_PARSING_DOMAIN);
- UString::size_type cur=a_from, end=a_input.bytes () ;
+ UString::size_type cur=a_from, end=a_input.bytes ();
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- Output output ;
+ Output output;
fetch_out_of_band_record:
if (a_input.raw () [cur] == '*'
@@ -3016,29 +3022,29 @@
|| a_input.raw ()[cur] == '&'
|| a_input.raw ()[cur] == '+'
|| a_input.raw ()[cur] == '=') {
- Output::OutOfBandRecord oo_record ;
+ Output::OutOfBandRecord oo_record;
if (!parse_out_of_band_record (a_input, cur, cur, oo_record)) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
- output.has_out_of_band_record (true) ;
- output.out_of_band_records ().push_back (oo_record) ;
- goto fetch_out_of_band_record ;
+ output.has_out_of_band_record (true);
+ output.out_of_band_records ().push_back (oo_record);
+ goto fetch_out_of_band_record;
}
if (cur > end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input.raw ()[cur] == '^') {
- Output::ResultRecord result_record ;
+ Output::ResultRecord result_record;
if (parse_result_record (a_input, cur, cur, result_record)) {
- output.has_result_record (true) ;
- output.result_record (result_record) ;
+ output.has_result_record (true);
+ output.result_record (result_record);
}
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
}
@@ -3046,19 +3052,19 @@
while (cur < end && isspace (a_input.raw ()[cur])) {++cur;}
if (!a_input.raw ().compare (cur, 5, "(gdb)")) {
- cur += 5 ;
+ cur += 5;
}
if (cur == a_from) {
//we didn't parse anything
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
while (cur < end && isspace (a_input.raw ()[cur])) {++cur;}
- a_output = output ;
- a_to = cur ;
+ a_output = output;
+ a_to = cur;
return true;
}
@@ -3069,159 +3075,159 @@
UString::size_type &a_to,
vector<IDebugger::OverloadsChoiceEntry> &a_prompts)
{
- UString::size_type cur=a_from, end=a_input.size () ;
- gunichar c = 0 ;
+ UString::size_type cur=a_from, end=a_input.size ();
+ gunichar c = 0;
if (cur >= end) {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
return false;
}
if (a_input[cur] != '[') {
- LOG_PARSING_ERROR (a_input, cur) ;
+ LOG_PARSING_ERROR (a_input, cur);
}
- c = a_input.raw ()[cur] ;
+ c = a_input.raw ()[cur];
- string index_str ;
- vector<IDebugger::OverloadsChoiceEntry> prompts ;
+ string index_str;
+ vector<IDebugger::OverloadsChoiceEntry> prompts;
while (c == '[') {
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- index_str.clear () ;
- c = a_input.raw ()[cur] ;
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ index_str.clear ();
+ c = a_input.raw ()[cur];
//look for the numerical index of the current prompt entry
for (;;) {
- CHECK_END (a_input, cur, end) ;
- c = a_input.raw ()[cur] ;
+ CHECK_END (a_input, cur, end);
+ c = a_input.raw ()[cur];
if (isdigit (c)) {
- index_str += a_input[cur] ;
+ index_str += a_input[cur];
} else if (c == ']') {
- break ;
+ break;
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- ++cur ;
+ ++cur;
if (cur >= end)
- break ;
- c = a_input.raw ()[cur] ;
+ break;
+ c = a_input.raw ()[cur];
}
//we should have the numerical index of the current prompt entry
//by now.
if (index_str.empty ()) {
- LOG_ERROR ("Could not parse prompt index") ;
- return false ;
+ LOG_ERROR ("Could not parse prompt index");
+ return false;
}
- LOG_DD ("prompt index: " << index_str) ;
- ++cur ;
- CHECK_END (a_input, cur, end) ;
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ LOG_DD ("prompt index: " << index_str);
+ ++cur;
+ CHECK_END (a_input, cur, end);
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
//now parse the prompt value.
//it is either "all", "cancel", or a function name/file location.
- IDebugger::OverloadsChoiceEntry entry ;
- entry.index (atoi (index_str.c_str ())) ;
+ IDebugger::OverloadsChoiceEntry entry;
+ entry.index (atoi (index_str.c_str ()));
if (end - cur >= 3
&& !a_input.raw ().compare (cur, 3, "all")) {
- entry.kind (IDebugger::OverloadsChoiceEntry::ALL) ;
- cur += 3 ;
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ entry.kind (IDebugger::OverloadsChoiceEntry::ALL);
+ cur += 3;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
LOG_DD ("pushing entry: " << (int) entry.index ()
- << ", all" ) ;
- prompts.push_back (entry) ;
+ << ", all" );
+ prompts.push_back (entry);
if (cur+1 < end && c == '\\' && a_input.raw ()[cur+1] == 'n') {
- cur += 2 ;
- c = a_input.raw ()[cur] ;
+ cur += 2;
+ c = a_input.raw ()[cur];
}
} else if (end - cur >= 6
&& !a_input.compare (cur, 6, "cancel")) {
- entry.kind (IDebugger::OverloadsChoiceEntry::CANCEL) ;
- cur += 6 ;
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ entry.kind (IDebugger::OverloadsChoiceEntry::CANCEL);
+ cur += 6;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
LOG_DD ("pushing entry: " << (int) entry.index ()
- << ", cancel") ;
- prompts.push_back (entry) ;
+ << ", cancel");
+ prompts.push_back (entry);
if (cur+1 < end && c == '\\' && a_input.raw ()[cur+1] == 'n') {
- cur += 2 ;
- c = a_input.raw ()[cur] ;
+ cur += 2;
+ c = a_input.raw ()[cur];
}
} else {
//try to parse a breakpoint location
- UString function_name, file_name, line_num ;
- UString::size_type b=0, e=0 ;
- b = cur ;
+ UString function_name, file_name, line_num;
+ UString::size_type b=0, e=0;
+ b = cur;
while (cur < end && a_input.raw ().compare (cur, 4, " at ")) {
- ++cur ;
+ ++cur;
}
- c = a_input.raw ()[cur] ;
+ c = a_input.raw ()[cur];
if (cur < end && !a_input.raw ().compare (cur, 4, " at ")) {
- e = cur ;
+ e = cur;
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- function_name.assign (a_input, b, e-b) ;
+ function_name.assign (a_input, b, e-b);
- cur += 4 ;
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
- b=cur ; e=0 ;
+ cur += 4;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
+ b=cur; e=0;
while (c != ':') {
- ++cur ;
+ ++cur;
if (cur >= end)
- break ;
- c = a_input.raw ()[cur] ;
+ break;
+ c = a_input.raw ()[cur];
}
if (cur < end && c == ':') {
- e = cur ;
+ e = cur;
} else {
- LOG_PARSING_ERROR (a_input, cur) ;
- return false ;
+ LOG_PARSING_ERROR (a_input, cur);
+ return false;
}
- file_name.assign (a_input, b, e-b) ;
- ++cur ;
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ file_name.assign (a_input, b, e-b);
+ ++cur;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
while (isdigit (c)) {
- line_num += c ;
- ++cur ;
+ line_num += c;
+ ++cur;
if (cur >= end)
- break ;
- c = a_input.raw ()[cur] ;
+ break;
+ c = a_input.raw ()[cur];
}
- entry.kind (IDebugger::OverloadsChoiceEntry::LOCATION) ;
- entry.function_name (function_name) ;
- entry.file_name (file_name) ;
- entry.line_number (atoi (line_num.c_str ())) ;
+ entry.kind (IDebugger::OverloadsChoiceEntry::LOCATION);
+ entry.function_name (function_name);
+ entry.file_name (file_name);
+ entry.line_number (atoi (line_num.c_str ()));
LOG_DD ("pushing entry: " << (int) entry.index ()
- << ", " << entry.function_name ()) ;
- prompts.push_back (entry) ;
+ << ", " << entry.function_name ());
+ prompts.push_back (entry);
if (cur >= end) {
- LOG_DD ("reached end, getting out") ;
- break ;
+ LOG_DD ("reached end, getting out");
+ break;
}
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
if (cur+1 < end
&& c == '\\' && a_input.raw ()[cur+1] == 'n') {
- cur += 2 ;
- c = a_input.raw ()[cur] ;
+ cur += 2;
+ c = a_input.raw ()[cur];
}
- SKIP_WS (a_input, cur, cur) ;
- c = a_input.raw ()[cur] ;
+ SKIP_WS (a_input, cur, cur);
+ c = a_input.raw ()[cur];
if (cur >= end)
- break ;
+ break;
}
}//end while//parse a prompt entry
if (prompts.empty ())
- return false ;
- a_prompts = prompts ;
- a_to = cur ;
- return true ;
+ return false;
+ a_prompts = prompts;
+ a_to = cur;
+ return true;
}
NEMIVER_END_NAMESPACE (nemiver)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
