← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevplatform/utopic-proposed

« back to all changes in this revision

Viewing changes to language/duchain/identifier.h

  • Committer: Package Import Robot
  • Author(s): Scarlett Clark
  • Date: 2014-08-30 03:52:11 UTC
  • mfrom: (0.3.26)
  • Revision ID: package-import@ubuntu.com-20140830035211-wndqlc843eu2v8nk
Tags: 1.7.0-0ubuntu1
* New upstream release
* Add XS-Testsuite: autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
language/duchain/identifier.h
21
21
#define KDEVPLATFORM_IDENTIFIER_H
22
22
 
23
23
#include <QtCore/QList>
24
 
#include <QtCore/QStack>
25
24
#include <QtCore/QStringList>
26
25
#include <QtCore/QMetaType>
27
26
#include <util/kdevvarlengtharray.h>
28
 
 
29
 
#include <ksharedptr.h>
 
27
#include <config-kdevplatform.h>
30
28
 
31
29
#include "../languageexport.h"
32
30
#include "referencecounting.h"
46
44
class IdentifierPrivate;
47
45
class IndexedString;
48
46
 
49
 
///A helper-class to store an identifier by index in a type-safe way. 
50
 
///The difference to Identifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
51
 
///abilities or access to the contained data.
52
 
///This class does "disk reference counting"
53
 
///@warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point
54
 
