← Back to branch summary

~ubuntu-branches/ubuntu/quantal/kdevplatform/quantal-proposed

« back to all changes in this revision

Viewing changes to language/duchain/identifier.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-10-24 00:06:18 UTC
  • mfrom: (0.3.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20101024000618-7otebin77mfcmt3b
Tags: 1.1.0-0ubuntu1
* New upstream release
  - Bump build-dependencies
  - Build against libboost-serialization1.42-dev
  - Update kdevplatform1-libs.install
  - Update kdevplatform-dev.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
language/duchain/identifier.cpp
128
128
  const DynamicIdentifierPrivate& m_identifier;
129
129
};
130
130
 
131
 
RepositoryManager< ItemRepository<ConstantIdentifierPrivate, IdentifierItemRequest>, false> identifierRepository("Identifier Repository");
 
131
static RepositoryManager< ItemRepository<ConstantIdentifierPrivate, IdentifierItemRequest>, false>& identifierRepository() {
 
132
  static RepositoryManager< ItemRepository<ConstantIdentifierPrivate, IdentifierItemRequest>, false> identifierRepositoryObject("Identifier Repository");
 
133
  return identifierRepositoryObject;
 
134
}
132
135
 
133
136
///This has to be initialized now, else we will get a crash when multiple threads try accessing it for the first time in the same moment
134
137
uint emptyConstantIdentifierPrivateIndex() {
135
 
  static uint index = identifierRepository->index(DynamicIdentifierPrivate());
 
138
  static uint index = identifierRepository()->index(DynamicIdentifierPrivate());
136
139
  
137
140
  if(index == 0) ///Just so the function is instantiated right now
138
 
    identifierRepository->deleteItem(0);
 
141
    identifierRepository()->deleteItem(0);
139
142
  
140
143
  return index;
141
144
}
142
145
 
143
146
const ConstantIdentifierPrivate* emptyConstantIdentifierPrivate() {
144
 
  return identifierRepository->itemFromIndex(emptyConstantIdentifierPrivateIndex());
 
147
  return identifierRepository()->itemFromIndex(emptyConstantIdentifierPrivateIndex());
145
148
}
146
149
 
147
150
bool IndexedIdentifier::isEmpty() const {
269
272
};
270
273
 
271
274
AbstractRepositoryManager* returnIdentifierRepository() {
272
 
  return &identifierRepository;
 
275
  return &identifierRepository();
273
276
}
274
277
 
275
 
RepositoryManager< ItemRepository<ConstantQualifiedIdentifierPrivate, QualifiedIdentifierItemRequest>, false> qualifiedidentifierRepository("Qualified Identifier Repository", 1, &returnIdentifierRepository);
 
278
static RepositoryManager< ItemRepository<ConstantQualifiedIdentifierPrivate, QualifiedIdentifierItemRequest>, false>& qualifiedidentifierRepository() {
 
279
    static RepositoryManager< ItemRepository<ConstantQualifiedIdentifierPrivate, QualifiedIdentifierItemRequest>, false> qualifiedidentifierRepositoryObject("Qualified Identifier Repository", 1, &returnIdentifierRepository);
 
280
    return qualifiedidentifierRepositoryObject;
 
281
}
276
282
 
277
283
uint emptyConstantQualifiedIdentifierPrivateIndex() {
278
 
   static uint index = qualifiedidentifierRepository->index(DynamicQualifiedIdentifierPrivate());
 
284
   static uint index = qualifiedidentifierRepository()->index(DynamicQualifiedIdentifierPrivate());
279
285
    if(index == 0) ///Just so the function is instantiated right now
280
 
      identifierRepository->deleteItem(0);
 
286
      identifierRepository()->deleteItem(0);
281
287
   return index;
282
288
}
283
289
 
284
290
const ConstantQualifiedIdentifierPrivate* emptyConstantQualifiedIdentifierPrivate() {
285
 
  return qualifiedidentifierRepository->itemFromIndex(emptyConstantQualifiedIdentifierPrivateIndex());
 
291
  return qualifiedidentifierRepository()->itemFromIndex(emptyConstantQualifiedIdentifierPrivateIndex());
286
292
}
287
293
 
288
294
// uint QualifiedIdentifier::combineHash(uint leftHash, uint /*leftSize*/, Identifier appendIdentifier) {
297
303
 
