import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
/**
 * Returns a mapping of class files to the bytes that make up those class files.
 *
 * @param resources
 *            the classfiles
 * @param qualifiedNames
 *            the fully qualified type names corresponding to the classfiles.
 *            The typeNames correspond to the resources on a one-to-one basis.
 * @return a mapping of class files to bytes key: class file value: the bytes
 *         which make up that classfile
 */
private Map<ReferenceType, byte[]> getTypesToBytes(List<IResource> resources, List<String> qualifiedNames) {
    Map<ReferenceType, byte[]> typesToBytes = new HashMap<>(resources.size());
    Iterator<IResource> resourceIter = resources.iterator();
    Iterator<String> nameIter = qualifiedNames.iterator();
    IResource resource;
    String name;
    while (resourceIter.hasNext()) {
        resource = resourceIter.next();
        name = nameIter.next();
        List<ReferenceType> classes = getJdiClassesByName(name);
        byte[] bytes = null;
        try {
            bytes = Util.getResourceContentsAsByteArray((IFile) resource);
        } catch (CoreException e) {
            continue;
        }
        for (ReferenceType type : classes) {
            typesToBytes.put(type, bytes);
        }
    }
    return typesToBytes;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void deleteIndexFiles(SimpleSet pathsToKeep) {
  File[] indexesFiles = getSavedIndexesDirectory().listFiles();
  if (indexesFiles == null) return;

  for (int i = 0, l = indexesFiles.length; i < l; i++) {
    String fileName = indexesFiles[i].getAbsolutePath();
    if (pathsToKeep != null && pathsToKeep.includes(new FileIndexLocation(indexesFiles[i])))
      continue;
    String suffix = ".index"; // $NON-NLS-1$
    if (fileName.regionMatches(
        true, fileName.length() - suffix.length(), suffix, 0, suffix.length())) {
      if (JobManager.VERBOSE || DEBUG)
        Util.verbose("Deleting index file " + indexesFiles[i]); // $NON-NLS-1$
      indexesFiles[i].delete();
    }
  }
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private char[][] readJavaLikeNamesFile() {
  try {
    String pathName = getJavaPluginWorkingLocation().toOSString();
    File javaLikeNamesFile = new File(pathName, "javaLikeNames.txt"); // $NON-NLS-1$
    if (!javaLikeNamesFile.exists()) return null;
    char[] javaLikeNames =
        org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(javaLikeNamesFile, null);
    if (javaLikeNames.length > 0) {
      char[][] names = CharOperation.splitOn('\n', javaLikeNames);
      return names;
    }
  } catch (IOException ignored) {
    if (JobManager.VERBOSE) Util.verbose("Failed to read javaLikeNames file"); // $NON-NLS-1$
  }
  return null;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void rebuildIndex(IndexLocation indexLocation, IPath containerPath) {
  Object target = JavaModelManager.getTarget(containerPath, true);
  if (target == null) return;

  if (JobManager.VERBOSE)
    Util.verbose(
        "-> request to rebuild index: "
            + indexLocation
            + " path: "
            + containerPath); // $NON-NLS-1$ //$NON-NLS-2$

  updateIndexState(indexLocation, REBUILDING_STATE);
  IndexRequest request = null;
  if (target instanceof IProject) {
    IProject p = (IProject) target;
    if (JavaProject.hasJavaNature(p)) request = new IndexAllProject(p, this);
  } else if (target instanceof IFolder) {
    request = new IndexBinaryFolder((IFolder) target, this);
  } else if (target instanceof IFile) {
    request = new AddJarFileToIndex((IFile) target, null, this);
  } else if (target instanceof File) {
    request = new AddJarFileToIndex(containerPath, null, this);
  }
  if (request != null) request(request);
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
public void saveIndex(Index index) throws IOException {
  // must have permission to write from the write monitor
  if (index.hasChanged()) {
    if (JobManager.VERBOSE)
      Util.verbose("-> saving index " + index.getIndexLocation()); // $NON-NLS-1$
    index.save();
  }
  synchronized (this) {
    IPath containerPath = new Path(index.containerPath);
    if (this.jobEnd > this.jobStart) {
      for (int i = this.jobEnd; i > this.jobStart; i--) { // skip the current job
        IJob job = this.awaitingJobs[i];
        if (job instanceof IndexRequest)
          if (((IndexRequest) job).containerPath.equals(containerPath)) return;
      }
    }
    IndexLocation indexLocation = computeIndexLocation(containerPath);
    updateIndexState(indexLocation, SAVED_STATE);
  }
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void readIndexMap() {
  try {
    char[] indexMaps =
        org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(
            this.indexNamesMapFile, null);
    char[][] names = CharOperation.splitOn('\n', indexMaps);
    if (names.length >= 3) {
      // First line is DiskIndex signature (see writeIndexMapFile())
      String savedSignature = DiskIndex.SIGNATURE;
      if (savedSignature.equals(new String(names[0]))) {
        for (int i = 1, l = names.length - 1; i < l; i += 2) {
          IndexLocation indexPath =
              IndexLocation.createIndexLocation(new URL(new String(names[i])));
          if (indexPath == null) continue;
          this.indexLocations.put(new Path(new String(names[i + 1])), indexPath);
          this.indexStates.put(indexPath, REUSE_STATE);
        }
      }
    }
  } catch (IOException ignored) {
    if (JobManager.VERBOSE) Util.verbose("Failed to read saved index file names"); // $NON-NLS-1$
  }
  return;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private char[][] readIndexState(String dirOSString) {
  try {
    char[] savedIndexNames =
        org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(
            this.savedIndexNamesFile, null);
    if (savedIndexNames.length > 0) {
      char[][] names = CharOperation.splitOn('\n', savedIndexNames);
      if (names.length > 1) {
        // First line is DiskIndex signature + saved plugin working location (see
        // writeSavedIndexNamesFile())
        String savedSignature = DiskIndex.SIGNATURE + "+" + dirOSString; // $NON-NLS-1$
        if (savedSignature.equals(new String(names[0]))) return names;
      }
    }
  } catch (IOException ignored) {
    if (JobManager.VERBOSE) Util.verbose("Failed to read saved index file names"); // $NON-NLS-1$
  }
  return null;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void readParticipantsIndexNamesFile() {
  SimpleLookupTable containers = new SimpleLookupTable(3);
  try {
    char[] participantIndexNames =
        org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(
            this.participantIndexNamesFile, null);
    if (participantIndexNames.length > 0) {
      char[][] names = CharOperation.splitOn('\n', participantIndexNames);
      if (names.length >= 3) {
        // First line is DiskIndex signature  (see writeParticipantsIndexNamesFile())
        if (DiskIndex.SIGNATURE.equals(new String(names[0]))) {
          for (int i = 1, l = names.length - 1; i < l; i += 2) {
            IndexLocation indexLocation =
                new FileIndexLocation(new File(new String(names[i])), true);
            containers.put(indexLocation, new Path(new String(names[i + 1])));
          }
        }
      }
    }
  } catch (IOException ignored) {
    if (JobManager.VERBOSE)
      Util.verbose("Failed to read participant index file names"); // $NON-NLS-1$
  }
  this.participantsContainers = containers;
  return;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private synchronized void removeIndexesState(IndexLocation[] locations) {
  getIndexStates(); // ensure the states are initialized
  int length = locations.length;
  boolean changed = false;
  for (int i = 0; i < length; i++) {
    if (locations[i] == null) continue;
    if ((this.indexStates.removeKey(locations[i]) != null)) {
      changed = true;
      if (JobManager.VERBOSE) {
        Util.verbose("-> index state updated to: ? for: " + locations[i]); // $NON-NLS-1$
      }
    }
  }
  if (!changed) return;

  writeSavedIndexNamesFile();
  writeIndexMapFile();
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private IPath getPath(IJavaElement element, boolean relativeToRoot) {
  switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
      return Path.EMPTY;
    case IJavaElement.JAVA_PROJECT:
      return element.getPath();
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
      if (relativeToRoot) return Path.EMPTY;
      return element.getPath();
    case IJavaElement.PACKAGE_FRAGMENT:
      String relativePath = Util.concatWith(((PackageFragment) element).names, '/');
      return getPath(element.getParent(), relativeToRoot).append(new Path(relativePath));
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
      return getPath(element.getParent(), relativeToRoot)
          .append(new Path(element.getElementName()));
    default:
      return getPath(element.getParent(), relativeToRoot);
  }
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private char[] readSource(ZipEntry entry, ZipFile zip, String charSet) {
  try {
    byte[] bytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(entry, zip);
    if (bytes != null) {
      // Order of preference: charSet supplied, this.encoding or this.defaultEncoding in that
      // order
      return org.eclipse.jdt.internal.compiler.util.Util.bytesToChar(
          bytes,
          charSet == null
              ? (this.encoding == null ? this.defaultEncoding : this.encoding)
              : charSet);
    }
  } catch (IOException e) {
    // ignore
  }
  return null;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void notifyTypeHierarchies(IElementChangedListener[] listeners, int listenerCount) {
  for (int i = 0; i < listenerCount; i++) {
    final IElementChangedListener listener = listeners[i];
    if (!(listener instanceof TypeHierarchy)) continue;

    // wrap callbacks with Safe runnable for subsequent listeners to be called when some are
    // causing grief
    SafeRunner.run(
        new ISafeRunnable() {
          public void handleException(Throwable exception) {
            Util.log(
                exception,
                "Exception occurred in listener of Java element change notification"); // $NON-NLS-1$
          }

          public void run() throws Exception {
            TypeHierarchy typeHierarchy = (TypeHierarchy) listener;
            if (typeHierarchy.hasFineGrainChanges()) {
              // case of changes in primary working copies
              typeHierarchy.needsRefresh = true;
              typeHierarchy.fireChange();
            }
          }
        });
  }
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
ClasspathJar(IFile resource, AccessRuleSet accessRuleSet) {
  this.resource = resource;
  try {
    java.net.URI location = resource.getLocationURI();
    if (location == null) {
      this.zipFilename = ""; // $NON-NLS-1$
    } else {
      File localFile = Util.toLocalFile(location, null);
      this.zipFilename = localFile.getPath();
    }
  } catch (CoreException e) {
    // ignore
  }
  this.zipFile = null;
  this.knownPackageNames = null;
  packageNames = null;
  this.accessRuleSet = accessRuleSet;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
public void contentTypeChanged(ContentTypeChangeEvent event) {
	Util.resetJavaLikeExtensions();

	// Walk through projects to reset their secondary types cache
	IJavaProject[] projects;
	try {
		projects = JavaModelManager.getJavaModelManager().getJavaModel().getJavaProjects();
	} catch (JavaModelException e) {
		return;
	}
	for (int i = 0, length = projects.length; i < length; i++) {
		IJavaProject project = projects[i];
		final PerProjectInfo projectInfo = getPerProjectInfo(project.getProject(), false /* don't create info */);
		if (projectInfo != null) {
			projectInfo.secondaryTypes = null;
		}
	}
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void verbose_reentering_project_container_access(	IPath containerPath, IJavaProject project, IClasspathContainer previousContainer) {
	StringBuffer buffer = new StringBuffer();
	buffer.append("CPContainer INIT - reentering access to project container during its initialization, will see previous value\n"); //$NON-NLS-1$
	buffer.append("	project: " + project.getElementName() + '\n'); //$NON-NLS-1$
	buffer.append("	container path: " + containerPath + '\n'); //$NON-NLS-1$
	buffer.append("	previous value: "); //$NON-NLS-1$
	buffer.append(previousContainer.getDescription());
	buffer.append(" {\n"); //$NON-NLS-1$
	IClasspathEntry[] entries = previousContainer.getClasspathEntries();
	if (entries != null){
		for (int j = 0; j < entries.length; j++){
			buffer.append(" 		"); //$NON-NLS-1$
			buffer.append(entries[j]);
			buffer.append('\n');
		}
	}
	buffer.append(" 	}"); //$NON-NLS-1$
	Util.verbose(buffer.toString());
	new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void notifyParticipants(final CompilationUnit workingCopy) {
	IJavaProject javaProject = getWorkingCopy().getJavaProject();
	CompilationParticipant[] participants = JavaModelManager.getJavaModelManager().compilationParticipants.getCompilationParticipants(javaProject);
	if (participants == null) return;

	final ReconcileContext context = new ReconcileContext(this, workingCopy);
	for (int i = 0, length = participants.length; i < length; i++) {
		final CompilationParticipant participant = participants[i];
		SafeRunner.run(new ISafeRunnable() {
			public void handleException(Throwable exception) {
				if (exception instanceof Error) {
					throw (Error) exception; // errors are not supposed to be caught
				} else if (exception instanceof OperationCanceledException)
					throw (OperationCanceledException) exception;
				else if (exception instanceof UnsupportedOperationException) {
					// might want to disable participant as it tried to modify the buffer of the working copy being reconciled
					Util.log(exception, "Reconcile participant attempted to modify the buffer of the working copy being reconciled"); //$NON-NLS-1$
				} else
					Util.log(exception, "Exception occurred in reconcile participant"); //$NON-NLS-1$
			}
			public void run() throws Exception {
				participant.reconcile(context);
			}
		});
	}
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
/**
 * Updates the content of <code>cu</code>, modifying the type name and/or package
 * declaration as necessary.
 *
 * @return an AST rewrite or null if no rewrite needed
 */
private TextEdit updateContent(ICompilationUnit cu, PackageFragment dest, String newName) throws JavaModelException {
	String[] currPackageName = ((PackageFragment) cu.getParent()).names;
	String[] destPackageName = dest.names;
	if (Util.equalArraysOrNull(currPackageName, destPackageName) && newName == null) {
		return null; //nothing to change
	} else {
		// ensure cu is consistent (noop if already consistent)
		cu.makeConsistent(this.progressMonitor);
		this.parser.setSource(cu);
		CompilationUnit astCU = (CompilationUnit) this.parser.createAST(this.progressMonitor);
		AST ast = astCU.getAST();
		ASTRewrite rewrite = ASTRewrite.create(ast);
		updateTypeName(cu, astCU, cu.getElementName(), newName, rewrite);
		updatePackageStatement(astCU, destPackageName, rewrite, cu);
		return rewrite.rewriteAST();
	}
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
/**
 * Searches for all declarations of the types referenced in the given element.
 * The element can be a compilation unit or a source type/method/field.
 * Reports the type declarations using the given requestor.
 *
 * @see SearchEngine#searchDeclarationsOfReferencedTypes(IJavaElement, SearchRequestor, IProgressMonitor)
 * 	for detailed comment
 */
public void searchDeclarationsOfReferencedTypes(IJavaElement enclosingElement, SearchRequestor requestor, IProgressMonitor monitor) throws JavaModelException {
	if (VERBOSE) {
		Util.verbose("BasicSearchEngine.searchDeclarationsOfReferencedTypes(IJavaElement, SearchRequestor, SearchPattern, IProgressMonitor)"); //$NON-NLS-1$
	}
	// Do not accept other kind of element type than those specified in the spec
	switch (enclosingElement.getElementType()) {
		case IJavaElement.FIELD:
		case IJavaElement.METHOD:
		case IJavaElement.TYPE:
		case IJavaElement.COMPILATION_UNIT:
			// valid element type
			break;
		default:
			throw new IllegalArgumentException();
	}
	SearchPattern pattern = new DeclarationOfReferencedTypesPattern(enclosingElement);
	searchDeclarations(enclosingElement, requestor, pattern, monitor);
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private char[][] readJavaLikeNamesFile() {
	try {
		String pathName = getJavaPluginWorkingLocation().toOSString();	
		File javaLikeNamesFile = new File(pathName, "javaLikeNames.txt"); //$NON-NLS-1$
		if (!javaLikeNamesFile.exists())
			return null;
		char[] javaLikeNames = org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(javaLikeNamesFile, null);
		if (javaLikeNames.length > 0) {
			char[][] names = CharOperation.splitOn('\n', javaLikeNames);
			return names;
		}
	} catch (IOException ignored) {
		if (VERBOSE)
			Util.verbose("Failed to read javaLikeNames file"); //$NON-NLS-1$
	}
	return null;
}
 

import org.eclipse.jdt.internal.core.util.Util; //导入依赖的package包/类
private void rebuildIndex(IndexLocation indexLocation, IPath containerPath, final boolean updateIndex) {
	Object target = JavaModel.getTarget(containerPath, true);
	if (target == null) return;

	if (VERBOSE)
		Util.verbose("-> request to rebuild index: "+indexLocation+" path: "+containerPath); //$NON-NLS-1$ //$NON-NLS-2$

	updateIndexState(indexLocation, REBUILDING_STATE);
	IndexRequest request = null;
	if (target instanceof IProject) {
		IProject p = (IProject) target;
		if (JavaProject.hasJavaNature(p))
			request = new IndexAllProject(p, this);
	} else if (target instanceof IFolder) {
		request = new IndexBinaryFolder((IFolder) target, this);
	} else if (target instanceof IFile) {
		request = new AddJarFileToIndex((IFile) target, null, this, updateIndex);
	} else if (target instanceof File) {
		request = new AddJarFileToIndex(containerPath, null, this, updateIndex);
	}
	if (request != null)
		request(request);
}