struct KDEVPLATFORMLANGUAGE_EXPORT IndexedIdentifier : public ReferenceCountManager {
 
47
/**
 
48
 * A helper-class to store an identifier by index in a type-safe way.
 
49
 *
 
50
 * The difference to Identifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
 
51
 * abilities or access to the contained data.
 
52
 *
 
53
 * This class does "disk reference counting"
 
54
 *
 
55
 * @warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point.
 
56
 */
 
57
class KDEVPLATFORMLANGUAGE_EXPORT IndexedIdentifier : public ReferenceCountManager
 
58
{
 
59
public:
55
60
  IndexedIdentifier();
56
61
  IndexedIdentifier(const Identifier& id);
57
62
  IndexedIdentifier(const IndexedIdentifier& rhs);
 
63
  IndexedIdentifier(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT;
58
64
  IndexedIdentifier& operator=(const Identifier& id);
59
65
  IndexedIdentifier& operator=(const IndexedIdentifier& rhs);
 
66
  IndexedIdentifier& operator=(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT;
60
67
  ~IndexedIdentifier();
61
68
  bool operator==(const IndexedIdentifier& rhs) const;
62
69
  bool operator!=(const IndexedIdentifier& rhs) const;
63
70
  bool operator==(const Identifier& id) const;
64
71
 
65
 
  
66
72
  bool isEmpty() const;
67
73
 
68
74
  Identifier identifier() const;
69
75
  operator Identifier() const;
70
76
 
71
 
  uint getIndex() const {
 
77
  uint getIndex() const
 
78
  {
72
79
    return index;
73
80
  }
74
 
  
75
 
  private:
 
81
 
 
82
private:
76
83
  unsigned int index;
77
84
};
78
85
 
79
 
///A helper-class to store an identifier by index in a type-safe way.
80
 
///The difference to QualifiedIdentifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
81
 
///abilities or access to the contained data.
82
 
///This class does "disk reference counting"
83
 
///@warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point
84
 
class KDEVPLATFORMLANGUAGE_EXPORT IndexedQualifiedIdentifier : public ReferenceCountManager {
 
86
/**
 
87
 * A helper-class to store an identifier by index in a type-safe way.
 
88
 *
 
89
 * The difference to QualifiedIdentifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
 
90
 * abilities or access to the contained data.
 
91
 *
 
92
 * This class does "disk reference counting"
 
93
 *
 
94
 * @warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point.
 
95
 */
 
96
class KDEVPLATFORMLANGUAGE_EXPORT IndexedQualifiedIdentifier : public ReferenceCountManager
 
97
{
85
98
public:
86
 
 
87
99
  IndexedQualifiedIdentifier();
88
100
  IndexedQualifiedIdentifier(const QualifiedIdentifier& id);
89
101
  IndexedQualifiedIdentifier(const IndexedQualifiedIdentifier& rhs);
 
102
  IndexedQualifiedIdentifier(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
90
103
  IndexedQualifiedIdentifier& operator=(const QualifiedIdentifier& id);
91
104
  IndexedQualifiedIdentifier& operator=(const IndexedQualifiedIdentifier& id);
 
105
  IndexedQualifiedIdentifier& operator=(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
92
106
  ~IndexedQualifiedIdentifier();
93
107
  bool operator==(const IndexedQualifiedIdentifier& rhs) const;
94
108
  bool operator==(const QualifiedIdentifier& id) const;
95
109
 
96
 
  bool operator<(const IndexedQualifiedIdentifier& rhs) const {
 
110
  bool operator<(const IndexedQualifiedIdentifier& rhs) const
 
111
  {
97
112
    return index < rhs.index;
98
113
  }
99
114
 
100
115
  bool isValid() const;
 
116
  bool isEmpty() const;
101
117
 
102
118
  QualifiedIdentifier identifier() const;
103
119
  operator QualifiedIdentifier() const;
104
120
 
105
 
  uint getIndex() const {
 
121
  uint getIndex() const
 
122
  {
106
123
    return index;
107
124
  }
108
 
  
109
 
  private:
 
125
 
 
126
private:
110
127
  uint index;
111
128
};
112
129
 
113
 
/// Represents a single unqualified identifier
 
130
/**
 
131
 * Represents a single unqualified identifier
 
132
 */
114
133
class KDEVPLATFORMLANGUAGE_EXPORT Identifier
115
134
{
116
135
  friend class QualifiedIdentifier;
117
136
 
118
137
public:
119
138
  /**
120
 
   * @param start The position in the given string where to start searching for the identifier(optional).
121
 
   * @param takenRange If this is nonzero, it will be filled with the length of the range from the beginning of the given string, that was used to construct this identifier.(optional)
122
 
   * @warning The identifier is parsed in a C++-similar way, and the result may not be what you expect. If you want to prevent that parsing, use the constructor that takes IndexedString.
123
 
   * */
 
139
   * @param start The position in the given string where to start searching for the identifier. (optional)
 
140
   * @param takenRange If this is nonzero, it will be filled with the length of the range from the beginning
 
141
   *                   of the given string, that was used to construct this identifier. (optional)
 
142
   *
 
143
   * @warning The identifier is parsed in a C++-similar way, and the result may not be what you expect.
 
144
   *          If you want to prevent that parsing, use the constructor that takes IndexedString.
 
145
   */
124
146
  explicit Identifier(const QString& str, uint start = 0, uint* takenRange = 0);
125
 
  ///Preferred constructor, ise this if you already have an IndexedString available. This does not decompose the given string.
 
147
  /**
 
148
   * Preferred constructor, use this if you already have an IndexedString available. This does not decompose the given string.
 
149
   */
126
150
  explicit Identifier(const IndexedString& str);
127
151
  Identifier(const Identifier& rhs);
128
152
  Identifier(uint index);
129
153
  Identifier();
 
154
  Identifier(Identifier&& rhs) Q_DECL_NOEXCEPT;
130
155
  ~Identifier();
 
156
  Identifier& operator=(const Identifier& rhs);
 
157
  Identifier& operator=(Identifier&& rhs) Q_DECL_NOEXCEPT;
131
158
 
132
159
  static Identifier unique(int token);
133
160
 
134
161
  bool isUnique() const;
135
162
  int uniqueToken() const;
136
 
  /// If \a token is non-zero, turns this Identifier into the special per-document
137
 
  /// Unique identifier, used for anonymous namespaces.
138
 
  /// Pass a token which is specific to the document to allow correct equality comparison.
 
163
  /**
 
164
   * If \a token is non-zero, turns this Identifier into the special per-document unique identifier.
 
165
   *
 
166
   * This is used e.g. for anonymous namespaces.
 
167
   *
 
168
   * Pass a token which is specific to the document to allow correct equality comparison.
 
169
   */
139
170
  void setUnique(int token);
140
171
 
141
172
  const IndexedString identifier() const;
142
173
  void setIdentifier(const QString& identifier);
143
 
  //Should be preferred over the other version
 
174
  /**
 
175
   * Should be preferred over the other version
 
176
   */
144
177
  void setIdentifier(const IndexedString& identifier);
145
178
 
146
 
//   QString mangled() const;
147
 
 
148
179
  uint hash() const;
149
180
 
150
181
  /**
151
182
   * Comparison ignoring the template-identifiers
152
 
   * */
 
183
   */
153
184
  bool nameEquals(const Identifier& rhs) const;
154
185
 
155
 
  //Expensive
 
186
  /**
 
187
   * @warning This is expensive.
 
188
   */
156
189
  IndexedTypeIdentifier templateIdentifier(int num) const;
157
190
  uint templateIdentifiersCount() const;
158
191
  void appendTemplateIdentifier(const IndexedTypeIdentifier& identifier);
163
196
 
164
197
  bool operator==(const Identifier& rhs) const;
165
198
  bool operator!=(const Identifier& rhs) const;
166
 
  Identifier& operator=(const Identifier& rhs);
167
199
 
168
200
  bool isEmpty() const;
169
201
 
170
 
  ///Returns a unique index within the global identifier repository for this identifier.
171
 
  ///If the identifier isn't in the repository yet, it is added to the repository.
 
202
  /**
 
203
   * @return a unique index within the global identifier repository for this identifier.
 
204
   *
 
205
   * If the identifier isn't in the repository yet, it is added to the repository.
 
206
   */
172
207
  uint index() const;
173
208
 
 
209
  bool inRepository() const;
174
210
private:
175
211
  void makeConstant() const;
176
212
  void prepareWrite();
187
223
 * Represents a qualified identifier
188
224
 *
189
225
 * QualifiedIdentifier has it's hash-values stored, so using the hash-values is very efficient.
190
 
 * */
 
226
 */
191
227
class KDEVPLATFORMLANGUAGE_EXPORT QualifiedIdentifier
192
228
{
193
229
public:
196
232
  QualifiedIdentifier(const QualifiedIdentifier& id);
197
233
  QualifiedIdentifier(uint index);
198
234
  QualifiedIdentifier();
199
 
  virtual ~QualifiedIdentifier();
 
235
  QualifiedIdentifier(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
 
236
  ~QualifiedIdentifier();
 
237
  QualifiedIdentifier& operator=(const QualifiedIdentifier& rhs);
 
238
  QualifiedIdentifier& operator=(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
200
239
 
 
240
  /**
 
241
   * Append @p id to this qualified identifier.
 
242
   */
 
243
  void push(const IndexedIdentifier& id);
 
244
  /**
 
245
   * Append @p id to this qualified identifier.
 
246
   *
 
247
   * NOTE: If you have an indexed identifier available, use the above method instead.
 
248
   */
201
249
  void push(const Identifier& id);
 
250
  /**
 
251
   * Append all identifiers of @p id to this qualified identifier.
 
252
   */
202
253
  void push(const QualifiedIdentifier& id);
203
 
  //Pops one identifier from back:
 
254
 
 
255
  /**
 
256
   * Pops one identifier from back:
 
257
   */
204
258
  void pop();
205
259
  void clear();
206
260
  bool isEmpty() const;
208
262
  Identifier first() const;
209
263
  Identifier last() const;
210
264
  Identifier top() const;
211
 
  const Identifier at(int i) const;
 
265
  Identifier at(int i) const;
212
266
  /**
213
267
   * @param pos Position where to start the copy.
214
268
   * @param len If this is -1, the whole following part will be returned.
215
 
   * */
 
269
   */
216
270
  QualifiedIdentifier mid(int pos, int len = -1) const;
217
271
 
218
272
  /**
219
273
   * Copy the leftmost \a len number of identifiers.
220
274
   *
221
275
   * @param len The number of identifiers to copy, or if negative, the number of identifiers to omit from the right
222
 
   * */
223
 
  inline QualifiedIdentifier left(int len) const { return mid(0, len > 0 ? len : count() + len); }
 
276
   */
 
277
  inline QualifiedIdentifier left(int len) const
 
278
  {
 
279
    return mid(0, len > 0 ? len : count() + len);
 
280
  }
224
281
 
225
282
  ///@todo Remove this flag
226
283
  bool explicitlyGlobal() const;
227
284
  void setExplicitlyGlobal(bool eg);
228
285
  bool isQualified() const;
229
286
 
230
 
  ///A flag that can be set by setIsExpression
 
287
  /**
 
288
   * A flag that can be set by setIsExpression
 
289
   */
231
290
  bool isExpression() const;
232
291
  /**
233
292
   * Set the expression-flag, that can be retrieved by isExpression().
234
293
   * This flag is not respected while creating the hash-value and while operator==() comparison.
235
294
   * It is respected while isSame(..) comparison.
236
 
   * */
 
295
   */
237
296
  void setIsExpression(bool);
238
297
 
239
298
  QString toString(bool ignoreExplicitlyGlobal = false) const;
240
299
  QStringList toStringList() const;
241
300
 
242
 
//   QString mangled() const;
243
 
 
244
301
  QualifiedIdentifier operator+(const QualifiedIdentifier& rhs) const;
245
302
  QualifiedIdentifier& operator+=(const QualifiedIdentifier& rhs);
246
303
 
247
 
  //Nicer interfaces to merge
 
304
  /**
 
305
   * Nicer interfaces to merge
 
306
   */
248
307
  QualifiedIdentifier operator+(const Identifier& rhs) const;
249
308
  QualifiedIdentifier& operator+=(const Identifier& rhs);
250
309
 
251
 
  //Returns a QualifiedIdentifier with this one appended to the other. It is explicitly global if either this or base is.
 
310
  QualifiedIdentifier operator+(const IndexedIdentifier& rhs) const;
 
311
  QualifiedIdentifier& operator+=(const IndexedIdentifier& rhs);
 
312
 
 
313
  /**
 
314
   * @return a QualifiedIdentifier with this one appended to the other.
 
315
   *
 
316
   * It is explicitly global if either this or base is.
 
317
   */
252
318
  QualifiedIdentifier merge(const QualifiedIdentifier& base) const;
253
319
 
254
320
  /**
255
 
   * Computes the hash-value that would be created with a qualified identifier with hash-value @param leftHash of size @param leftSize
256
 
   * with @param appendIdentifier appended as an identifier
257
 
   * */
258
 
//   static uint combineHash(uint leftHash, uint leftSize, Identifier appendIdentifier);
259
 
 
260
 
  /**The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
 
321
   * The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
261
322
   * This is for convenient use in hash-tables etc.
262
 
   * */
 
323
   */
263
324
  bool operator==(const QualifiedIdentifier& rhs) const;
264
325
  bool operator!=(const QualifiedIdentifier& rhs) const;
265
 
  QualifiedIdentifier& operator=(const QualifiedIdentifier& rhs);
266
326
 
267
327
  bool beginsWith(const QualifiedIdentifier& other) const;
268
328
 
269
329
  uint index() const;
270
 
  
 
330
 
271
331
  /**
272
 
   * Returns true if this qualified identifier is already in the persistent identifier repository
 
332
   * @return true if this qualified identifier is already in the persistent identifier repository
273
333
   */
274
334
  bool inRepository() const;
275
335
 
276
 
  typedef uint HashType;
277
 
 
278
 
  ///The hash does not respect explicitlyGlobal, only the real scope.
279
 
  HashType hash() const;
280
 
 
281
 
  ///Finds all identifiers in the identifier-repository that have the given hash value
282
 
  static void findByHash(HashType hash, KDevVarLengthArray<QualifiedIdentifier>& target);
 
336
  /**
 
337
   * The hash does not respect explicitlyGlobal, only the real scope.
 
338
   */
 
339
  uint hash() const;
 
340
 
 
341
  /**
 
342
   * Finds all identifiers in the identifier-repository that have the given hash value
 
343
   */
 
344
  static void findByHash(uint hash, KDevVarLengthArray<QualifiedIdentifier>& target);
283
345
 
284
346
protected:
285
347
  bool sameIdentifiers(const QualifiedIdentifier& rhs) const;
299
361
 * - Arbitrary count of pointer-poperators with cv-qualifiers
300
362
 * - Reference operator
301
363
 * All the properties set here are respected in the hash value.
302
 
 *
303
 
 * */
 
364
 */
304
365
class KDEVPLATFORMLANGUAGE_EXPORT IndexedTypeIdentifier
305
366
{
306
367
public:
307
 
  ///Variables like pointerDepth, isReference, etc. are not parsed from the string, so this parsing is quite limited.
308
 
  explicit IndexedTypeIdentifier(IndexedQualifiedIdentifier identifier = IndexedQualifiedIdentifier());
 
368
  /**
 
369
   * Variables like pointerDepth, isReference, etc. are not parsed from the string, so this parsing is quite limited.
 
370
   */
 
371
  explicit IndexedTypeIdentifier(const IndexedQualifiedIdentifier& identifier = IndexedQualifiedIdentifier());
309
372
  explicit IndexedTypeIdentifier(const QString& identifer, bool isExpression = false);
310
 
  
 
373
 
311
374
  bool isReference() const;
312
375
  void setIsReference(bool);
313
376
 
321
384
  void setIsVolatile(bool);
322
385
 
323
386
  IndexedQualifiedIdentifier identifier() const ;
324
 
  
325
 
  void setIdentifier(IndexedQualifiedIdentifier id);
326
 
 
327
 
  ///Returns the pointer depth. Example for C++: "char*" has pointer-depth 1, "char***" has pointer-depth 3
 
387
 
 
388
  void setIdentifier(const IndexedQualifiedIdentifier& id);
 
389
 
 
390
  /**
 
391
   * @return the pointer depth. Example for C++: "char*" has pointer-depth 1, "char***" has pointer-depth 3
 
392
   */
328
393
  int pointerDepth() const;
329
 
  /**Sets the pointer-depth to the specified count
 
394
  /**
 
395
   * Sets the pointer-depth to the specified count.
 
396
   *
330
397
   * When the pointer-depth is increased, the "isConstPointer" values for new depths will be initialized with false.
331
 
   * For efficiency-reasons the maximum currently is 23. */
 
398
   *
 
399
   * For efficiency-reasons the maximum currently is 23.
 
400
   */
332
401
  void setPointerDepth(int);
333
402
 
334
 
  ///Whether the target of pointer 'depthNumber' is constant
 
403
  /**
 
404
   * Whether the target of pointer 'depthNumber' is constant
 
405
   */
335
406
  bool isConstPointer(int depthNumber) const;
336
407
  void setIsConstPointer(int depthNumber, bool constant);
337
408
 
338
409
  QString toString(bool ignoreExplicitlyGlobal = false) const;
339
410
 
340
411
  uint hash() const;
341
 
  
342
 
  /**The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
 
412
 
 
413
  /**
 
414
   * The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
343
415
   * This is for convenient use in hash-tables etc.
344
 
   * */
 
416
   */
345
417
  bool operator==(const IndexedTypeIdentifier& rhs) const;
346
418
  bool operator!=(const IndexedTypeIdentifier& rhs) const;
347
 
  private:
348
 
    IndexedQualifiedIdentifier m_identifier;
349
 
    // The overall number of bits shared by these bit-fields should not exceed 32,
350
 
    // so that we don't waste space. IndexedTypeIdentifer should be as compact as possible.
351
 
    bool m_isConstant : 1;
352
 
    bool m_isReference : 1;
353
 
    bool m_isRValue : 1;
354
 
    bool m_isVolatile : 1;
355
 
    uint m_pointerDepth : 5;
356
 
    uint m_pointerConstMask : 23;
 
419
 
 
420
private:
 
421
  IndexedQualifiedIdentifier m_identifier;
 
422
  // The overall number of bits shared by these bit-fields should not exceed 32,
 
423
  // so that we don't waste space. IndexedTypeIdentifer should be as compact as possible.
 
424
  bool m_isConstant : 1;
 
425
  bool m_isReference : 1;
 
426
  bool m_isRValue : 1;
 
427
  bool m_isVolatile : 1;
 
428
  uint m_pointerDepth : 5;
 
429
  uint m_pointerConstMask : 23;
357
430
};
358
431
 
359
432
KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const IndexedTypeIdentifier& id);
360
433
KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const QualifiedIdentifier& id);
361
434
KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const Identifier& id);
362
435
 
 
436
inline uint qHash(const IndexedIdentifier& id)
 
437
{
 
438
  return id.getIndex();
 
439
}
 
440
 
 
441
inline uint qHash(const IndexedQualifiedIdentifier& id)
 
442
{
 
443
  return id.getIndex();
 
444
}
 
445
 
363
446
}
364
447
 
365
448
Q_DECLARE_TYPEINFO(KDevelop::IndexedQualifiedIdentifier, Q_MOVABLE_TYPE);