298
304
Identifier::Identifier(uint index) : m_index(index) {
299
305
  Q_ASSERT(m_index);
300
 
  cd = identifierRepository->itemFromIndex(index);
 
306
  cd = identifierRepository()->itemFromIndex(index);
301
307
}
302
308
 
303
309
Identifier::~Identifier() {
501
507
void Identifier::makeConstant() const {
502
508
  if(m_index)
503
509
    return;
504
 
  m_index = identifierRepository->index( IdentifierItemRequest(*dd) );
 
510
  m_index = identifierRepository()->index( IdentifierItemRequest(*dd) );
505
511
  delete dd;
506
 
  cd = identifierRepository->itemFromIndex( m_index );
 
512
  cd = identifierRepository()->itemFromIndex( m_index );
507
513
}
508
514
 
509
515
void Identifier::prepareWrite() {
525
531
  if(m_index)
526
532
    return true;
527
533
  else
528
 
    return (bool)qualifiedidentifierRepository->findIndex( QualifiedIdentifierItemRequest(*dd) );
 
534
    return (bool)qualifiedidentifierRepository()->findIndex( QualifiedIdentifierItemRequest(*dd) );
529
535
}
530
536
 
531
 
QualifiedIdentifier::QualifiedIdentifier(uint index) : m_index(index), cd( qualifiedidentifierRepository->itemFromIndex(index) ) {
 
537
QualifiedIdentifier::QualifiedIdentifier(uint index) : m_index(index), cd( qualifiedidentifierRepository()->itemFromIndex(index) ) {
532
538
}
533
539
 
534
540
QualifiedIdentifier::QualifiedIdentifier(const QString& id, bool isExpression)
804
810
void QualifiedIdentifier::findByHash(HashType hash, KDevVarLengthArray<QualifiedIdentifier>& target)
805
811
{
806
812
  Visitor v(target, hash);
807
 
  qualifiedidentifierRepository->visitItemsWithHash<Visitor>(v, hash);
 
813
  qualifiedidentifierRepository()->visitItemsWithHash<Visitor>(v, hash);
808
814
}
809
815
 
810
816
uint QualifiedIdentifier::hash() const {
943
949
void QualifiedIdentifier::makeConstant() const {
944
950
  if(m_index)
945
951
    return;
946
 
  m_index = qualifiedidentifierRepository->index( QualifiedIdentifierItemRequest(*dd) );
 
952
  m_index = qualifiedidentifierRepository()->index( QualifiedIdentifierItemRequest(*dd) );
947
953
  delete dd;
948
 
  cd = qualifiedidentifierRepository->itemFromIndex( m_index );
 
954
  cd = qualifiedidentifierRepository()->itemFromIndex( m_index );
949
955
}
950
956
 
951
957
void QualifiedIdentifier::prepareWrite() {
1042
1048
 
1043
1049
IndexedIdentifier::IndexedIdentifier() : index(emptyConstantIdentifierPrivateIndex()) {
1044
1050
  if(shouldDoDUChainReferenceCounting(this)) {
1045
 
    QMutexLocker lock(identifierRepository->mutex());
1046
 
    increase(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1051
    QMutexLocker lock(identifierRepository()->mutex());
 
1052
    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1047
1053
  }
1048
1054
}
1049
1055
 
1050
1056
IndexedIdentifier::IndexedIdentifier(const Identifier& id) : index(id.index()) {
1051
1057
  if(shouldDoDUChainReferenceCounting(this)) {
1052
 
    QMutexLocker lock(identifierRepository->mutex());
1053
 
    increase(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1058
    QMutexLocker lock(identifierRepository()->mutex());
 
1059
    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1054
1060
  }
1055
1061
}
1056
1062
 
1057
1063
IndexedIdentifier::IndexedIdentifier(const IndexedIdentifier& rhs) : index(rhs.index) {
1058
1064
  if(shouldDoDUChainReferenceCounting(this)) {
1059
 
    QMutexLocker lock(identifierRepository->mutex());
1060
 
    increase(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1065
    QMutexLocker lock(identifierRepository()->mutex());
 
1066
    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1061
1067
  }
1062
1068
}
1063
1069
 
1064
1070
IndexedIdentifier::~IndexedIdentifier() {
1065
1071
  if(shouldDoDUChainReferenceCounting(this)) {
1066
 
    QMutexLocker lock(identifierRepository->mutex());
1067
 
    decrease(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1072
    QMutexLocker lock(identifierRepository()->mutex());
 
1073
    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1068
1074
  }
1069
1075
}
1070
1076
 
1071
1077
IndexedIdentifier& IndexedIdentifier::operator=(const Identifier& id) {
1072
1078
  if(shouldDoDUChainReferenceCounting(this)) {
1073
 
    QMutexLocker lock(identifierRepository->mutex());
1074
 
    decrease(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1079
    QMutexLocker lock(identifierRepository()->mutex());
 
1080
    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1075
1081
  }
1076
1082
 
1077
1083
  index = id.index();
1078
1084
 
1079
1085
  if(shouldDoDUChainReferenceCounting(this)) {
1080
 
    QMutexLocker lock(identifierRepository->mutex());
1081
 
    increase(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1086
    QMutexLocker lock(identifierRepository()->mutex());
 
1087
    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1082
1088
  }
1083
1089
  return *this;
1084
1090
}
1085
1091
 
1086
1092
IndexedIdentifier& IndexedIdentifier::operator=(const IndexedIdentifier& id) {
1087
1093
  if(shouldDoDUChainReferenceCounting(this)) {
1088
 
    QMutexLocker lock(identifierRepository->mutex());
1089
 
    decrease(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1094
    QMutexLocker lock(identifierRepository()->mutex());
 
1095
    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1090
1096
  }
1091
1097
 
1092
1098
  index = id.index;
1093
1099
 
1094
1100
  if(shouldDoDUChainReferenceCounting(this)) {
1095
 
    QMutexLocker lock(identifierRepository->mutex());
1096
 
    increase(identifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1101
    QMutexLocker lock(identifierRepository()->mutex());
 
1102
    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1097
1103
  }
1098
1104
  return *this;
1099
1105
}
1142
1148
    ifDebug( kDebug() << "increasing"; )
1143
1149
    
1144
1150
    //kDebug() << "(" << ++cnt << ")" << this << identifier().toString() << "inc" << index;
1145
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
1146
 
    increase(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1151
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
 
1152
    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1147
1153
  }
1148
1154
}
1149
1155
 
1152
1158
  
1153
1159
  if(shouldDoDUChainReferenceCounting(this)) {
1154
1160
    ifDebug( kDebug() << "increasing"; )
1155
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
1156
 
    increase(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1161
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
 
1162
    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1157
1163
  }
1158
1164
}
1159
1165
 
1163
1169
  if(shouldDoDUChainReferenceCounting(this)) {
1164
1170
    ifDebug( kDebug() << "increasing"; )
1165
1171
    
1166
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
1167
 
    increase(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1172
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
 
1173
    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1168
1174
  }
1169
1175
}
1170
1176
 
1172
1178
  ifDebug( kDebug() << "(" << ++cnt << ")" << identifier().toString() << index; )
1173
1179
  
1174
1180
  if(shouldDoDUChainReferenceCounting(this)) {
1175
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
 
1181
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
1176
1182
 
1177
1183
    ifDebug( kDebug() << "decreasing"; )
1178
 
    decrease(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1184
    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1179
1185
 
1180
1186
    index = id.index();
1181
1187
 
1182
1188
    ifDebug( kDebug() << index << "increasing"; )
1183
 
    increase(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1189
    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1184
1190
  } else {
1185
1191
    index = id.index();
1186
1192
  }
1193
1199
  ifDebug( kDebug() << "(" << ++cnt << ")" << identifier().toString() << index; )
1194
1200
  
1195
1201
  if(shouldDoDUChainReferenceCounting(this)) {
1196
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
 
1202
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
1197
1203
    ifDebug( kDebug() << "decreasing"; )
1198
1204
    
1199
 
    decrease(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1205
    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1200
1206
 
1201
1207
    index = rhs.index;
1202
1208
 
1203
1209
    ifDebug( kDebug() << index << "increasing"; )
1204
 
    increase(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1210
    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1205
1211
  } else {
1206
1212
    index = rhs.index;
1207
1213
  }
1213
1219
  ifDebug( kDebug() << "(" << ++cnt << ")" << identifier().toString() << index; )
1214
1220
  if(shouldDoDUChainReferenceCounting(this)) {
1215
1221
    ifDebug( kDebug() << index << "decreasing"; )
1216
 
    QMutexLocker lock(qualifiedidentifierRepository->mutex());
1217
 
    decrease(qualifiedidentifierRepository->dynamicItemFromIndexSimple(index)->m_refCount, index);
 
1222
    QMutexLocker lock(qualifiedidentifierRepository()->mutex());
 
1223
    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
1218
1224
  }
1219
1225
}
1220
1226