private void parseVersionInContext(
      int linkageID,
      LinkageTask map,
      IIndexFileLocation ifl,
      final FileVersionTask versionTask,
      Object tu,
      LinkedHashSet<IIndexFile> safeGuard,
      IProgressMonitor monitor)
      throws CoreException, InterruptedException {
    final IIndexFragmentFile headerFile = versionTask.fIndexFile;

    final int safeguardSize = safeGuard.size();
    while (true) {
      // Look for a context and parse the file.
      IIndexFragmentFile ctxFile = findContextFile(linkageID, map, versionTask, safeGuard, monitor);
      if (ctxFile == null || ctxFile == headerFile) return;

      Object contextTu = fResolver.getInputFile(ctxFile.getLocation());
      if (contextTu == null) return;

      final IScannerInfo scannerInfo = getScannerInfo(linkageID, contextTu);
      final AbstractLanguage language = getLanguage(contextTu, linkageID);
      final FileContext ctx = new FileContext(ctxFile, headerFile);
      Set<IIndexFile> dependencies = null;
      boolean done = false;
      while (!done) {
        done = true;
        DependsOnOutdatedFileException d = parseFile(tu, language, ifl, scannerInfo, ctx, monitor);
        if (d != null) {
          // File was not parsed, because there is a dependency that needs to be
          // handled before.
          if (dependencies == null) dependencies = new HashSet<IIndexFile>();
          if (dependencies.add(d.fIndexFile)) {
            if (parseFile(
                    d.fTu,
                    language,
                    d.fIndexFile.getLocation(),
                    scannerInfo,
                    new FileContext(ctxFile, d.fIndexFile),
                    monitor)
                == null) done = false;
          }
        }
      }
      if (!ctx.fLostPragmaOnceSemantics) return;

      // Try the next context
      restoreSet(safeGuard, safeguardSize);
    }
  }
Пример #2
0
  @Override
  public void clearFile(IIndexFragmentFile file) throws CoreException {
    assert file.getIndexFragment() == this;
    IIndexFileLocation location = file.getLocation();
    PDOMFile pdomFile = (PDOMFile) file;
    pdomFile.clear();
    IIndexInclude include = pdomFile.getParsedInContext();
    if (include != null) {
      PDOMFile includedBy = (PDOMFile) include.getIncludedBy();
      if (includedBy.getTimestamp() > 0)
        getIndexOfFilesWithUnresolvedIncludes().insert(includedBy.getRecord());
    }

    fEvent.fClearedFiles.add(location);
  }
