1/*
2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Distributed under the terms of the MIT License.
4 */
5#ifndef TYPE_H
6#define TYPE_H
7
8
9#include <image.h>
10
11#include <Referenceable.h>
12#include <Variant.h>
13
14#include "Types.h"
15
16
17enum type_kind {
18	TYPE_PRIMITIVE,
19	TYPE_COMPOUND,
20	TYPE_MODIFIED,
21	TYPE_TYPEDEF,
22	TYPE_ADDRESS,
23	TYPE_ENUMERATION,
24	TYPE_SUBRANGE,
25	TYPE_ARRAY,
26	TYPE_UNSPECIFIED,
27	TYPE_FUNCTION,
28	TYPE_POINTER_TO_MEMBER
29};
30
31
32enum compound_type_kind {
33	COMPOUND_TYPE_CLASS,
34	COMPOUND_TYPE_STRUCT,
35	COMPOUND_TYPE_UNION,
36	COMPOUND_TYPE_INTERFACE
37};
38
39
40enum address_type_kind {
41	DERIVED_TYPE_POINTER,
42	DERIVED_TYPE_REFERENCE
43};
44
45
46enum template_type_kind {
47	TEMPLATE_TYPE_TYPE,
48	TEMPLATE_TYPE_VALUE
49};
50
51
52enum {
53	TYPE_MODIFIER_CONST		= 0x01,
54	TYPE_MODIFIER_VOLATILE	= 0x02,
55	TYPE_MODIFIER_RESTRICT	= 0x04,
56	TYPE_MODIFIER_PACKED	= 0x08,
57	TYPE_MODIFIER_SHARED	= 0x10
58};
59
60
61class AddressType;
62class ArrayIndexPath;
63class BString;
64class Type;
65class ValueLocation;
66
67
68class BaseType : public BReferenceable {
69public:
70	virtual						~BaseType();
71
72	virtual	Type*				GetType() const = 0;
73};
74
75
76class DataMember : public BReferenceable {
77public:
78	virtual						~DataMember();
79
80	virtual	const char*			Name() const = 0;
81	virtual	Type*				GetType() const = 0;
82};
83
84
85class EnumeratorValue : public BReferenceable {
86public:
87	virtual						~EnumeratorValue();
88
89	virtual	const char*			Name() const = 0;
90	virtual	BVariant			Value() const = 0;
91};
92
93
94class ArrayDimension : public BReferenceable {
95public:
96	virtual						~ArrayDimension();
97
98	virtual	Type*				GetType() const = 0;
99									// subrange or enumeration
100	virtual	uint64				CountElements() const;
101									// returns 0, if unknown
102};
103
104
105class FunctionParameter : public BReferenceable {
106public:
107	virtual						~FunctionParameter();
108
109	virtual	const char*			Name() const = 0;
110	virtual	Type*				GetType() const = 0;
111};
112
113
114class TemplateParameter : public BReferenceable {
115public:
116	virtual						~TemplateParameter();
117
118	virtual	template_type_kind	Kind() const = 0;
119	virtual Type*				GetType() const = 0;
120	virtual	BVariant			Value() const = 0;
121};
122
123
124class Type : public BReferenceable {
125public:
126	virtual						~Type();
127
128	virtual	image_id			ImageID() const = 0;
129	virtual	const BString&		ID() const = 0;
130	virtual	const BString&		Name() const = 0;
131	virtual	type_kind			Kind() const = 0;
132	virtual	target_size_t		ByteSize() const = 0;
133	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
134									// strips modifiers and typedefs (only one,
135									// if requested)
136
137
138	// TODO: also need the ability to derive array types
139	virtual status_t			CreateDerivedAddressType(
140									address_type_kind kind,
141									AddressType*& _resultType);
142
143	virtual	status_t			ResolveObjectDataLocation(
144									const ValueLocation& objectLocation,
145									ValueLocation*& _location) = 0;
146									// returns a reference
147	virtual	status_t			ResolveObjectDataLocation(
148									target_addr_t objectAddress,
149									ValueLocation*& _location) = 0;
150									// returns a reference
151};
152
153
154class PrimitiveType : public virtual Type {
155public:
156	virtual						~PrimitiveType();
157
158	virtual	type_kind			Kind() const;
159
160	virtual	uint32				TypeConstant() const = 0;
161};
162
163
164class CompoundType : public virtual Type {
165public:
166	virtual						~CompoundType();
167
168	virtual	type_kind			Kind() const;
169	virtual compound_type_kind	CompoundKind() const = 0;
170
171	virtual	int32				CountBaseTypes() const = 0;
172	virtual	BaseType*			BaseTypeAt(int32 index) const = 0;
173
174	virtual	int32				CountDataMembers() const = 0;
175	virtual	DataMember*			DataMemberAt(int32 index) const = 0;
176
177	virtual int32				CountTemplateParameters() const = 0;
178	virtual TemplateParameter*	TemplateParameterAt(int32 index) const = 0;
179
180
181	virtual	status_t			ResolveBaseTypeLocation(BaseType* baseType,
182									const ValueLocation& parentLocation,
183									ValueLocation*& _location) = 0;
184									// returns a reference
185	virtual	status_t			ResolveDataMemberLocation(DataMember* member,
186									const ValueLocation& parentLocation,
187									ValueLocation*& _location) = 0;
188									// returns a reference
189};
190
191
192class ModifiedType : public virtual Type {
193public:
194	virtual						~ModifiedType();
195
196	virtual	type_kind			Kind() const;
197
198	virtual	uint32				Modifiers() const = 0;
199	virtual	Type*				BaseType() const = 0;
200	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
201};
202
203
204class TypedefType : public virtual Type {
205public:
206	virtual						~TypedefType();
207
208	virtual	type_kind			Kind() const;
209
210	virtual	Type*				BaseType() const = 0;
211	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
212};
213
214
215class AddressType : public virtual Type {
216public:
217	virtual						~AddressType();
218
219	virtual	type_kind			Kind() const;
220
221	virtual	address_type_kind	AddressKind() const = 0;
222	virtual	Type*				BaseType() const = 0;
223};
224
225
226class EnumerationType : public virtual Type {
227public:
228	virtual						~EnumerationType();
229
230	virtual	type_kind			Kind() const;
231
232	virtual	Type*				BaseType() const = 0;
233									// may return NULL
234
235	virtual	int32				CountValues() const = 0;
236	virtual	EnumeratorValue*	ValueAt(int32 index) const = 0;
237	virtual	EnumeratorValue*	ValueFor(const BVariant& value) const;
238};
239
240
241class SubrangeType : public virtual Type {
242public:
243	virtual						~SubrangeType();
244
245	virtual	type_kind			Kind() const;
246
247	virtual	Type*				BaseType() const = 0;
248
249	virtual	BVariant			LowerBound() const = 0;
250	virtual	BVariant			UpperBound() const = 0;
251};
252
253
254class ArrayType : public virtual Type {
255public:
256	virtual						~ArrayType();
257
258	virtual	type_kind			Kind() const;
259
260	virtual	Type*				BaseType() const = 0;
261
262	virtual	int32				CountDimensions() const = 0;
263	virtual	ArrayDimension*		DimensionAt(int32 index) const = 0;
264
265	virtual	status_t			ResolveElementLocation(
266									const ArrayIndexPath& indexPath,
267									const ValueLocation& parentLocation,
268									ValueLocation*& _location) = 0;
269									// returns a reference
270};
271
272
273class UnspecifiedType : public virtual Type {
274public:
275	virtual						~UnspecifiedType();
276
277	virtual	type_kind			Kind() const;
278};
279
280
281class FunctionType : public virtual Type {
282public:
283	virtual						~FunctionType();
284
285	virtual	type_kind			Kind() const;
286
287	virtual	Type*				ReturnType() const = 0;
288
289	virtual	int32				CountParameters() const = 0;
290	virtual	FunctionParameter*	ParameterAt(int32 index) const = 0;
291
292	virtual	bool				HasVariableArguments() const = 0;
293};
294
295
296class PointerToMemberType : public virtual Type {
297public:
298	virtual						~PointerToMemberType();
299
300	virtual	type_kind			Kind() const;
301
302	virtual	CompoundType*		ContainingType() const = 0;
303	virtual	Type*				BaseType() const = 0;
304};
305
306
307#endif	// TYPE_H
308