Nemiver  0.3
nmv-gdbmi-parser.h
Go to the documentation of this file.
1 // -*- c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4; -*-'
2 //Author: Dodji Seketeli
3 /*
4  *This file is part of the Nemiver project
5  *
6  *Nemiver is free software; you can redistribute
7  *it and/or modify it under the terms of
8  *the GNU General Public License as published by the
9  *Free Software Foundation; either version 2,
10  *or (at your option) any later version.
11  *
12  *Nemiver is distributed in the hope that it will
13  *be useful, but WITHOUT ANY WARRANTY;
14  *without even the implied warranty of
15  *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16  *See the GNU General Public License for more details.
17  *
18  *You should have received a copy of the
19  *GNU General Public License along with Nemiver;
20  *see the file COPYING.
21  *If not, write to the Free Software Foundation,
22  *Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23  *
24  *See COPYRIGHT file copyright information.
25  */
26 #ifndef __NMV_GDBMI_PARSER_H
27 #define __NMV_GDBMI_PARSER_H
28 #include <boost/variant.hpp>
29 #include <iosfwd>
30 #include "nmv-i-debugger.h"
31 #include "nmv-dbg-common.h"
32 
33 NEMIVER_BEGIN_NAMESPACE (nemiver)
34 
35 class GDBMITuple;
36 class GDBMIResult;
37 class GDBMIValue;
38 class GDBMIList;
39 typedef SafePtr<GDBMIResult, ObjectRef, ObjectUnref> GDBMIResultSafePtr;
40 typedef SafePtr<GDBMITuple, ObjectRef, ObjectUnref> GDBMITupleSafePtr;
41 typedef SafePtr<GDBMIValue, ObjectRef, ObjectUnref> GDBMIValueSafePtr;
42 typedef SafePtr<GDBMIList, ObjectRef, ObjectUnref> GDBMIListSafePtr;
43 
46 class GDBMITuple : public Object {
47  GDBMITuple (const GDBMITuple&);
48  GDBMITuple& operator= (const GDBMITuple&);
49 
50  list<GDBMIResultSafePtr> m_content;
51 
52 public:
53 
54  // Please do not define the methods of this class inline here.
55  // Rather, define them in nmv-gdbmi-parser.cc, otherwise, this file
56  // will not compile on OpenBSD (gcc 3.3.5). Please read the comment before
57  // the definition of GDBMITuple methods in that file.
58  GDBMITuple () {}
59  virtual ~GDBMITuple () {}
60  const list<GDBMIResultSafePtr>& content () const;
61  void content (const list<GDBMIResultSafePtr> &a_in);
62  void append (const GDBMIResultSafePtr &a_result);
63  void clear ();
64 };//end class GDBMITuple
65 
72 class GDBMIValue : public Object {
73  GDBMIValue (const GDBMIValue&);
74  GDBMIValue& operator= (const GDBMIValue&);
75  typedef boost::variant<bool,
76  UString,
77  GDBMIListSafePtr,
78  GDBMITupleSafePtr> ContentType;
79  ContentType m_content;
80  friend class GDBMIResult;
81 
82 
83 public:
84  enum Type {
85  EMPTY_TYPE=0,
86  STRING_TYPE,
87  LIST_TYPE,
88  TUPLE_TYPE,
89  };
90 
91  GDBMIValue () {m_content = false;}
92 
93  GDBMIValue (const UString &a_str) {m_content = a_str;}
94 
95  GDBMIValue (const GDBMIListSafePtr &a_list)
96  {
97  m_content = a_list;
98  }
99 
100  GDBMIValue (const GDBMITupleSafePtr &a_tuple)
101  {
102  m_content = a_tuple;
103  }
104 
105  Type content_type () const {return (Type) m_content.which ();}
106 
107  const UString& get_string_content ()
108  {
109  THROW_IF_FAIL (content_type () == STRING_TYPE);
110  return boost::get<UString> (m_content);
111  }
112 
113  const GDBMIListSafePtr get_list_content () const
114  {
115  THROW_IF_FAIL (content_type () == LIST_TYPE);
116  return boost::get<GDBMIListSafePtr> (m_content);
117  }
118  GDBMIListSafePtr get_list_content ()
119  {
120  THROW_IF_FAIL (content_type () == LIST_TYPE);
121  return boost::get<GDBMIListSafePtr> (m_content);
122  }
123 
124  const GDBMITupleSafePtr get_tuple_content () const
125  {
126  THROW_IF_FAIL (content_type () == TUPLE_TYPE);
127  THROW_IF_FAIL (boost::get<GDBMITupleSafePtr> (&m_content));
128  return boost::get<GDBMITupleSafePtr> (m_content);
129  }
130  GDBMITupleSafePtr get_tuple_content ()
131  {
132  THROW_IF_FAIL (content_type () == TUPLE_TYPE);
133  THROW_IF_FAIL (boost::get<GDBMITupleSafePtr> (&m_content));
134  return boost::get<GDBMITupleSafePtr> (m_content);
135  }
136 
137 
138  const ContentType& content () const
139  {
140  return m_content;
141  }
142  void content (const ContentType &a_in)
143  {
144  m_content = a_in;
145  }
146 };//end class value
147 
151 class GDBMIResult : public Object {
152  GDBMIResult (const GDBMIResult&);
153  GDBMIResult& operator= (const GDBMIResult&);
154 
155  UString m_variable;
156  GDBMIValueSafePtr m_value;
157  bool m_is_singular;
158 
159 public:
160 
161  GDBMIResult () {}
162  GDBMIResult (const UString &a_variable,
163  const GDBMIValueSafePtr &a_value,
164  bool is_singular=false) :
165  m_variable (a_variable),
166  m_value (a_value),
167  m_is_singular (is_singular)
168  {}
169  virtual ~GDBMIResult () {}
170  const UString& variable () const {return m_variable;}
171  void variable (const UString& a_in) {m_variable = a_in;}
172  const GDBMIValueSafePtr& value () const {return m_value;}
173  void value (const GDBMIValueSafePtr &a_in) {m_value = a_in;}
174  bool is_singular () const {return m_is_singular;}
175  void set_is_singular (bool a_singular) {m_is_singular = a_singular;}
176 };//end class GDBMIResult
177 
179 class GDBMIList : public Object {
180  GDBMIList (const GDBMIList &);
181  GDBMIList& operator= (const GDBMIList &);
182 
183  list<boost::variant<GDBMIResultSafePtr, GDBMIValueSafePtr> > m_content;
184  bool m_empty;
185 
186 public:
187  enum ContentType {
188  RESULT_TYPE=0,
189  VALUE_TYPE,
190  UNDEFINED_TYPE
191  };
192 
193  GDBMIList () :
194  m_empty (true)
195  {}
196 
197  GDBMIList (const GDBMITupleSafePtr &a_tuple) :
198  m_empty (false)
199  {
200  GDBMIValueSafePtr value (new GDBMIValue (a_tuple));
201  //list<GDBMIValueSafePtr> value_list; value_list.push_back (value) ;
202  //list<GDBMIValueSafePtr> value_list; value_list.push_back (value) ;
203  //m_content = value_list;
204  m_content.push_back (value);
205  }
206 
207  GDBMIList (const UString &a_str) :
208  m_empty (false)
209  {
210  GDBMIValueSafePtr value (new GDBMIValue (a_str));
211  //list<GDBMIValueSafePtr> list;
212  //list.push_back (value);
213  //m_content = list;
214  m_content.push_back (value);
215  }
216 
217  GDBMIList (const GDBMIResultSafePtr &a_result) :
218  m_empty (false)
219  {
220  //list<GDBMIResultSafePtr> list;
221  //list.push_back (a_result);
222  //m_content = list;
223  m_content.push_back (a_result);
224  }
225 
226  GDBMIList (const GDBMIValueSafePtr &a_value) :
227  m_empty (false)
228  {
229  //list<GDBMIValueSafePtr> list;
230  //list.push_back (a_value);
231  //m_content = list;
232  m_content.push_back (a_value);
233  }
234 
235  virtual ~GDBMIList () {}
236  ContentType content_type () const
237  {
238  if (m_content.empty ()) {
239  return UNDEFINED_TYPE;
240  }
241  return (ContentType) m_content.front ().which ();
242  }
243 
244  bool empty () const {return m_empty;}
245 
246  void append (const GDBMIResultSafePtr &a_result)
247  {
248  THROW_IF_FAIL (a_result);
249  if (!m_content.empty ()) {
250  THROW_IF_FAIL (m_content.front ().which () == RESULT_TYPE);
251  }
252  m_content.push_back (a_result);
253  m_empty = false;
254  }
255  void append (const GDBMIValueSafePtr &a_value)
256  {
257  THROW_IF_FAIL (a_value);
258  if (!m_content.empty ()) {
259  THROW_IF_FAIL (m_content.front ().which () == VALUE_TYPE);
260  }
261  m_content.push_back (a_value);
262  m_empty = false;
263  }
264 
265  void get_result_content (list<GDBMIResultSafePtr> &a_list) const
266  {
267  if (empty ()) {return;}
268  THROW_IF_FAIL (content_type () == RESULT_TYPE);
269  list<boost::variant<GDBMIResultSafePtr,GDBMIValueSafePtr> >::const_iterator it;
270  for (it= m_content.begin (); it!= m_content.end () ; ++it) {
271  a_list.push_back (boost::get<GDBMIResultSafePtr> (*it));
272  }
273  }
274 
275  void get_value_content (list<GDBMIValueSafePtr> &a_list) const
276  {
277  if (empty ()) {return;}
278  THROW_IF_FAIL (content_type () == VALUE_TYPE);
279  list<boost::variant<GDBMIResultSafePtr,GDBMIValueSafePtr> >::const_iterator it;
280  for (it= m_content.begin (); it!= m_content.end () ; ++it) {
281  a_list.push_back (boost::get<GDBMIValueSafePtr> (*it));
282  }
283  }
284 };//end class GDBMIList
285 
286 //******************************************
287 //<gdbmi datastructure streaming operators>
288 //******************************************
289 
290 ostream& operator<< (ostream &a_out, const GDBMIValueSafePtr &a_val);
291 
292 ostream& operator<< (ostream &a_out, const GDBMIResultSafePtr &a_result);
293 
294 ostream& operator<< (ostream &a_out, const GDBMITupleSafePtr &a_tuple);
295 
296 ostream&
297 operator<< (ostream &a_out, const GDBMIListSafePtr a_list);
298 
299 ostream&
300 operator<< (ostream &a_out, const GDBMIValueSafePtr &a_val);
301 
302 std::ostream&
303 operator<< (std::ostream &a_out, const IDebugger::Variable &a_var);
304 
305 //******************************************
306 //</gdbmi datastructure streaming operators>
307 //******************************************
308 
309 bool gdbmi_result_to_string (GDBMIResultSafePtr a_result, UString &a_string);
310 
311 bool gdbmi_list_to_string (GDBMIListSafePtr a_list, UString &a_string);
312 
313 bool gdbmi_value_to_string (GDBMIValueSafePtr a_value, UString &a_string);
314 
315 bool gdbmi_tuple_to_string (GDBMITupleSafePtr a_result, UString &a_string);
316 
317 //**************************
318 //GDBMI parsing functions
319 //**************************
320 
321 class GDBMIParser {
322  // non copyable
323  GDBMIParser (const GDBMIParser &);
324  GDBMIParser& operator= (const GDBMIParser &);
325  struct Priv;
326  SafePtr<Priv> m_priv;
327 
328  bool analyse_pure_asm_instrs (GDBMIListSafePtr,
329  list<common::AsmInstr>&,
330  string::size_type a_cur);
331 
332  bool analyse_mixed_asm_instrs (GDBMIListSafePtr,
333  list<common::MixedAsmInstr>&,
334  string::size_type a_cur);
335 public:
336 
338  enum Mode {
339  UNDEFINED_MODE=0,
340  // This one means we adhere to the strict MI syntax.
341  STRICT_MODE,
342  // This one means we try to accept the broken MI ouptut from GDB,
343  // even those that are not MI compliant. This is implies best effort strategy.
344  BROKEN_MODE,
345  };
346  explicit GDBMIParser (Mode a_mode = STRICT_MODE);
347  explicit GDBMIParser (const UString &a_input, Mode a_mode = STRICT_MODE);
348  virtual ~GDBMIParser ();
349 
350  void push_input (const UString &a_input);
351  void pop_input ();
352  const UString& get_input () const;
353 
354  void set_mode (Mode);
355  Mode get_mode () const;
356 
357  //*********************
358  //<Parsing entry points.>
359  //*********************
360 
363  bool parse_string (UString::size_type a_from,
364  UString::size_type &a_to,
365  UString &a_string);
366 
367  bool parse_octal_escape (UString::size_type a_from,
368  UString::size_type &a_to,
369  unsigned char &a_byte_value);
370 
371  bool parse_octal_escape_sequence (UString::size_type a_from,
372  UString::size_type &a_to,
373  UString &a_result);
374 
375  bool parse_c_string_body (UString::size_type a_from,
376  UString::size_type &a_to,
377  UString &a_string);
378 
381  bool parse_c_string (UString::size_type a_from,
382  UString::size_type &a_to,
383  UString &a_c_string);
384 
385  bool parse_embedded_c_string_body (UString::size_type a_from,
386  UString::size_type &a_to,
387  UString &a_string);
388 
389  bool parse_embedded_c_string (UString::size_type a_from,
390  UString::size_type &a_to,
391  UString &a_string);
392 
398  bool parse_gdbmi_result (UString::size_type a_from,
399  UString::size_type &a_to,
400  GDBMIResultSafePtr &a_value);
401 
416  bool parse_gdbmi_value (UString::size_type a_from,
417  UString::size_type &a_to,
418  GDBMIValueSafePtr &a_value);
419 
423  bool parse_gdbmi_tuple (UString::size_type a_from,
424  UString::size_type &a_to,
425  GDBMITupleSafePtr &a_tuple);
426 
430  bool parse_gdbmi_list (UString::size_type a_from,
431  UString::size_type &a_to,
432  GDBMIListSafePtr &a_list);
433 
436  bool parse_gdbmi_string_result (UString::size_type a_from,
437  UString::size_type &a_to,
438  UString &a_variable,
439  UString &a_value);
440 
441  bool parse_stream_record (UString::size_type a_from,
442  UString::size_type &a_to,
443  Output::StreamRecord &a_record);
444 
449  bool parse_stopped_async_output (UString::size_type a_from,
450  UString::size_type &a_to,
451  bool &a_got_frame,
452  IDebugger::Frame &a_frame,
453  map<UString, UString> &a_attrs);
454 
460  bool parse_running_async_output (UString::size_type a_from,
461  UString::size_type &a_to,
462  int &a_thread_id);
463 
468  bool parse_thread_selected_async_output (UString::size_type a_from,
469  UString::size_type &a_to,
470  int &a_thread_id);
471 
472  bool parse_attribute (UString::size_type a_from,
473  UString::size_type &a_to,
474  UString &a_name,
475  UString &a_value);
476 
477  bool parse_attribute (UString::size_type a_from,
478  UString::size_type &a_to,
479  UString &a_name,
480  GDBMIResultSafePtr &a_value);
481 
486  bool parse_attributes (UString::size_type a_from,
487  UString::size_type &a_to,
488  map<UString, UString> &a_attrs);
489 
502  bool parse_frame (UString::size_type a_from,
503  UString::size_type &a_to,
504  IDebugger::Frame &a_frame);
505 
506  bool parse_out_of_band_record (UString::size_type a_from,
507  UString::size_type &a_to,
508  Output::OutOfBandRecord &a_record);
509 
510  bool parse_breakpoint_with_one_loc (Glib::ustring::size_type a_from,
511  Glib::ustring::size_type &a_to,
512  bool is_sub_breakpoint,
513  IDebugger::Breakpoint &a_bkpt);
514 
528  bool parse_breakpoint (Glib::ustring::size_type a_from,
529  Glib::ustring::size_type &a_to,
530  IDebugger::Breakpoint &a_bkpt);
531 
532  bool parse_breakpoint_table (UString::size_type a_from,
533  UString::size_type &a_to,
534  map<string, IDebugger::Breakpoint> &a_breakpoints);
535 
539  bool parse_breakpoint_modified_async_output (UString::size_type a_from,
540  UString::size_type &a_to,
541  IDebugger::Breakpoint &a_b);
542 
545  bool parse_threads_list (UString::size_type a_from,
546  UString::size_type &a_to,
547  std::list<int> &a_thread_ids);
548 
558  bool parse_new_thread_id (UString::size_type a_from,
559  UString::size_type &a_to,
560  int &a_thread_id,
561  IDebugger::Frame &a_frame);
562 
565  bool parse_file_list (UString::size_type a_from,
566  UString::size_type &a_to,
567  std::vector<UString> &a_files);
568 
571  bool parse_call_stack (const UString::size_type a_from,
572  UString::size_type &a_to,
573  vector<IDebugger::Frame> &a_stack);
574 
580  bool parse_stack_arguments
581  (UString::size_type a_from,
582  UString::size_type &a_to,
583  map<int, list<IDebugger::VariableSafePtr> > &a_params);
584 
587  bool parse_local_var_list (UString::size_type a_from,
588  UString::size_type &a_to,
589  list<IDebugger::VariableSafePtr> &a_vars);
590 
591  bool parse_member_variable (const UString::size_type a_from,
592  UString::size_type &a_to,
593  IDebugger::VariableSafePtr &a_var,
594  bool a_in_unnamed_var=false);
595 
600  bool parse_variable_value (const UString::size_type a_from,
601  UString::size_type &a_to,
602  IDebugger::VariableSafePtr &a_var);
603 
604  bool parse_overloads_choice_prompt
605  (UString::size_type a_from,
606  UString::size_type &a_to,
607  vector<IDebugger::OverloadsChoiceEntry> &a_prompts);
608 
609  bool parse_register_names (UString::size_type a_from,
610  UString::size_type &a_to,
611  std::map<IDebugger::register_id_t,
612  UString> &a_registers);
613 
614  bool parse_changed_registers (UString::size_type a_from,
615  UString::size_type &a_to,
616  std::list<IDebugger::register_id_t> &a_regs);
617 
618  bool parse_register_values (UString::size_type a_from,
619  UString::size_type &a_to,
620  std::map<IDebugger::register_id_t,
621  UString> &a_values);
622 
623  bool parse_memory_values (UString::size_type a_from,
624  UString::size_type &a_to,
625  size_t& a_start_addr,
626  std::vector<uint8_t> &a_values);
627 
630  bool parse_asm_instruction_list (UString::size_type a_from,
631  UString::size_type &a_to,
632  std::list<common::Asm> &a_asm);
633 
634  bool parse_variable (UString::size_type a_from,
635  UString::size_type &a_to,
636  IDebugger::VariableSafePtr &a_var);
637 
638  bool parse_variables_deleted (UString::size_type a_from,
639  UString::size_type &a_to,
640  unsigned int &a_nb_vars_deleted);
641 
642  bool parse_var_list_children (UString::size_type a_from,
643  UString::size_type &a_to,
644  vector<IDebugger::VariableSafePtr> &a_vars);
645 
646  bool parse_var_changed_list (UString::size_type a_from,
647  UString::size_type &a_to,
648  list<VarChangePtr> &a_var_changes);
649 
650  bool parse_var_path_expression (UString::size_type a_from,
651  UString::size_type &a_to,
652  UString &a_expression);
653 
654  bool parse_variable_format (UString::size_type a_from,
655  UString::size_type &a_to,
656  IDebugger::Variable::Format &a_format,
657  UString &a_value);
658 
659  bool parse_result_record (UString::size_type a_from,
660  UString::size_type &a_to,
661  Output::ResultRecord &a_record);
662 
664  bool parse_output_record (UString::size_type a_from,
665  UString::size_type &a_to,
666  Output &a_output);
667 
668  bool skip_output_record (UString::size_type a_from,
669  UString::size_type &a_to);
670 
671  //*********************
672  //</Parsing entry points.>
673  //*********************
674 };//end class GDBMIParser
675 
676 NEMIVER_END_NAMESPACE (nemiver)
677 #endif //__NMV_GDBMI_PARSER_H
678 
nemiver::GDBMIValue::get_list_content
GDBMIListSafePtr get_list_content()
Definition: nmv-gdbmi-parser.h:118
nemiver::GDBMIResult::set_is_singular
void set_is_singular(bool a_singular)
Definition: nmv-gdbmi-parser.h:175
nemiver::common::Object
Definition: nmv-object.h:43
nemiver::GDBMIResult
Definition: nmv-gdbmi-parser.h:151
nemiver::gdbmi_result_to_string
bool gdbmi_result_to_string(GDBMIResultSafePtr a_result, UString &a_string)
nemiver::GDBMIValue::GDBMIValue
GDBMIValue(const UString &a_str)
Definition: nmv-gdbmi-parser.h:93
nemiver::GDBMIList::GDBMIList
GDBMIList(const UString &a_str)
Definition: nmv-gdbmi-parser.h:207
nemiver
Definition: nmv-address.h:31
nemiver::GDBMIValue::get_string_content
const UString & get_string_content()
Definition: nmv-gdbmi-parser.h:107
nemiver::GDBMIResult::~GDBMIResult
virtual ~GDBMIResult()
Definition: nmv-gdbmi-parser.h:169
nemiver::gdbmi_list_to_string
bool gdbmi_list_to_string(GDBMIListSafePtr a_list, UString &a_string)
nemiver::GDBMIList::content_type
ContentType content_type() const
Definition: nmv-gdbmi-parser.h:236
nemiver::GDBMIParser::STRICT_MODE
@ STRICT_MODE
Definition: nmv-gdbmi-parser.h:341
nemiver::GDBMIParser::Mode
Mode
Parsing mode.
Definition: nmv-gdbmi-parser.h:338
nemiver::GDBMITuple::~GDBMITuple
virtual ~GDBMITuple()
Definition: nmv-gdbmi-parser.h:59
nemiver::GDBMIList::get_result_content
void get_result_content(list< GDBMIResultSafePtr > &a_list) const
Definition: nmv-gdbmi-parser.h:265
nemiver::GDBMIList::GDBMIList
GDBMIList(const GDBMIResultSafePtr &a_result)
Definition: nmv-gdbmi-parser.h:217
nemiver::GDBMIValue::STRING_TYPE
@ STRING_TYPE
Definition: nmv-gdbmi-parser.h:86
nemiver::common::UString
Definition: nmv-ustring.h:45
nemiver::GDBMIResult::value
const GDBMIValueSafePtr & value() const
Definition: nmv-gdbmi-parser.h:172
nemiver::GDBMIList
A GDB/MI LIST. It can be a list of either GDB/MI Result or GDB/MI Value.
Definition: nmv-gdbmi-parser.h:179
nemiver::GDBMIValue::get_tuple_content
const GDBMITupleSafePtr get_tuple_content() const
Definition: nmv-gdbmi-parser.h:124
nemiver::GDBMIList::GDBMIList
GDBMIList(const GDBMIValueSafePtr &a_value)
Definition: nmv-gdbmi-parser.h:226
nemiver::gdbmi_tuple_to_string
bool gdbmi_tuple_to_string(GDBMITupleSafePtr a_result, UString &a_string)
nemiver::GDBMIList::ContentType
ContentType
Definition: nmv-gdbmi-parser.h:187
nemiver::IDebugger::Variable::Format
Format
Definition: nmv-i-debugger.h:467
nemiver::GDBMIResult::variable
const UString & variable() const
Definition: nmv-gdbmi-parser.h:170
nemiver::GDBMIValue::Type
Type
Definition: nmv-gdbmi-parser.h:84
nemiver::GDBMIParser::BROKEN_MODE
@ BROKEN_MODE
Definition: nmv-gdbmi-parser.h:344
nemiver::operator<<
std::ostream & operator<<(std::ostream &a_out, const IDebugger::Variable &a_var)
nemiver::GDBMIList::VALUE_TYPE
@ VALUE_TYPE
Definition: nmv-gdbmi-parser.h:189
nemiver::GDBMIParser
Definition: nmv-gdbmi-parser.h:321
nemiver::GDBMIList::get_value_content
void get_value_content(list< GDBMIValueSafePtr > &a_list) const
Definition: nmv-gdbmi-parser.h:275
nemiver::IDebugger::register_id_t
unsigned int register_id_t
Definition: nmv-i-debugger.h:87
nemiver::GDBMIValueSafePtr
SafePtr< GDBMIValue, ObjectRef, ObjectUnref > GDBMIValueSafePtr
Definition: nmv-gdbmi-parser.h:41
nemiver::GDBMIListSafePtr
SafePtr< GDBMIList, ObjectRef, ObjectUnref > GDBMIListSafePtr
Definition: nmv-gdbmi-parser.h:42
nemiver::GDBMITuple
Definition: nmv-gdbmi-parser.h:46
nemiver::GDBMIList::GDBMIList
GDBMIList()
Definition: nmv-gdbmi-parser.h:193
nemiver::GDBMIValue
Definition: nmv-gdbmi-parser.h:72
nemiver::GDBMIResult::value
void value(const GDBMIValueSafePtr &a_in)
Definition: nmv-gdbmi-parser.h:173
nemiver::GDBMIResultSafePtr
SafePtr< GDBMIResult, ObjectRef, ObjectUnref > GDBMIResultSafePtr
Definition: nmv-gdbmi-parser.h:38
nemiver::Output
the output received from the debugger.
Definition: nmv-dbg-common.h:209
nemiver::GDBMIList::append
void append(const GDBMIResultSafePtr &a_result)
Definition: nmv-gdbmi-parser.h:246
nemiver::GDBMIValue::content
const ContentType & content() const
Definition: nmv-gdbmi-parser.h:138
nmv-dbg-common.h
nemiver::Output::OutOfBandRecord
the out of band record we got from GDB.
Definition: nmv-dbg-common.h:264
nemiver::GDBMIValue::GDBMIValue
GDBMIValue()
Definition: nmv-gdbmi-parser.h:91
nemiver::Output::StreamRecord
debugger stream record.
Definition: nmv-dbg-common.h:217
nemiver::GDBMIValue::content_type
Type content_type() const
Definition: nmv-gdbmi-parser.h:105
nemiver::GDBMIList::append
void append(const GDBMIValueSafePtr &a_value)
Definition: nmv-gdbmi-parser.h:255
nmv-i-debugger.h
nemiver::GDBMIList::GDBMIList
GDBMIList(const GDBMITupleSafePtr &a_tuple)
Definition: nmv-gdbmi-parser.h:197
nemiver::IDebugger::Frame
a function frame as seen by the debugger.
Definition: nmv-i-debugger.h:372
nemiver::GDBMITupleSafePtr
SafePtr< GDBMITuple, ObjectRef, ObjectUnref > GDBMITupleSafePtr
Definition: nmv-gdbmi-parser.h:40
nemiver::GDBMIValue::LIST_TYPE
@ LIST_TYPE
Definition: nmv-gdbmi-parser.h:87
nemiver::GDBMIValue::TUPLE_TYPE
@ TUPLE_TYPE
Definition: nmv-gdbmi-parser.h:88
nemiver::GDBMITuple::GDBMITuple
GDBMITuple()
Definition: nmv-gdbmi-parser.h:58
nemiver::GDBMIList::~GDBMIList
virtual ~GDBMIList()
Definition: nmv-gdbmi-parser.h:235
nemiver::IDebugger::Breakpoint
a breakpoint descriptor
Definition: nmv-i-debugger.h:90
nemiver::GDBMIResult::variable
void variable(const UString &a_in)
Definition: nmv-gdbmi-parser.h:171
nemiver::GDBMIValue::GDBMIValue
GDBMIValue(const GDBMITupleSafePtr &a_tuple)
Definition: nmv-gdbmi-parser.h:100
nemiver::GDBMIValue::content
void content(const ContentType &a_in)
Definition: nmv-gdbmi-parser.h:142
nemiver::GDBMIValue::get_list_content
const GDBMIListSafePtr get_list_content() const
Definition: nmv-gdbmi-parser.h:113
nemiver::GDBMIResult::GDBMIResult
GDBMIResult(const UString &a_variable, const GDBMIValueSafePtr &a_value, bool is_singular=false)
Definition: nmv-gdbmi-parser.h:162
nemiver::GDBMIResult::is_singular
bool is_singular() const
Definition: nmv-gdbmi-parser.h:174
nemiver::gdbmi_value_to_string
bool gdbmi_value_to_string(GDBMIValueSafePtr a_value, UString &a_string)
nemiver::GDBMIValue::GDBMIValue
GDBMIValue(const GDBMIListSafePtr &a_list)
Definition: nmv-gdbmi-parser.h:95
nemiver::common::SafePtr
Definition: nmv-safe-ptr.h:71
nemiver::GDBMIResult::GDBMIResult
GDBMIResult()
Definition: nmv-gdbmi-parser.h:161
nemiver::GDBMIList::empty
bool empty() const
Definition: nmv-gdbmi-parser.h:244
THROW_IF_FAIL
#define THROW_IF_FAIL(a_cond)
Definition: nmv-exception.h:65
nemiver::Output::ResultRecord
Definition: nmv-dbg-common.h:437
nemiver::GDBMIValue::get_tuple_content
GDBMITupleSafePtr get_tuple_content()
Definition: nmv-gdbmi-parser.h:130
Generated by   doxygen 1.8.17