Пример #3
0
  @Override
  public void addFileContent(
      IIndexFragmentFile sourceFile,
      IncludeInformation[] includes,
      IASTPreprocessorStatement[] macros,
      IASTName[][] names,
      ASTFilePathResolver pathResolver,
      YieldableIndexLock lock)
      throws CoreException, InterruptedException {
    assert sourceFile.getIndexFragment() == this;

    PDOMFile pdomFile = (PDOMFile) sourceFile;
    pdomFile.addMacros(macros);
    final ASTFilePathResolver origResolver = fPathResolver;
    fPathResolver = pathResolver;
    try {
      pdomFile.addNames(names, lock);
    } finally {
      fPathResolver = origResolver;
    }
    // Includes expose the temporary file in the index, we must not yield the lock beyond this
    // point.
    pdomFile.addIncludesTo(includes);

    final IIndexFileLocation location = pdomFile.getLocation();
    if (location != null) {
      fEvent.fClearedFiles.remove(location);
      fEvent.fFilesWritten.add(location);
    }
  }
 private boolean isModified(
     boolean checkTimestamps,
     boolean checkFileContentsHash,
     IIndexFileLocation ifl,
     Object tu,
     IIndexFragmentFile file)
     throws CoreException {
   if (checkTimestamps) {
     if (fResolver.getLastModified(ifl) != file.getTimestamp()
         || computeFileSizeAndEncodingHashcode(ifl) != file.getSizeAndEncodingHashcode()) {
       if (checkFileContentsHash && computeFileContentsHash(tu) == file.getContentsHash()) {
         return false;
       }
       return true;
     }
   }
   return false;
 }
  IIndexFragmentFile selectIndexFile(
      int linkageID, IIndexFileLocation ifl, ISignificantMacros sigMacros) throws CoreException {
    LinkageTask map = findRequestMap(linkageID);
    if (map != null) {
      LocationTask locTask = map.find(ifl);
      if (locTask != null) {
        FileVersionTask task = locTask.findVersion(sigMacros);
        if (task != null) {
          return task.fOutdated ? null : task.fIndexFile;
        }
      }
    }

    IIndexFragmentFile[] files = getAvailableIndexFiles(linkageID, ifl);
    for (IIndexFragmentFile file : files) {
      if (sigMacros.equals(file.getSignificantMacros())) return file;
    }
    return null;
  }
  private IIndexFragmentFile findContextFile(
      int linkageID,
      LinkageTask map,
      final FileVersionTask versionTask,
      LinkedHashSet<IIndexFile> safeGuard,
      IProgressMonitor monitor)
      throws CoreException, InterruptedException {
    IIndexFragmentFile ctxFile = versionTask.fIndexFile;
    while (true) {
      IIndexInclude ctxInclude = ctxFile.getParsedInContext();
      if (ctxInclude == null) return ctxFile;

      IIndexFragmentFile nextCtx = (IIndexFragmentFile) ctxInclude.getIncludedBy();
      if (nextCtx == null) return nextCtx;

      // Found a recursion.
      if (!safeGuard.add(nextCtx)) return null;

      final IIndexFileLocation ctxIfl = nextCtx.getLocation();
      LocationTask ctxTask = map.find(ctxIfl);
      if (ctxTask != null) {
        FileVersionTask ctxVersionTask = ctxTask.findVersion(nextCtx);
        if (ctxVersionTask != null && ctxVersionTask.fOutdated) {
          // Handle the context first.
          parseVersionInContext(
              linkageID, map, ctxIfl, ctxVersionTask, ctxTask.fTu, safeGuard, monitor);
          if (ctxVersionTask.fOutdated // This is unexpected.
              || !versionTask.fOutdated) // Our file was parsed.
          return null;

          // The file is no longer a context, look for a different one.
          nextCtx = ctxFile;
        }
      }
      ctxFile = nextCtx;
    }
  }
  private void extractFiles(
      HashMap<Integer, List<IIndexFileLocation>> files,
      List<IIndexFragmentFile> iFilesToRemove,
      IProgressMonitor monitor)
      throws CoreException {
    final boolean forceAll = (fUpdateFlags & IIndexManager.UPDATE_ALL) != 0;
    final boolean checkTimestamps = (fUpdateFlags & IIndexManager.UPDATE_CHECK_TIMESTAMPS) != 0;
    final boolean checkFileContentsHash =
        (fUpdateFlags & IIndexManager.UPDATE_CHECK_CONTENTS_HASH) != 0;
    final boolean forceUnresolvedIncludes =
        (fUpdateFlags & IIndexManager.UPDATE_UNRESOLVED_INCLUDES) != 0;
    final boolean both = fIndexHeadersWithoutContext == UnusedHeaderStrategy.useBoth;
    int count = 0;
    int forceFirst = fForceNumberFiles;
    BitSet linkages = new BitSet();
    for (final Object tu : fFilesToUpdate) {
      if (monitor.isCanceled()) return;

      final boolean force = forceAll || --forceFirst >= 0;
      final IIndexFileLocation ifl = fResolver.resolveFile(tu);
      if (ifl == null) continue;

      final IIndexFragmentFile[] indexFiles = fIndex.getWritableFiles(ifl);
      final boolean isSourceUnit = fResolver.isSourceUnit(tu);
      linkages.clear();
      final boolean regularContent = isRequiredInIndex(tu, ifl, isSourceUnit);
      final boolean indexedUnconditionally = fResolver.isIndexedUnconditionally(ifl);
      if (regularContent || indexedUnconditionally) {
        // Headers or sources required with a specific linkage
        final UpdateKind updateKind =
            isSourceUnit
                ? UpdateKind.REQUIRED_SOURCE
                : regularContent && both
                    ? UpdateKind.REQUIRED_HEADER
                    : UpdateKind.ONE_LINKAGE_HEADER;
        if (regularContent || indexFiles.length == 0) {
          AbstractLanguage[] langs = fResolver.getLanguages(tu, fIndexHeadersWithoutContext);
          for (AbstractLanguage lang : langs) {
            int linkageID = lang.getLinkageID();
            boolean foundInLinkage = false;
            for (int i = 0; i < indexFiles.length; i++) {
              IIndexFragmentFile ifile = indexFiles[i];
              if (ifile != null && ifile.getLinkageID() == linkageID && ifile.hasContent()) {
                foundInLinkage = true;
                indexFiles[i] = null; // Take the file.
                boolean update =
                    force
                        || (forceUnresolvedIncludes && ifile.hasUnresolvedInclude())
                        || isModified(checkTimestamps, checkFileContentsHash, ifl, tu, ifile);
                if (update && requestUpdate(linkageID, ifl, ifile, tu, updateKind)) {
                  count++;
                  linkages.set(linkageID);
                }
              }
            }
            if (!foundInLinkage && requestUpdate(linkageID, ifl, null, tu, updateKind)) {
              linkages.set(linkageID);
              count++;
            }
          }
        }
      }

      // Handle other files present in index.
      for (IIndexFragmentFile ifile : indexFiles) {
        if (ifile != null) {
          IIndexInclude ctx = ifile.getParsedInContext();
          if (ctx == null && !indexedUnconditionally && ifile.hasContent()) {
            iFilesToRemove.add(ifile);
            count++;
          } else {
            boolean update =
                force
                    || (forceUnresolvedIncludes && ifile.hasUnresolvedInclude())
                    || isModified(checkTimestamps, checkFileContentsHash, ifl, tu, ifile);
            final int linkageID = ifile.getLinkageID();
            if (update && requestUpdate(linkageID, ifl, ifile, tu, UpdateKind.OTHER_HEADER)) {
              count++;
              linkages.set(linkageID);
            }
          }
        }
      }
      for (int lid = linkages.nextSetBit(0); lid >= 0; lid = linkages.nextSetBit(lid + 1)) {
        addPerLinkage(lid, ifl, files);
      }
    }
    synchronized (this) {
      incrementRequestedFilesCount(count - fFilesToUpdate.length);
      fFilesToUpdate = null;
    }
  }