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 ArrayType;
64class BString;
65class Type;
66class ValueLocation;
67
68
69class BaseType : public BReferenceable {
70public:
71	virtual						~BaseType();
72
73	virtual	Type*				GetType() const = 0;
74};
75
76
77class DataMember : public BReferenceable {
78public:
79	virtual						~DataMember();
80
81	virtual	const char*			Name() const = 0;
82	virtual	Type*				GetType() const = 0;
83};
84
85
86class EnumeratorValue : public BReferenceable {
87public:
88	virtual						~EnumeratorValue();
89
90	virtual	const char*			Name() const = 0;
91	virtual	BVariant			Value() const = 0;
92};
93
94
95class ArrayDimension : public BReferenceable {
96public:
97	virtual						~ArrayDimension();
98
99	virtual	Type*				GetType() const = 0;
100									// subrange or enumeration
101	virtual	uint64				CountElements() const;
102									// returns 0, if unknown
103};
104
105
106class FunctionParameter : public BReferenceable {
107public:
108	virtual						~FunctionParameter();
109
110	virtual	const char*			Name() const = 0;
111	virtual	Type*				GetType() const = 0;
112};
113
114
115class TemplateParameter : public BReferenceable {
116public:
117	virtual						~TemplateParameter();
118
119	virtual	template_type_kind	Kind() const = 0;
120	virtual Type*				GetType() const = 0;
121	virtual	BVariant			Value() const = 0;
122};
123
124
125class Type : public BReferenceable {
126public:
127	virtual						~Type();
128
129	virtual	image_id			ImageID() const = 0;
130	virtual	const BString&		ID() const = 0;
131	virtual	const BString&		Name() const = 0;
132	virtual	type_kind			Kind() const = 0;
133	virtual	target_size_t		ByteSize() const = 0;
134	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
135									// strips modifiers and typedefs (only one,
136									// if requested)
137
138
139	virtual status_t			CreateDerivedAddressType(
140									address_type_kind kind,
141									AddressType*& _resultType);
142
143	virtual	status_t			CreateDerivedArrayType(
144									int64 lowerBound,
145									int64 elementCount,
146									bool extendExisting,
147										// if the current object is already
148										// an array type, attach an extra
149										// dimension to it rather than
150										// creating a new encapsulating
151										// type object
152									ArrayType*& _resultType);
153
154
155	virtual	status_t			ResolveObjectDataLocation(
156									const ValueLocation& objectLocation,
157									ValueLocation*& _location) = 0;
158									// returns a reference
159	virtual	status_t			ResolveObjectDataLocation(
160									target_addr_t objectAddress,
161									ValueLocation*& _location) = 0;
162									// returns a reference
163};
164
165
166class PrimitiveType : public virtual Type {
167public:
168	virtual						~PrimitiveType();
169
170	virtual	type_kind			Kind() const;
171
172	virtual	uint32				TypeConstant() const = 0;
173};
174
175
176class CompoundType : public virtual Type {
177public:
178	virtual						~CompoundType();
179
180	virtual	type_kind			Kind() const;
181	virtual compound_type_kind	CompoundKind() const = 0;
182
183	virtual	int32				CountBaseTypes() const = 0;
184	virtual	BaseType*			BaseTypeAt(int32 index) const = 0;
185
186	virtual	int32				CountDataMembers() const = 0;
187	virtual	DataMember*			DataMemberAt(int32 index) const = 0;
188
189	virtual int32				CountTemplateParameters() const = 0;
190	virtual TemplateParameter*	TemplateParameterAt(int32 index) const = 0;
191
192
193	virtual	status_t			ResolveBaseTypeLocation(BaseType* baseType,
194									const ValueLocation& parentLocation,
195									ValueLocation*& _location) = 0;
196									// returns a reference
197	virtual	status_t			ResolveDataMemberLocation(DataMember* member,
198									const ValueLocation& parentLocation,
199									ValueLocation*& _location) = 0;
200									// returns a reference
201};
202
203
204class ModifiedType : public virtual Type {
205public:
206	virtual						~ModifiedType();
207
208	virtual	type_kind			Kind() const;
209
210	virtual	uint32				Modifiers() const = 0;
211	virtual	Type*				BaseType() const = 0;
212	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
213};
214
215
216class TypedefType : public virtual Type {
217public:
218	virtual						~TypedefType();
219
220	virtual	type_kind			Kind() const;
221
222	virtual	Type*				BaseType() const = 0;
223	virtual	Type*				ResolveRawType(bool nextOneOnly) const;
224};
225
226
227class AddressType : public virtual Type {
228public:
229	virtual						~AddressType();
230
231	virtual	type_kind			Kind() const;
232
233	virtual	address_type_kind	AddressKind() const = 0;
234	virtual	Type*				BaseType() const = 0;
235};
236
237
238class EnumerationType : public virtual Type {
239public:
240	virtual						~EnumerationType();
241
242	virtual	type_kind			Kind() const;
243
244	virtual	Type*				BaseType() const = 0;
245									// may return NULL
246
247	virtual	int32				CountValues() const = 0;
248	virtual	EnumeratorValue*	ValueAt(int32 index) const = 0;
249	virtual	EnumeratorValue*	ValueFor(const BVariant& value) const;
250};
251
252
253class SubrangeType : public virtual Type {
254public:
255	virtual						~SubrangeType();
256
257	virtual	type_kind			Kind() const;
258
259	virtual	Type*				BaseType() const = 0;
260
261	virtual	BVariant			LowerBound() const = 0;
262	virtual	BVariant			UpperBound() const = 0;
263};
264
265
266class ArrayType : public virtual Type {
267public:
268	virtual						~ArrayType();
269
270	virtual	type_kind			Kind() const;
271
272	virtual	Type*				BaseType() const = 0;
273
274	virtual	int32				CountDimensions() const = 0;
275	virtual	ArrayDimension*		DimensionAt(int32 index) const = 0;
276
277	virtual	status_t			ResolveElementLocation(
278									const ArrayIndexPath& indexPath,
279									const ValueLocation& parentLocation,
280									ValueLocation*& _location) = 0;
281									// returns a reference
282};
283
284
285class UnspecifiedType : public virtual Type {
286public:
287	virtual						~UnspecifiedType();
288
289	virtual	type_kind			Kind() const;
290};
291
292
293class FunctionType : public virtual Type {
294public:
295	virtual						~FunctionType();
296
297	virtual	type_kind			Kind() const;
298
299	virtual	Type*				ReturnType() const = 0;
300
301	virtual	int32				CountParameters() const = 0;
302	virtual	FunctionParameter*	ParameterAt(int32 index) const = 0;
303
304	virtual	bool				HasVariableArguments() const = 0;
305};
306
307
308class PointerToMemberType : public virtual Type {
309public:
310	virtual						~PointerToMemberType();
311
312	virtual	type_kind			Kind() const;
313
314	virtual	CompoundType*		ContainingType() const = 0;
315	virtual	Type*				BaseType() const = 0;
316};
317
318
319#endif	// TYPE_H
320