diff --git a/core/org.eclipse.cdt.core/browser/ChangeLog-browser b/core/org.eclipse.cdt.core/browser/ChangeLog-browser index cc15e311dfc..d51cb9248c5 100644 --- a/core/org.eclipse.cdt.core/browser/ChangeLog-browser +++ b/core/org.eclipse.cdt.core/browser/ChangeLog-browser @@ -1,3 +1,8 @@ +2004-06-17 Alain Magloire + + Changes from Chris Wiebe to deal + with the memory consumption. + 2004-05-12 Chris Wiebe Heavy refactoring of type cache to address scalability concerns. diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/ITypeInfo.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/ITypeInfo.java index 6943508b7ce..62100aea57c 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/ITypeInfo.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/ITypeInfo.java @@ -35,6 +35,11 @@ public interface ITypeInfo extends Comparable { */ public int getCElementType(); + /** + * Sets the CElement type. + */ + public void setCElementType(int type); + /** * Gets the type name. */ diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/QualifiedTypeName.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/QualifiedTypeName.java index 153b18790ef..ec0a1390bf3 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/QualifiedTypeName.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/QualifiedTypeName.java @@ -97,7 +97,6 @@ public class QualifiedTypeName implements IQualifiedTypeName { return null; } -// TODO extra methods eg matchingFirstSegments() etc public boolean isEmpty() { return fSegments.length == 0; } @@ -179,7 +178,7 @@ public class QualifiedTypeName implements IQualifiedTypeName { public IQualifiedTypeName removeFirstSegments(int count) { if (count == 0) { - return new QualifiedTypeName(this); + return this; } else if (count >= fSegments.length || count < 0) { return new QualifiedTypeName(new String[0]); } else { @@ -192,7 +191,7 @@ public class QualifiedTypeName implements IQualifiedTypeName { public IQualifiedTypeName removeLastSegments(int count) { if (count == 0) { - return new QualifiedTypeName(this); + return this; } else if (count >= fSegments.length || count < 0) { return new QualifiedTypeName(new String[0]); } else { diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/TypeInfo.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/TypeInfo.java index 0c0783fc1c9..8c7808bfcb5 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/TypeInfo.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/TypeInfo.java @@ -10,10 +10,6 @@ *******************************************************************************/ package org.eclipse.cdt.core.browser; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Set; - import org.eclipse.cdt.core.model.ICElement; import org.eclipse.cdt.internal.core.browser.cache.ITypeCache; import org.eclipse.cdt.internal.core.browser.util.ArrayUtil; @@ -23,26 +19,44 @@ public class TypeInfo implements ITypeInfo { protected ITypeCache fTypeCache; protected int fElementType; - protected QualifiedTypeName fQualifiedName; - protected Set fSourceRefs = new HashSet(); + protected IQualifiedTypeName fQualifiedName; + protected ITypeReference[] fSourceRefs = null; + protected int fSourceRefsCount = 0; + + protected final static int INITIAL_REFS_SIZE = 1; + protected final static int REFS_GROW_BY = 10; protected final static ITypeInfo[] EMPTY_TYPES = new ITypeInfo[0]; public TypeInfo(int elementType, IQualifiedTypeName typeName) { fElementType = elementType; - fQualifiedName = new QualifiedTypeName(typeName); + fQualifiedName = typeName; } public void addReference(ITypeReference location) { - fSourceRefs.add(location); + if (fSourceRefs == null) { + fSourceRefs = new ITypeReference[INITIAL_REFS_SIZE]; + fSourceRefsCount = 0; + } else if (fSourceRefsCount == fSourceRefs.length) { + ITypeReference[] refs = new ITypeReference[fSourceRefs.length + REFS_GROW_BY]; + System.arraycopy(fSourceRefs, 0, refs, 0, fSourceRefsCount); + fSourceRefs = refs; + } + fSourceRefs[fSourceRefsCount] = location; + ++fSourceRefsCount; } public ITypeReference[] getReferences() { - return (ITypeReference[]) fSourceRefs.toArray(new ITypeReference[fSourceRefs.size()]); + if (fSourceRefs != null) { + ITypeReference[] refs = new ITypeReference[fSourceRefsCount]; + System.arraycopy(fSourceRefs, 0, refs, 0, fSourceRefsCount); + return refs; + } + return null; } public ITypeReference getResolvedReference() { - for (Iterator i = fSourceRefs.iterator(); i.hasNext(); ) { - ITypeReference location = (ITypeReference) i.next(); + for (int i = 0; i < fSourceRefsCount; ++i) { + ITypeReference location = fSourceRefs[i]; if (location.getLength() != 0) { return location; } @@ -51,7 +65,7 @@ public class TypeInfo implements ITypeInfo } public boolean isReferenced() { - return !fSourceRefs.isEmpty(); + return (fSourceRefs != null); } public boolean isUndefinedType() { @@ -171,12 +185,12 @@ public class TypeInfo implements ITypeInfo return true; // check if path is in scope - for (Iterator i = fSourceRefs.iterator(); i.hasNext(); ) { - ITypeReference location = (ITypeReference) i.next(); + for (int i = 0; i < fSourceRefsCount; ++i) { + ITypeReference location = fSourceRefs[i]; if (scope.encloses(location.getPath())) return true; } - + return false; } diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/IndexerTypesJob.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/IndexerTypesJob.java index 03002c1eb9f..bb4e1432e6b 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/IndexerTypesJob.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/IndexerTypesJob.java @@ -149,18 +149,28 @@ public class IndexerTypesJob extends IndexerJob { int[] references = entry.getFileReferences(); if (references != null && references.length > 0) { // add new type to cache - info = new TypeInfo(type, qualifiedName); - fTypeCache.insert(info); + if (info != null) { + info.setCElementType(type); + } else { + info = new TypeInfo(type, qualifiedName); + fTypeCache.insert(info); + } - for (int i = 0; i < references.length; ++i) { - if (monitor.isCanceled()) - throw new InterruptedException(); - - IndexedFile file = input.getIndexedFile(references[i]); - if (file != null && file.getPath() != null) { - IPath path = PathUtil.getWorkspaceRelativePath(file.getPath()); - info.addReference(new TypeReference(path, project)); - } +// for (int i = 0; i < references.length; ++i) { +// if (monitor.isCanceled()) +// throw new InterruptedException(); +// +// IndexedFile file = input.getIndexedFile(references[i]); +// if (file != null && file.getPath() != null) { +// IPath path = PathUtil.getWorkspaceRelativePath(file.getPath()); +// info.addReference(new TypeReference(path, project)); +// } +// } + // just grab the first reference + IndexedFile file = input.getIndexedFile(references[0]); + if (file != null && file.getPath() != null) { + IPath path = PathUtil.getWorkspaceRelativePath(file.getPath()); + info.addReference(new TypeReference(path, project)); } } } diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeCache.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeCache.java index 546fb504685..2925e854dd8 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeCache.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeCache.java @@ -44,12 +44,14 @@ import org.eclipse.core.runtime.jobs.Job; public class TypeCache implements ITypeCache { private static final int INITIAL_TYPE_COUNT = 100; - private final Map fTypeNameMap = new HashMap(INITIAL_TYPE_COUNT); + private final Map fTypeKeyMap = new HashMap(INITIAL_TYPE_COUNT); private final IProject fProject; private final IWorkingCopyProvider fWorkingCopyProvider; private final Collection fDeltas = new ArrayList(); private final ITypeInfo fGlobalNamespace; + private static final int[] ENCLOSING_TYPES = {ICElement.C_NAMESPACE, ICElement.C_CLASS, ICElement.C_STRUCT, 0}; + private IJobChangeListener fJobChangeListener = new IJobChangeListener() { public void aboutToRun(IJobChangeEvent event) { } @@ -94,7 +96,8 @@ public class TypeCache implements ITypeCache { private static class GlobalNamespace implements IQualifiedTypeName { private static final String GLOBAL_NAMESPACE = TypeCacheMessages.getString("TypeCache.globalNamespace"); //$NON-NLS-1$ - + private static final String[] segments = new String[] { GLOBAL_NAMESPACE }; + public GlobalNamespace() { } @@ -127,7 +130,7 @@ public class TypeCache implements ITypeCache { } public String[] segments() { - return new String[] { GLOBAL_NAMESPACE }; + return segments; } public String segment(int index) { @@ -161,11 +164,11 @@ public class TypeCache implements ITypeCache { } public IQualifiedTypeName removeFirstSegments(int count) { - return new QualifiedTypeName(this); + return this; } public IQualifiedTypeName removeLastSegments(int count) { - return new QualifiedTypeName(this); + return this; } public boolean isLowLevel() { @@ -207,6 +210,28 @@ public class TypeCache implements ITypeCache { } } + private static class HashKey { + private IQualifiedTypeName name; + private int type; + public HashKey(IQualifiedTypeName name, int type) { + this.name = name; + this.type = type; + } + public int hashCode() { + return (this.name.hashCode() + this.type); + } + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof HashKey)) { + return false; + } + HashKey otherKey = (HashKey)obj; + return (this.type == otherKey.type && this.name.equals(otherKey.name)); + } + } + public TypeCache(IProject project, IWorkingCopyProvider workingCopyProvider) { fProject = project; fWorkingCopyProvider = workingCopyProvider; @@ -240,89 +265,49 @@ public class TypeCache implements ITypeCache { } public synchronized boolean isEmpty() { - return fTypeNameMap.isEmpty(); + return fTypeKeyMap.isEmpty(); } - - public synchronized void insert(ITypeInfo newType) { - // check if type already exists - Collection typeCollection = (Collection) fTypeNameMap.get(newType.getName()); - if (typeCollection != null) { - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo currType = (ITypeInfo) typeIter.next(); - if (currType.canSubstituteFor(newType)) { - // merge references into new type - ITypeReference[] refs = currType.getReferences(); - for (int i = 0; i < refs.length; ++i) { - newType.addReference(refs[i]); - } - // remove the old type - currType.setCache(null); - typeIter.remove(); - } - } - } + public synchronized void insert(ITypeInfo newType) { // check if enclosing types are already in cache IQualifiedTypeName enclosingName = newType.getQualifiedTypeName().getEnclosingTypeName(); if (enclosingName != null) { while (!enclosingName.isEmpty()) { boolean foundType = false; - Collection enclosingCollection = (Collection) fTypeNameMap.get(enclosingName.getName()); - if (enclosingCollection == null) { - enclosingCollection = new HashSet(); - fTypeNameMap.put(enclosingName.getName(), enclosingCollection); - } else { - for (Iterator typeIter = enclosingCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo curr = (ITypeInfo) typeIter.next(); - if (curr.getQualifiedTypeName().equals(enclosingName)) { - foundType = true; - break; - } - } + // try namespace, class, struct, then undefined + ITypeInfo enclosingType = null; + for (int i = 0; enclosingType == null && i < ENCLOSING_TYPES.length; ++i) { + enclosingType = (ITypeInfo) fTypeKeyMap.get(new HashKey(enclosingName, ENCLOSING_TYPES[i])); } - if (!foundType) { + if (enclosingType == null) { // create a dummy type to take this place (type 0 == unknown) ITypeInfo dummyType = new TypeInfo(0, enclosingName); - enclosingCollection.add(dummyType); dummyType.setCache(this); + fTypeKeyMap.put(new HashKey(enclosingName, 0), dummyType); } enclosingName = enclosingName.removeLastSegments(1); } } - typeCollection = (Collection) fTypeNameMap.get(newType.getName()); - if (typeCollection == null) { - typeCollection = new HashSet(); - fTypeNameMap.put(newType.getName(), typeCollection); - } - typeCollection.add(newType); + fTypeKeyMap.put(new HashKey(newType.getQualifiedTypeName(), newType.getCElementType()), newType); newType.setCache(this); } public synchronized void remove(ITypeInfo info) { - Collection typeCollection = (Collection) fTypeNameMap.get(info.getName()); - if (typeCollection != null) { - info.setCache(null); - typeCollection.remove(info); - } + fTypeKeyMap.remove(new HashKey(info.getQualifiedTypeName(), info.getCElementType())); + info.setCache(null); } public synchronized void flush(ITypeSearchScope scope) { if (scope.encloses(fProject)) { flushAll(); } else { - for (Iterator mapIter = fTypeNameMap.entrySet().iterator(); mapIter.hasNext(); ) { + for (Iterator mapIter = fTypeKeyMap.entrySet().iterator(); mapIter.hasNext(); ) { Map.Entry entry = (Map.Entry) mapIter.next(); - Collection typeCollection = (Collection) entry.getValue(); - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo info = (ITypeInfo) typeIter.next(); - if (info.isEnclosed(scope)) { - info.setCache(null); - typeIter.remove(); - } - } - if (typeCollection.isEmpty()) + ITypeInfo info = (ITypeInfo) entry.getValue(); + if (info.isEnclosed(scope)) { mapIter.remove(); + } } } } @@ -342,19 +327,16 @@ public class TypeCache implements ITypeCache { } public boolean shouldContinue() { return true; } }); - fTypeNameMap.clear(); + fTypeKeyMap.clear(); } public synchronized void accept(ITypeInfoVisitor visitor) { - for (Iterator mapIter = fTypeNameMap.entrySet().iterator(); mapIter.hasNext(); ) { + for (Iterator mapIter = fTypeKeyMap.entrySet().iterator(); mapIter.hasNext(); ) { Map.Entry entry = (Map.Entry) mapIter.next(); - Collection typeCollection = (Collection) entry.getValue(); - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo info = (ITypeInfo) typeIter.next(); - if (!visitor.shouldContinue()) - return; // stop visiting - visitor.visit(info); - } + ITypeInfo info = (ITypeInfo) entry.getValue(); + if (!visitor.shouldContinue()) + return; // stop visiting + visitor.visit(info); } } @@ -364,10 +346,12 @@ public class TypeCache implements ITypeCache { public boolean visit(ITypeInfo info) { if (scope == null || info.isEnclosed(scope)) { ITypeReference[] refs = info.getReferences(); - for (int i = 0; i < refs.length; ++i) { - IPath path = refs[i].getPath(); - if (scope == null || scope.encloses(path)) - pathSet.add(path); + if (refs != null) { + for (int i = 0; i < refs.length; ++i) { + IPath path = refs[i].getPath(); + if (scope == null || scope.encloses(path)) + pathSet.add(path); + } } } return true; @@ -393,51 +377,38 @@ public class TypeCache implements ITypeCache { public synchronized ITypeInfo[] getTypes(IQualifiedTypeName qualifiedName) { Collection results = new ArrayList(); - Collection typeCollection = (Collection) fTypeNameMap.get(qualifiedName.getName()); - if (typeCollection != null) { - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo info = (ITypeInfo) typeIter.next(); - if (info.getQualifiedTypeName().equals(qualifiedName)) { - results.add(info); - } + for (int i = 0; i < ITypeInfo.KNOWN_TYPES.length; ++i) { + ITypeInfo info = (ITypeInfo) fTypeKeyMap.get(new HashKey(qualifiedName, ITypeInfo.KNOWN_TYPES[i])); + if (info != null) { + results.add(info); } } + ITypeInfo info = (ITypeInfo) fTypeKeyMap.get(new HashKey(qualifiedName, 0)); + if (info != null) { + results.add(info); + } return (ITypeInfo[]) results.toArray(new ITypeInfo[results.size()]); } public synchronized ITypeInfo getType(int type, IQualifiedTypeName qualifiedName) { - Collection typeCollection = (Collection) fTypeNameMap.get(qualifiedName.getName()); - if (typeCollection != null) { - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo info = (ITypeInfo) typeIter.next(); - if ((info.getCElementType() == type || info.getCElementType() == 0) - && info.getQualifiedTypeName().equals(qualifiedName)) { - return info; - } - } + ITypeInfo info = (ITypeInfo) fTypeKeyMap.get(new HashKey(qualifiedName, type)); + if (info == null && type != 0) { + info = (ITypeInfo) fTypeKeyMap.get(new HashKey(qualifiedName, 0)); } - return null; + return info; } public synchronized ITypeInfo getEnclosingType(ITypeInfo info, final int[] kinds) { IQualifiedTypeName enclosingName = info.getQualifiedTypeName().getEnclosingTypeName(); if (enclosingName != null) { - Collection typeCollection = (Collection) fTypeNameMap.get(enclosingName.getName()); - if (typeCollection != null) { - // try namespace, class, struct, then undefined - final int[] validKinds = {ICElement.C_NAMESPACE, ICElement.C_CLASS, ICElement.C_STRUCT, 0}; - for (int i = 0; i < validKinds.length; ++i) { - if (ArrayUtil.contains(kinds, validKinds[i])) { - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo type = (ITypeInfo) typeIter.next(); - if (type.getCElementType() == validKinds[i] - && type.getQualifiedTypeName().equals(enclosingName)) { - return type; - } - } - } + // try namespace, class, struct, then undefined + ITypeInfo enclosingType = null; + for (int i = 0; enclosingType == null && i < ENCLOSING_TYPES.length; ++i) { + if (ArrayUtil.contains(kinds, ENCLOSING_TYPES[i])) { + enclosingType = (ITypeInfo) fTypeKeyMap.get(new HashKey(enclosingName, ENCLOSING_TYPES[i])); } } + return enclosingType; } return null; } @@ -451,23 +422,12 @@ public class TypeCache implements ITypeCache { return fGlobalNamespace; return null; } - String[] segments = qualifiedName.segments(); - String namespace = segments[0]; - Collection typeCollection = (Collection) fTypeNameMap.get(namespace); - if (typeCollection != null) { - // try namespace, then undefined - final int[] kinds = {ICElement.C_NAMESPACE, 0}; - for (int i = 0; i < kinds.length; ++i) { - for (Iterator typeIter = typeCollection.iterator(); typeIter.hasNext(); ) { - ITypeInfo type = (ITypeInfo) typeIter.next(); - if (type.getCElementType() == kinds[i] - && type.getQualifiedTypeName().isGlobal()) { - return type; - } - } - } - } - return null; + IQualifiedTypeName namespace = qualifiedName.removeLastSegments(qualifiedName.segmentCount()-1); + // try namespace, then undefined + ITypeInfo namespaceType = (ITypeInfo) fTypeKeyMap.get(new HashKey(namespace, ICElement.C_NAMESPACE)); + if (namespaceType == null) + namespaceType = (ITypeInfo) fTypeKeyMap.get(new HashKey(namespace, 0)); + return namespaceType; } public synchronized boolean hasEnclosedTypes(final ITypeInfo info) { diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeParser.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeParser.java index f1d9d855e36..5585acd3488 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeParser.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeParser.java @@ -110,8 +110,8 @@ public class TypeParser implements ISourceElementRequestor { private IWorkingCopyProvider fWorkingCopyProvider; private IProgressMonitor fProgressMonitor; private ISourceElementCallbackDelegate fLastDeclaration; - private SimpleStack fScopeStack = new SimpleStack(); - private SimpleStack fResourceStack = new SimpleStack(); + private final SimpleStack fScopeStack = new SimpleStack(); + private final SimpleStack fResourceStack = new SimpleStack(); private ITypeInfo fTypeToFind; private boolean fFoundType; @@ -311,6 +311,8 @@ public class TypeParser implements ISourceElementRequestor { } if (reader != null) { + fResourceStack.clear(); + fScopeStack.clear(); fResourceStack.push(stackObject); parseContents(path, project, reader, language, progressMonitor); fResourceStack.pop(); @@ -419,7 +421,8 @@ public class TypeParser implements ISourceElementRequestor { } catch (ParserFactoryError e) { CCorePlugin.log(e); } catch (ParseError e) { - CCorePlugin.log(e); + // no need to log + // CCorePlugin.log(e); } catch (OperationCanceledException e) { throw new InterruptedException(); } catch (Exception e) { @@ -622,19 +625,35 @@ public class TypeParser implements ISourceElementRequestor { return; } - // collect enclosing names + if (fTypeToFind != null) { + if ((fTypeToFind.getCElementType() == type || fTypeToFind.isUndefinedType()) && name.equals(fTypeToFind.getName())) { + String[] enclosingNames = getEnclosingNames(offsetable); + QualifiedTypeName qualifiedName = new QualifiedTypeName(name, enclosingNames); + if (qualifiedName.equals(fTypeToFind.getQualifiedTypeName())) { + fFoundType = true; + + // add types to cache + addType(type, name, enclosingNames, fResourceStack.bottom(), fResourceStack.top(), offset, end - offset); + fProgressMonitor.worked(1); + } + } + } else { + // add types to cache + addType(type, name, getEnclosingNames(offsetable), fResourceStack.bottom(), fResourceStack.top(), offset, end - offset); + fProgressMonitor.worked(1); + } + } + + private String[] getEnclosingNames(IASTOffsetableNamedElement elem) { String[] enclosingNames = null; - if (offsetable instanceof IASTQualifiedNameElement) { - String[] names = ((IASTQualifiedNameElement) offsetable).getFullyQualifiedName(); + if (elem instanceof IASTQualifiedNameElement) { + String[] names = ((IASTQualifiedNameElement) elem).getFullyQualifiedName(); if (names != null && names.length > 1) { enclosingNames = new String[names.length - 1]; System.arraycopy(names, 0, enclosingNames, 0, names.length - 1); } } - - // add types to cache - addType(type, name, enclosingNames, fResourceStack.bottom(), fResourceStack.top(), offset, end - offset); - fProgressMonitor.worked(1); + return enclosingNames; } private int getElementType(IASTOffsetableNamedElement offsetable) { @@ -667,8 +686,12 @@ public class TypeParser implements ISourceElementRequestor { ITypeInfo info = fTypeCache.getType(type, qualifiedName); if (info == null || info.isUndefinedType()) { // add new type to cache - info = new TypeInfo(type, qualifiedName); - fTypeCache.insert(info); + if (info != null) { + info.setCElementType(type); + } else { + info = new TypeInfo(type, qualifiedName); + fTypeCache.insert(info); + } TypeReference location; if (originalRef instanceof IWorkingCopy) { @@ -696,10 +719,6 @@ public class TypeParser implements ISourceElementRequestor { location = new TypeReference(path, fProject, offset, length); } info.addReference(location); - - if (fTypeToFind != null && fTypeToFind.equals(info)) { - fFoundType = true; - } } /* (non-Javadoc) diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/PathUtil.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/PathUtil.java index e86f4ba3abf..717603ad6df 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/PathUtil.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/PathUtil.java @@ -13,6 +13,7 @@ package org.eclipse.cdt.internal.core.browser.util; import java.io.File; import java.io.IOException; +import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IWorkspace; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; @@ -70,10 +71,26 @@ public class PathUtil { return fullPath; } + public static IPath getProjectRelativePath(IPath fullPath, IProject project) { + IPath projectPath = project.getFullPath(); + if (projectPath.isPrefixOf(fullPath)) { + return fullPath.removeFirstSegments(projectPath.segmentCount()); + } + projectPath = project.getLocation(); + if (projectPath.isPrefixOf(fullPath)) { + return fullPath.removeFirstSegments(projectPath.segmentCount()); + } + return getWorkspaceRelativePath(fullPath); + } + public static IPath getWorkspaceRelativePath(String fullPath) { return getWorkspaceRelativePath(new Path(fullPath)); } + public static IPath getProjectRelativePath(String fullPath, IProject project) { + return getProjectRelativePath(new Path(fullPath), project); + } + public static IPath getRawLocation(IPath wsRelativePath) { IWorkspaceRoot workspaceRoot = getWorkspaceRoot(); if (workspaceRoot != null && wsRelativePath != null) { diff --git a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/SimpleStack.java b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/SimpleStack.java index 0c32f5bc85e..433f55a832d 100644 --- a/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/SimpleStack.java +++ b/core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/util/SimpleStack.java @@ -31,6 +31,10 @@ public class SimpleStack { items = new ArrayList(initialSize); } + public void clear() { + items.clear(); + } + public Object push(Object item) { items.add(item); if (VERBOSE)