1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/***************************************************************************
* Copyright (C) 2004 by Roberto Raggi *
* roberto@kdevelop.org *
* Copyright (C) 2005-2006 by Vladimir Prus *
* ghost@cs.msu.su *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Library General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef GDBMI_H
#define GDBMI_H
#include <qstring.h>
#include <qvaluelist.h>
#include <qmap.h>
#include <stdexcept>
/**
@author Roberto Raggi
@author Vladimir Prus
*/
namespace GDBMI
{
/** Exception that is thrown when we're trying to invoke an
operation that is not supported by specific MI value. For
example, trying to index a string literal.
Such errors are conceptually the same as assert, but in GUI
we can't use regular assert, and Q_ASSERT, which only prints
a message, is not suitable either. We need to break processing,
and the higher-level code can report "Internal parsing error",
or something.
Being glorified assert, this exception does not cary any
useful information.
*/
class type_error : public std::logic_error
{
public:
type_error();
};
/** Base class for all MI values.
MI values are of three kinds:
- String literals
- Lists (indexed by integer)
- Tuple (set of named values, indexed by name)
The structure of response to a specific gdb command is fixed.
While any tuples in response may omit certain named fields, the
kind of each item never changes. That is, response to specific
command can't contains sometimes string and sometimes tuple in
specific position.
Because of that static structure, it's almost never needed to query
dynamic type of a MI value. Most often we know it's say, tuple, and
can subscripts it.
So, the Value class has methods for accessing all kinds of values.
Attempting to call a method that is not applicable to specific value
will result in exception. The client code will almost never need to
cast from 'Value' to its derived classes.
Note also that all methods in this class are const and return
const Value&. That's by design -- there's no need to modify gdb
responses in GUI.
*/
struct Value
{
Value() {}
private: // Copy disabled to prevent slicing.
Value(const Value&);
Value& operator=(const Value&);
public:
virtual ~Value() {}
enum { StringLiteral, Tuple, List } kind;
/** If this value is a string literals, returns the string value.
Othewise, throws type_error.
*/
virtual QString literal() const;
/** If the value is a string literal, converts it to int and
returns. If conversion fails, or the value cannot be
converted to int, throws type_error.
*/
virtual int toInt(int base = 10) const;
/** If this value is a tuple, returns true if the tuple
has a field named 'variable'. Otherwise,
throws type_error.
*/
virtual bool hasField(const QString& variable) const;
/** If this value is a tuple, and contains named field 'variable',
returns it. Otherwise, throws 'type_error'.
This method is virtual, and derived in base class, so that
we can save on casting, when we know for sure that instance
is TupleValue, or ListValue.
*/
virtual const Value& operator[](const QString& variable) const;
/** If this value is a list, returns true if the list is empty.
If this value is not a list, throws 'type_error'.
*/
virtual bool empty() const;
/** If this value is a list, returns it's size.
Otherwise, throws 'type_error'.
*/
virtual unsigned size() const;
/** If this value is a list, returns the element at
'index'. Otherwise, throws 'type_error'.
*/
virtual const Value& operator[](unsigned index) const;
};
/** @internal
Internal class to represent name-value pair in tuples.
*/
struct Result
{
Result() : value(0) {}
~Result() { delete value; value = 0; }
QString variable;
Value *value;
};
struct StringLiteralValue : public Value
{
StringLiteralValue(const QString &lit)
: literal_(lit) { Value::kind = StringLiteral; }
public: // Value overrides
QString literal() const;
int toInt(int base) const;
private:
QString literal_;
};
struct TupleValue : public Value
{
TupleValue() { Value::kind = Tuple; }
~TupleValue();
bool hasField(const QString&) const;
const Value& operator[](const QString& variable) const;
QValueList<Result*> results;
QMap<QString, GDBMI::Result*> results_by_name;
};
struct ListValue : public Value
{
ListValue() { Value::kind = List; }
~ListValue();
bool empty() const;
unsigned size() const;
const Value& operator[](unsigned index) const;
QValueList<Result*> results;
};
struct Record
{
virtual ~Record() {}
virtual QString toString() const { Q_ASSERT( 0 ); return QString::null; }
enum { Prompt, Stream, Result } kind;
};
struct ResultRecord : public Record, public TupleValue
{
ResultRecord() { Record::kind = Result; }
QString reason;
};
struct PromptRecord : public Record
{
inline PromptRecord() { Record::kind = Prompt; }
virtual QString toString() const
{ return "(prompt)\n"; }
};
struct StreamRecord : public Record
{
inline StreamRecord() : reason(0) { Record::kind = Stream; }
char reason;
QString message;
};
}
#endif
|
