mirror of
https://github.com/eclipse-cdt/cdt
synced 2025-04-29 19:45:01 +02:00
Moved an improved cache for include paths into the ASTFilePathResolver, where it can be reused with EFS, bug 225302.
This commit is contained in:
Markus Schorn
parent
3d6501658c
commit
ac29604de3
8 changed files with 167 additions and 202 deletions
|
|
@ -35,19 +35,17 @@ import org.eclipse.cdt.core.parser.ICodeReaderCache;
|
|||
import org.eclipse.cdt.core.parser.ParserUtil;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IIndexBasedCodeReaderFactory;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IncludeFileContent;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IncludeFileResolutionCache;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IncludeFileContent.InclusionKind;
|
||||
import org.eclipse.cdt.internal.core.pdom.ASTFilePathResolver;
|
||||
import org.eclipse.cdt.internal.core.pdom.AbstractIndexerTask;
|
||||
import org.eclipse.cdt.internal.core.pdom.AbstractIndexerTask.FileContent;
|
||||
import org.eclipse.core.runtime.CoreException;
|
||||
import org.eclipse.core.runtime.IAdaptable;
|
||||
|
||||
/**
|
||||
* Code reader factory, that fakes code readers for header files already stored in the
|
||||
* index.
|
||||
*/
|
||||
public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderFactory, IAdaptable {
|
||||
public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderFactory {
|
||||
private static final class NeedToParseException extends Exception {}
|
||||
|
||||
private final IIndex fIndex;
|
||||
|
|
@ -57,7 +55,6 @@ public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderF
|
|||
private final ICodeReaderFactory fFallBackFactory;
|
||||
private final ASTFilePathResolver fPathResolver;
|
||||
private final AbstractIndexerTask fRelatedIndexerTask;
|
||||
private final IncludeFileResolutionCache fIncludeFileResolutionCache;
|
||||
|
||||
public IndexBasedCodeReaderFactory(IIndex index, ASTFilePathResolver pathResolver, int linkage,
|
||||
ICodeReaderFactory fallbackFactory) {
|
||||
|
|
@ -71,7 +68,6 @@ public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderF
|
|||
fPathResolver= pathResolver;
|
||||
fRelatedIndexerTask= relatedIndexerTask;
|
||||
fLinkage= linkage;
|
||||
fIncludeFileResolutionCache= new IncludeFileResolutionCache(1024);
|
||||
}
|
||||
|
||||
public int getUniqueIdentifier() {
|
||||
|
|
@ -92,6 +88,10 @@ public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderF
|
|||
return ParserUtil.createReader(path, null);
|
||||
}
|
||||
|
||||
public boolean getInclusionExists(String path) {
|
||||
return fPathResolver.doesIncludeFileExist(path);
|
||||
}
|
||||
|
||||
public IncludeFileContent getContentForInclusion(String path) {
|
||||
IIndexFileLocation ifl= fPathResolver.resolveIncludeFile(path);
|
||||
if (ifl == null) {
|
||||
|
|
@ -183,12 +183,4 @@ public final class IndexBasedCodeReaderFactory implements IIndexBasedCodeReaderF
|
|||
public void setLinkage(int linkageID) {
|
||||
fLinkage= linkageID;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public Object getAdapter(Class adapter) {
|
||||
if (adapter.isInstance(fIncludeFileResolutionCache)) {
|
||||
return fIncludeFileResolutionCache;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ import org.eclipse.core.runtime.Path;
|
|||
* @since 5.0
|
||||
*/
|
||||
public class StandaloneIndexerInputAdapter extends IndexerInputAdapter {
|
||||
private HashMap fIflCache= new HashMap();
|
||||
private HashMap<String, IIndexFileLocation> fIflCache= new HashMap<String, IIndexFileLocation>();
|
||||
|
||||
private final StandaloneIndexer fIndexer;
|
||||
|
||||
|
|
@ -38,28 +38,34 @@ public class StandaloneIndexerInputAdapter extends IndexerInputAdapter {
|
|||
fIndexer= indexer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IScannerInfo getBuildConfiguration(int linkageID, Object tu) {
|
||||
return fIndexer.getScannerInfo();
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getLastModified(IIndexFileLocation location) {
|
||||
return new File(location.getFullPath()).lastModified();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSourceUnit(Object tu) {
|
||||
return isValidSourceUnitName((String) tu);
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveFile(Object tu) {
|
||||
return resolveASTPath((String) tu);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getASTPath(IIndexFileLocation ifl) {
|
||||
return ifl.getFullPath();
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveASTPath(String astPath) {
|
||||
IIndexFileLocation result= (IIndexFileLocation) fIflCache.get(astPath);
|
||||
IIndexFileLocation result= fIflCache.get(astPath);
|
||||
if (result == null) {
|
||||
try {
|
||||
astPath = new File(astPath).getCanonicalPath();
|
||||
|
|
@ -73,13 +79,17 @@ public class StandaloneIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return result;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public boolean doesIncludeFileExist(String includePath) {
|
||||
return new File(includePath).exists();
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveIncludeFile(String includePath) {
|
||||
IIndexFileLocation result= (IIndexFileLocation) fIflCache.get(includePath);
|
||||
IIndexFileLocation result= fIflCache.get(includePath);
|
||||
if (result == null) {
|
||||
File file= new File(includePath);
|
||||
if (!file.exists()) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
includePath = file.getCanonicalPath();
|
||||
} catch (IOException e) {
|
||||
|
|
@ -92,14 +102,17 @@ public class StandaloneIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isFileBuildConfigured(Object tu) {
|
||||
return isValidSourceUnitName((String) tu);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canBePartOfSDK(IIndexFileLocation ifl) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public CodeReader getCodeReader(Object tu) {
|
||||
try {
|
||||
return new CodeReader((String) tu);
|
||||
|
|
@ -108,10 +121,12 @@ public class StandaloneIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getInputFile(IIndexFileLocation location) {
|
||||
return location.getFullPath();
|
||||
}
|
||||
|
||||
@Override
|
||||
public AbstractLanguage[] getLanguages(Object tu) {
|
||||
ILanguage language = fIndexer.getLanguageMapper().getLanguage((String) tu);
|
||||
if (language instanceof AbstractLanguage) {
|
||||
|
|
|
|||
|
|
@ -45,8 +45,6 @@ import org.eclipse.cdt.core.parser.util.CharArrayIntMap;
|
|||
import org.eclipse.cdt.core.parser.util.CharArrayMap;
|
||||
import org.eclipse.cdt.core.parser.util.CharArrayUtils;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.ExpressionEvaluator.EvalException;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IncludeFileResolutionCache.ISPKey;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.IncludeFileResolutionCache.LookupKey;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.Lexer.LexerOptions;
|
||||
import org.eclipse.cdt.internal.core.parser.scanner.MacroDefinitionParser.InvalidMacroDefinitionException;
|
||||
import org.eclipse.core.runtime.IAdaptable;
|
||||
|
|
@ -93,15 +91,16 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
|
||||
final private IIncludeFileTester<IncludeFileContent> createCodeReaderTester= new IIncludeFileTester<IncludeFileContent>() {
|
||||
public IncludeFileContent checkFile(String path, String fileName) {
|
||||
return createReader(path, fileName);
|
||||
String finalPath = ScannerUtility.createReconciledPath(path, fileName);
|
||||
return fCodeReaderFactory.getContentForInclusion(finalPath);
|
||||
}
|
||||
};
|
||||
|
||||
final private IIncludeFileTester<String> createPathTester= new IIncludeFileTester<String>() {
|
||||
public String checkFile(String path, String fileName) {
|
||||
path= ScannerUtility.createReconciledPath(path, fileName);
|
||||
if (new File(path).exists()) {
|
||||
return path;
|
||||
String finalPath= ScannerUtility.createReconciledPath(path, fileName);
|
||||
if (fCodeReaderFactory.getInclusionExists(finalPath)) {
|
||||
return finalPath;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
|
@ -121,9 +120,6 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
final private String[] fIncludePaths;
|
||||
final private String[] fQuoteIncludePaths;
|
||||
private String[][] fPreIncludedFiles= null;
|
||||
private final IncludeFileResolutionCache fIncludeResolutionCache;
|
||||
private final ISPKey fIncludePathKey;
|
||||
private final ISPKey fQuoteIncludePathKey;
|
||||
|
||||
private int fContentAssistLimit= -1;
|
||||
private boolean fHandledCompletion= false;
|
||||
|
|
@ -162,10 +158,6 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
fMacroExpander= new MacroExpander(this, fMacroDictionary, fLocationMap, fLexOptions);
|
||||
fCodeReaderFactory= wrapReaderFactory(readerFactory);
|
||||
|
||||
fIncludeResolutionCache= getIncludeResolutionCache(readerFactory);
|
||||
fIncludePathKey= fIncludeResolutionCache.getKey(fIncludePaths);
|
||||
fQuoteIncludePathKey= fIncludeResolutionCache.getKey(fQuoteIncludePaths);
|
||||
|
||||
setupMacroDictionary(configuration, info, language);
|
||||
|
||||
final String filePath= new String(reader.filename);
|
||||
|
|
@ -179,16 +171,6 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
}
|
||||
}
|
||||
|
||||
private IncludeFileResolutionCache getIncludeResolutionCache(ICodeReaderFactory readerFactory) {
|
||||
if (readerFactory instanceof IAdaptable) {
|
||||
IncludeFileResolutionCache cache= (IncludeFileResolutionCache) ((IAdaptable) readerFactory).getAdapter(IncludeFileResolutionCache.class);
|
||||
if (cache != null) {
|
||||
return cache;
|
||||
}
|
||||
}
|
||||
return new IncludeFileResolutionCache(1024);
|
||||
}
|
||||
|
||||
private IIndexBasedCodeReaderFactory wrapReaderFactory(final ICodeReaderFactory readerFactory) {
|
||||
if (readerFactory instanceof IIndexBasedCodeReaderFactory) {
|
||||
return (IIndexBasedCodeReaderFactory) readerFactory;
|
||||
|
|
@ -216,6 +198,9 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
public int getUniqueIdentifier() {
|
||||
return readerFactory.getUniqueIdentifier();
|
||||
}
|
||||
public boolean getInclusionExists(String path) {
|
||||
return readerFactory.createCodeReaderForInclusion(path) != null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -759,46 +744,18 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
|
||||
// if we're not include_next, then we are looking for the first occurrence of
|
||||
// the file, otherwise, we ignore all the paths before the current directory
|
||||
String[] isp;
|
||||
ISPKey ispKey;
|
||||
if (quoteInclude) {
|
||||
isp= fQuoteIncludePaths;
|
||||
ispKey= fQuoteIncludePathKey;
|
||||
}
|
||||
else {
|
||||
isp= fIncludePaths;
|
||||
ispKey= fIncludePathKey;
|
||||
}
|
||||
|
||||
final String[] isp= quoteInclude ? fQuoteIncludePaths : fIncludePaths;
|
||||
if (isp != null ) {
|
||||
int i=0;
|
||||
if (includeNext && currentDirectory != null) {
|
||||
final int startpos = findIncludePos(isp, currentDirectory) + 1;
|
||||
for (int i= startpos; i < isp.length; ++i) {
|
||||
i= findIncludePos(isp, currentDirectory) + 1;
|
||||
}
|
||||
for (; i < isp.length; ++i) {
|
||||
reader= tester.checkFile(isp[i], filename);
|
||||
if (reader != null) {
|
||||
return reader;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
final LookupKey lookupKey= fIncludeResolutionCache.getKey(ispKey, filename.toCharArray());
|
||||
Integer offset= fIncludeResolutionCache.getCachedPathOffset(lookupKey);
|
||||
if (offset != null) {
|
||||
if (offset < 0) {
|
||||
return null;
|
||||
}
|
||||
return tester.checkFile(isp[offset], filename);
|
||||
}
|
||||
|
||||
for (int i= 0; i < isp.length; ++i) {
|
||||
reader = tester.checkFile(isp[i], filename);
|
||||
if (reader != null) {
|
||||
fIncludeResolutionCache.putCachedPathOffset(lookupKey, i);
|
||||
return reader;
|
||||
}
|
||||
}
|
||||
fIncludeResolutionCache.putCachedPathOffset(lookupKey, -1);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
|
@ -849,12 +806,6 @@ public class CPreprocessor implements ILexerLog, IScanner, IAdaptable {
|
|||
fLocationMap.encounterProblem(id, arg, offset, endOffset);
|
||||
}
|
||||
|
||||
private IncludeFileContent createReader(String path, String fileName){
|
||||
String finalPath = ScannerUtility.createReconciledPath(path, fileName);
|
||||
return fCodeReaderFactory.getContentForInclusion(finalPath);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Assumes that the pound token has not yet been consumed
|
||||
* @param ppdCtx
|
||||
|
|
|
|||
|
|
@ -30,4 +30,10 @@ public interface IIndexBasedCodeReaderFactory extends ICodeReaderFactory {
|
|||
* @see IncludeFileContent
|
||||
*/
|
||||
public IncludeFileContent getContentForInclusion(String fileLocation);
|
||||
|
||||
/**
|
||||
* Check whether the specified inclusion exists.
|
||||
* @since 5.0
|
||||
*/
|
||||
boolean getInclusionExists(String finalPath);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,107 +0,0 @@
|
|||
/*******************************************************************************
|
||||
* Copyright (c) 2008 Wind River Systems, Inc. and others.
|
||||
* All rights reserved. This program and the accompanying materials
|
||||
* are made available under the terms of the Eclipse Public License v1.0
|
||||
* which accompanies this distribution, and is available at
|
||||
* http://www.eclipse.org/legal/epl-v10.html
|
||||
*
|
||||
* Contributors:
|
||||
* Markus Schorn - initial API and implementation
|
||||
*******************************************************************************/
|
||||
package org.eclipse.cdt.internal.core.parser.scanner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import org.eclipse.cdt.internal.core.parser.util.WeakHashSet;
|
||||
|
||||
/**
|
||||
* A limited LRU cache for looking up files in an include search path.
|
||||
* @since 5.0
|
||||
*/
|
||||
public final class IncludeFileResolutionCache {
|
||||
public static class ISPKey {
|
||||
private String[] fISP;
|
||||
private int fHashCode;
|
||||
|
||||
private ISPKey(String[] isp) {
|
||||
fISP= isp;
|
||||
fHashCode= Arrays.hashCode(isp);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
return obj != null && Arrays.equals(fISP, ((ISPKey) obj).fISP);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return fHashCode;
|
||||
}
|
||||
}
|
||||
|
||||
public static class LookupKey {
|
||||
private ISPKey fCanonicISP;
|
||||
private char[] fName;
|
||||
private int fHashCode;
|
||||
|
||||
private LookupKey(ISPKey ispKey, char[] include) {
|
||||
fCanonicISP= ispKey;
|
||||
fName= include;
|
||||
fHashCode= Arrays.hashCode(include) * 31 + ispKey.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return fHashCode;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
LookupKey other= (LookupKey) obj;
|
||||
if (fCanonicISP != other.fCanonicISP)
|
||||
return false;
|
||||
if (!Arrays.equals(fName, other.fName))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private WeakHashSet<ISPKey> fCanonicISPs;
|
||||
private LinkedHashMap<LookupKey, Integer> fCache;
|
||||
|
||||
/**
|
||||
* Creates a cache for include file resolution using up to the given amount of memory
|
||||
* @param maxSizeKBytes the maximum size of the cache in kilobytes
|
||||
*/
|
||||
public IncludeFileResolutionCache(final int maxSizeKBytes) {
|
||||
final int size= maxSizeKBytes*1024/72; // HashEntry 32 bytes, Key 16 bytes, Name 16 bytes, Integer 8 bytes
|
||||
fCache= new LinkedHashMap<LookupKey, Integer>(size, 0.75f, true) {
|
||||
@Override
|
||||
protected boolean removeEldestEntry(Map.Entry<LookupKey, Integer> eldest) {
|
||||
return size() > size;
|
||||
}
|
||||
};
|
||||
fCanonicISPs= new WeakHashSet<ISPKey>();
|
||||
}
|
||||
|
||||
public ISPKey getKey(String[] isp) {
|
||||
return fCanonicISPs.add(new ISPKey(isp));
|
||||
}
|
||||
|
||||
public LookupKey getKey(ISPKey ispKey, char[] filename) {
|
||||
return new LookupKey(ispKey, filename);
|
||||
}
|
||||
|
||||
public Integer getCachedPathOffset(LookupKey key) {
|
||||
return fCache.get(key);
|
||||
}
|
||||
|
||||
public void putCachedPathOffset(LookupKey key, int offset) {
|
||||
fCache.put(key, offset);
|
||||
}
|
||||
}
|
||||
|
|
@ -25,12 +25,17 @@ public abstract class ASTFilePathResolver {
|
|||
public abstract IIndexFileLocation resolveASTPath(String astFilePath);
|
||||
|
||||
/**
|
||||
* Resolve a path for an inclusion as computed by the preprocessor. Check for existance
|
||||
* Resolve a path for an inclusion as computed by the preprocessor. Check for existence
|
||||
* and return <code>null</code> if the file does not exist.
|
||||
* @return an index file location or <code>null</code> if the file does not exist.
|
||||
*/
|
||||
public abstract IIndexFileLocation resolveIncludeFile(String includePath);
|
||||
|
||||
/**
|
||||
* Check for existence of an inclusion as computed by the preprocessor.
|
||||
*/
|
||||
public abstract boolean doesIncludeFileExist(String includePath);
|
||||
|
||||
/**
|
||||
* Convert an index file location to the path as it will be stored in the AST.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -0,0 +1,75 @@
|
|||
/*******************************************************************************
|
||||
* Copyright (c) 2008 Wind River Systems, Inc. and others.
|
||||
* All rights reserved. This program and the accompanying materials
|
||||
* are made available under the terms of the Eclipse Public License v1.0
|
||||
* which accompanies this distribution, and is available at
|
||||
* http://www.eclipse.org/legal/epl-v10.html
|
||||
*
|
||||
* Contributors:
|
||||
* Markus Schorn - initial API and implementation
|
||||
*******************************************************************************/
|
||||
package org.eclipse.cdt.internal.core.pdom.indexer;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.ref.Reference;
|
||||
import java.lang.ref.SoftReference;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* A cache for checking whether a file exists. The cache shall be used for a limited amount of time, only (e.g. one
|
||||
* indexer task). It uses as much memory as it needs. To protect against OutOfMemory situations, a soft reference is
|
||||
* used.
|
||||
* @since 5.0
|
||||
*/
|
||||
public final class FileExistsCache {
|
||||
private static final String[] EMPTY_STRING_ARRAY= {};
|
||||
private static final boolean CASE_INSENSITIVE = new File("a").equals(new File("A")); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
private static boolean BYPASS_CACHE= Boolean.getBoolean("CDT_INDEXER_BYPASS_FILE_EXISTS_CACHE"); //$NON-NLS-1$
|
||||
|
||||
private Reference<Map<String,String[]>> fCache= null;
|
||||
|
||||
public FileExistsCache() {
|
||||
fCache= new SoftReference<Map<String,String[]>>(new HashMap<String, String[]>()); // before running out of memory the entire map will be thrown away.
|
||||
}
|
||||
|
||||
public boolean exists(String path) {
|
||||
File file= new File(path);
|
||||
if (BYPASS_CACHE) {
|
||||
return file.exists();
|
||||
}
|
||||
|
||||
String parent= file.getParent();
|
||||
String name= file.getName();
|
||||
if (CASE_INSENSITIVE)
|
||||
name= name.toUpperCase();
|
||||
|
||||
String[] avail= getExistsCache().get(parent);
|
||||
if (avail == null) {
|
||||
avail= new File(parent).list();
|
||||
if (avail == null || avail.length == 0) {
|
||||
avail= EMPTY_STRING_ARRAY;
|
||||
}
|
||||
else {
|
||||
if (CASE_INSENSITIVE) {
|
||||
for (int i = 0; i < avail.length; i++) {
|
||||
avail[i]= avail[i].toUpperCase();
|
||||
}
|
||||
}
|
||||
Arrays.sort(avail);
|
||||
}
|
||||
getExistsCache().put(parent, avail);
|
||||
}
|
||||
return Arrays.binarySearch(avail, name) >= 0;
|
||||
}
|
||||
|
||||
private Map<String, String[]> getExistsCache() {
|
||||
Map<String, String[]> cache= fCache.get();
|
||||
if (cache == null) {
|
||||
cache= new HashMap<String, String[]>();
|
||||
fCache= new SoftReference<Map<String, String[]>>(cache); // before running out of memory the entire map will be thrown away.
|
||||
}
|
||||
return cache;
|
||||
}
|
||||
}
|
||||
|
|
@ -42,7 +42,8 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
private final static boolean CASE_SENSITIVE_FILES= !new File("a").equals(new File("A")); //$NON-NLS-1$//$NON-NLS-2$
|
||||
|
||||
private final ICProject fCProject;
|
||||
private HashMap<String, IIndexFileLocation> fIflCache;
|
||||
private final HashMap<String, IIndexFileLocation> fIflCache;
|
||||
private final FileExistsCache fExistsCache;
|
||||
|
||||
public ProjectIndexerInputAdapter(ICProject cproject) {
|
||||
this(cproject, true);
|
||||
|
|
@ -50,9 +51,17 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
|
||||
public ProjectIndexerInputAdapter(ICProject cproject, boolean useCache) {
|
||||
fCProject= cproject;
|
||||
fIflCache= useCache ? new HashMap<String, IIndexFileLocation>() : null;
|
||||
if (useCache) {
|
||||
fIflCache= new HashMap<String, IIndexFileLocation>();
|
||||
fExistsCache= new FileExistsCache();
|
||||
}
|
||||
else {
|
||||
fIflCache= null;
|
||||
fExistsCache= null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveASTPath(String astPath) {
|
||||
if (fIflCache == null) {
|
||||
return doResolveASTPath(astPath);
|
||||
|
|
@ -69,19 +78,20 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return IndexLocationFactory.getIFLExpensive(fCProject, astPath);
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveIncludeFile(String includePath) {
|
||||
if (fIflCache == null) {
|
||||
return doResolveASTPath(includePath);
|
||||
}
|
||||
IIndexFileLocation result= fIflCache.get(includePath);
|
||||
if (result == null) {
|
||||
File location= new File(includePath);
|
||||
if (!location.exists()) {
|
||||
if (!fExistsCache.exists(includePath)) {
|
||||
return null;
|
||||
}
|
||||
IIndexFileLocation result= fIflCache.get(includePath);
|
||||
if (result == null) {
|
||||
result = doResolveASTPath(includePath);
|
||||
if (result.getFullPath() == null && !CASE_SENSITIVE_FILES) {
|
||||
try {
|
||||
File location= new File(includePath);
|
||||
String canonicalPath= location.getCanonicalPath();
|
||||
if (!includePath.equals(canonicalPath)) {
|
||||
result= IndexLocationFactory.getExternalIFL(canonicalPath);
|
||||
|
|
@ -97,6 +107,15 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean doesIncludeFileExist(String includePath) {
|
||||
if (fExistsCache != null) {
|
||||
return fExistsCache.exists(includePath);
|
||||
}
|
||||
return new File(includePath).exists();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getASTPath(IIndexFileLocation ifl) {
|
||||
IPath path= IndexLocationFactory.getAbsolutePath(ifl);
|
||||
if (path != null) {
|
||||
|
|
@ -105,6 +124,7 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return ifl.getURI().getPath();
|
||||
}
|
||||
|
||||
@Override
|
||||
public IScannerInfo getBuildConfiguration(int linkageID, Object tu) {
|
||||
IScannerInfo info= ((ITranslationUnit) tu).getScannerInfo(true);
|
||||
if (info == null) {
|
||||
|
|
@ -113,6 +133,7 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return info;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getLastModified(IIndexFileLocation ifl) {
|
||||
String fullPath= ifl.getFullPath();
|
||||
if (fullPath != null) {
|
||||
|
|
@ -130,6 +151,7 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
}
|
||||
|
||||
|
||||
@Override
|
||||
public AbstractLanguage[] getLanguages(Object tuo) {
|
||||
ITranslationUnit tu= (ITranslationUnit) tuo;
|
||||
try {
|
||||
|
|
@ -144,25 +166,30 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return new AbstractLanguage[0];
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isFileBuildConfigured(Object tuo) {
|
||||
ITranslationUnit tu= (ITranslationUnit) tuo;
|
||||
return !CoreModel.isScannerInformationEmpty(tu.getResource());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSourceUnit(Object tuo) {
|
||||
ITranslationUnit tu= (ITranslationUnit) tuo;
|
||||
return tu.isSourceUnit();
|
||||
}
|
||||
|
||||
@Override
|
||||
public IIndexFileLocation resolveFile(Object tuo) {
|
||||
ITranslationUnit tu= (ITranslationUnit) tuo;
|
||||
return IndexLocationFactory.getIFL(tu);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canBePartOfSDK(IIndexFileLocation ifl) {
|
||||
return ifl.getFullPath() == null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getInputFile(IIndexFileLocation location) {
|
||||
try {
|
||||
return CoreModelUtil.findTranslationUnitForLocation(location, fCProject);
|
||||
|
|
@ -172,6 +199,7 @@ public class ProjectIndexerInputAdapter extends IndexerInputAdapter {
|
|||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public CodeReader getCodeReader(Object tuo) {
|
||||
ITranslationUnit tu= (ITranslationUnit) tuo;
|
||||
return tu.getCodeReader();
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue