Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2013 IBM Corporation 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: IBM Corporation - initial API and implementation /
 
 package org.eclipse.jdt.internal.core.builder;
 
 import  org.eclipse.core.runtime.*;
 import  org.eclipse.core.resources.*;
 
 
 import java.io.*;
 import java.util.*;

The abstract superclass of Java builders. Provides the building and compilation mechanism in common with the batch and incremental builders.
 
 public abstract class AbstractImageBuilder implements ICompilerRequestorICompilationUnitLocator {
 
 protected JavaBuilder javaBuilder;
 protected State newState;
 
 // local copies
 protected BuildNotifier notifier;
 
 protected Compiler compiler;
 protected WorkQueue workQueue;
 protected boolean compiledAllAtOnce;
 
 private boolean inCompiler;
 
 protected boolean keepStoringProblemMarkers;
 protected SimpleSet filesWithAnnotations = null;
 
 //2000 is best compromise between space used and speed
 public static int MAX_AT_ONCE = Integer.getInteger(., 2000).intValue();
 public final static String[] JAVA_PROBLEM_MARKER_ATTRIBUTE_NAMES = {
 	IMarker.MESSAGE,
 	IMarker.SEVERITY,
 	IMarker.CHAR_START,
 	IMarker.CHAR_END,
 	IMarker.LINE_NUMBER,
 };
 public final static String[] JAVA_TASK_MARKER_ATTRIBUTE_NAMES = {
 	IMarker.MESSAGE,
 	IMarker.PRIORITY,
 	IMarker.CHAR_START,
 	IMarker.CHAR_END,
 	IMarker.LINE_NUMBER,
 	IMarker.USER_EDITABLE,
 	IMarker.SOURCE_ID,
 };
 public final static Integer S_ERROR = new Integer(IMarker.SEVERITY_ERROR);
 public final static Integer S_WARNING = new Integer(IMarker.SEVERITY_WARNING);
 public final static Integer P_HIGH = new Integer(IMarker.PRIORITY_HIGH);
 public final static Integer P_NORMAL = new Integer(IMarker.PRIORITY_NORMAL);
 public final static Integer P_LOW = new Integer(IMarker.PRIORITY_LOW);
 
 protected AbstractImageBuilder(JavaBuilder javaBuilderboolean buildStartingState newState) {
 	// local copies
 	this. = javaBuilder;
 	this. = javaBuilder.nameEnvironment;
 	this. = javaBuilder.notifier;
 	this. = true// may get disabled when missing classfiles are encountered
 
 	if (buildStarting) {
 		this. = newState == null ? new State(javaBuilder) : newState;
 		this. = newCompiler();
 		this. = new WorkQueue();
		this. = new ArrayList(3);
		if (this.. != null) {
			for (int i = 0, l = this...lengthi < li++) {
					// initialize this set so the builder knows to gather CUs that define Annotation types
					// each Annotation processor participant is then asked to process these files AFTER
					// the compile loop. The normal dependency loop will then recompile all affected types
					break;
				}
			}
		}
	}
public void acceptResult(CompilationResult result) {
	// In Batch mode, we write out the class files, hold onto the dependency info
	// & additional types and report problems.
	// In Incremental mode, when writing out a class file we need to compare it
	// against the previous file, remembering if structural changes occured.
	// Before reporting the new problems, we need to update the problem count &
	// remove the old problems. Plus delete additional class files that no longer exist.
	SourceFile compilationUnit = (SourceFileresult.getCompilationUnit(); // go directly back to the sourceFile
	if (!this..isCompiled(compilationUnit)) {
		this..finished(compilationUnit);
		try {
			updateProblemsFor(compilationUnitresult); // record compilation problems before potentially adding duplicate errors
			updateTasksFor(compilationUnitresult); // record tasks
catch (CoreException e) {
		}
		if (result.hasInconsistentToplevelHierarchies)
			// ensure that this file is always retrieved from source for the rest of the build
			if (!this..contains(compilationUnit))
				this..add(compilationUnit);
		IType mainType = null;
		String mainTypeName = null;
		String typeLocator = compilationUnit.typeLocator();
		ClassFile[] classFiles = result.getClassFiles();
		int length = classFiles.length;
		ArrayList duplicateTypeNames = null;
		ArrayList definedTypeNames = new ArrayList(length);
		for (int i = 0; i < lengthi++) {
			ClassFile classFile = classFiles[i];
			char[][] compoundName = classFile.getCompoundName();
			char[] typeName = compoundName[compoundName.length - 1];
			boolean isNestedType = classFile.isNestedType;
			// Look for a possible collision, if one exists, report an error but do not write the class file
			if (isNestedType) {
				String qualifiedTypeName = new String(classFile.outerMostEnclosingClassFile().fileName());
				if (this..isDuplicateLocator(qualifiedTypeNametypeLocator))
					continue;
else {
				String qualifiedTypeName = new String(classFile.fileName()); // the qualified type name "p1/p2/A"
				if (this..isDuplicateLocator(qualifiedTypeNametypeLocator)) {
					if (duplicateTypeNames == null)
						duplicateTypeNames = new ArrayList();
					duplicateTypeNames.add(compoundName);
					if (mainType == null) {
						try {
							mainTypeName = compilationUnit.initialTypeName// slash separated qualified name "p1/p1/A"
							mainType = this...findType(mainTypeName.replace('/''.'));
catch (JavaModelException e) {
							// ignore
						}
					}
					IType type;
					if (qualifiedTypeName.equals(mainTypeName)) {
						type = mainType;
else {
						String simpleName = qualifiedTypeName.substring(qualifiedTypeName.lastIndexOf('/')+1);
						type = mainType == null ? null : mainType.getCompilationUnit().getType(simpleName);
					}
					createProblemFor(compilationUnit.resourcetype, Messages.bind(.new String(typeName)), .);
					continue;
				}
				this..recordLocatorForType(qualifiedTypeNametypeLocator);
				if (result.checkSecondaryTypes && !qualifiedTypeName.equals(compilationUnit.initialTypeName))
			}
			try {
				definedTypeNames.add(writeClassFile(classFilecompilationUnit, !isNestedType));
catch (CoreException e) {
				Util.log(e"JavaBuilder handling CoreException"); //$NON-NLS-1$
				if (e.getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS)
					createProblemFor(compilationUnit.resourcenull, Messages.bind(.e.getMessage()), .);
				else
			}
		}
		if (result.hasAnnotations && this. != null// only initialized if an annotation processor is attached
			this..add(compilationUnit);
		finishedWith(typeLocatorresultcompilationUnit.getMainTypeName(), definedTypeNamesduplicateTypeNames);
		this..compiled(compilationUnit);
	}
protected void acceptSecondaryType(ClassFile classFile) {
	// noop
protected void addAllSourceFiles(final ArrayList sourceFilesthrows CoreException {
	for (int i = 0, l = this..lengthi < li++) {
		final ClasspathMultiDirectory sourceLocation = this.[i];
		final char[][] exclusionPatterns = sourceLocation.exclusionPatterns;
		final char[][] inclusionPatterns = sourceLocation.inclusionPatterns;
		final boolean isAlsoProject = sourceLocation.sourceFolder.equals(this..);
		final int segmentCount = sourceLocation.sourceFolder.getFullPath().segmentCount();
		final IContainer outputFolder = sourceLocation.binaryFolder;
		final boolean isOutputFolder = sourceLocation.sourceFolder.equals(outputFolder);
		sourceLocation.sourceFolder.accept(
			new IResourceProxyVisitor() {
				public boolean visit(IResourceProxy proxythrows CoreException {
					switch(proxy.getType()) {
						case IResource.FILE :
							if (org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(proxy.getName())) {
								IResource resource = proxy.requestResource();
								if (exclusionPatterns != null || inclusionPatterns != null)
									if (Util.isExcluded(resource.getFullPath(), inclusionPatternsexclusionPatternsfalse))
										return false;
								sourceFiles.add(new SourceFile((IFile) resourcesourceLocation));
							}
							return false;
						case IResource.FOLDER :
							IPath folderPath = null;
							if (isAlsoProject)
								if (isExcludedFromProject(folderPath = proxy.requestFullPath()))
									return false;
							if (exclusionPatterns != null) {
								if (folderPath == null)
									folderPath = proxy.requestFullPath();
								if (Util.isExcluded(folderPathinclusionPatternsexclusionPatternstrue)) {
									// must walk children if inclusionPatterns != null, can skip them if == null
									// but folder is excluded so do not create it in the output folder
									return inclusionPatterns != null;
								}
							}
							if (!isOutputFolder) {
								if (folderPath == null)
									folderPath = proxy.requestFullPath();
								String packageName = folderPath.lastSegment();
								if (packageName.length() > 0) {
									if (JavaConventions.validatePackageName(packageNamesourceLevelcomplianceLevel).getSeverity() != IStatus.ERROR)
										createFolder(folderPath.removeFirstSegments(segmentCount), outputFolder);
								}
							}
					}
					return true;
				}
			},
			IResource.NONE
		);
	}
protected void cleanUp() {
	this. = null;
	this. = null;
	this. = null;
	this. = null;
	this. = null;
	this. = null;
	this. = null;
/* Compile the given elements, adding more elements to the work queue
* if they are affected by the changes.
*/
protected void compile(SourceFile[] units) {
	if (this. != null && this.. > 0)
		// will add files that have annotations in acceptResult() & then processAnnotations() before exitting this method
	// notify CompilationParticipants which source files are about to be compiled
	CompilationParticipantResult[] participantResults = this.. == null ? null : notifyParticipants(units);
	if (participantResults != null && participantResults.length > units.length) {
		units = new SourceFile[participantResults.length];
		for (int i = participantResults.length; --i >= 0;)
			units[i] = participantResults[i].;
	}
	int unitsLength = units.length;
	this. =  == 0 || unitsLength <= ;
	if (this.) {
		// do them all now
			for (int i = 0; i < unitsLengthi++)
				..println("About to compile " + units[i].typeLocator()); //$NON-NLS-1$
		compile(unitsnulltrue);
else {
		SourceFile[] remainingUnits = new SourceFile[unitsLength]; // copy of units, removing units when about to compile
		System.arraycopy(units, 0, remainingUnits, 0, unitsLength);
		int doNow = unitsLength <  ? unitsLength : ;
		SourceFile[] toCompile = new SourceFile[doNow];
		int remainingIndex = 0;
		boolean compilingFirstGroup = true;
		while (remainingIndex < unitsLength) {
			int count = 0;
			while (remainingIndex < unitsLength && count < doNow) {
				// Although it needed compiling when this method was called, it may have
				// already been compiled when it was referenced by another unit.
				SourceFile unit = remainingUnits[remainingIndex];
				if (unit != null && (compilingFirstGroup || this..isWaiting(unit))) {
						..println("About to compile #" + remainingIndex + " : "unit.typeLocator()); //$NON-NLS-1$ //$NON-NLS-2$
					toCompile[count++] = unit;
				}
				remainingUnits[remainingIndex++] = null;
			}
			if (count < doNow)
				System.arraycopy(toCompile, 0, toCompile = new SourceFile[count], 0, count);
			if (!compilingFirstGroup)
				for (int a = remainingIndexa < unitsLengtha++)
					if (remainingUnits[a] != null && this..isCompiled(remainingUnits[a]))
						remainingUnits[a] = null// use the class file for this source file since its been compiled
			compile(toCompileremainingUnitscompilingFirstGroup);
			compilingFirstGroup = false;
		}
	}
	if (participantResults != null) {
		for (int i = participantResults.length; --i >= 0;)
			if (participantResults[i] != null)
				recordParticipantResult(participantResults[i]);
		processAnnotations(participantResults);
	}
protected void compile(SourceFile[] unitsSourceFile[] additionalUnitsboolean compilingFirstGroup) {
	if (units.length == 0) return;
	this..aboutToCompile(units[0]); // just to change the message
	// extend additionalFilenames with all hierarchical problem types found during this entire build
	if (!this..isEmpty()) {
		int toAdd = this..size();
		int length = additionalUnits == null ? 0 : additionalUnits.length;
		if (length == 0)
			additionalUnits = new SourceFile[toAdd];
		else
			System.arraycopy(additionalUnits, 0, additionalUnits = new SourceFile[length + toAdd], 0, length);
		for (int i = 0; i < toAddi++)
			additionalUnits[length + i] = (SourceFilethis..get(i);
	}
	String[] initialTypeNames = new String[units.length];
	for (int i = 0, l = units.lengthi < li++)
		initialTypeNames[i] = units[i].;
	this..setNames(initialTypeNamesadditionalUnits);
	try {
		this. = true;
		this..compile(units);
catch (AbortCompilation ignored) {
		// ignore the AbortCompilcation coming from BuildNotifier.checkCancelWithinCompiler()
		// the Compiler failed after the user has chose to cancel... likely due to an OutOfMemory error
finally {
		this. = false;
	}
	// Check for cancel immediately after a compile, because the compiler may
	// have been cancelled but without propagating the correct exception
protected void copyResource(IResource source, IResource destinationthrows CoreException {
	IPath destPath = destination.getFullPath();
	try {
		source.copy(destPath, IResource.FORCE | IResource.DERIVED, null);
catch (CoreException e) {
		// handle the case when the source resource is deleted
		source.refreshLocal(0, null);
		if (!source.exists()) return// source resource was deleted so skip it
		throw e;
	}
	Util.setReadOnly(destinationfalse); // just in case the original was read only
protected void createProblemFor(IResource resourceIMember javaElementString messageString problemSeverity) {
	try {
		IMarker marker = resource.createMarker(.);
		int severity = problemSeverity.equals(.) ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_ERROR;
		ISourceRange range = null;
		if (javaElement != null) {
			try {
				range = javaElement.getNameRange();
catch (JavaModelException e) {
					throw e;
				}
				if (!CharOperation.equals(javaElement.getElementName().toCharArray(), .)) {
					throw e;
				}
				// else silently swallow the exception as the synthetic interface type package-info has no
				// source range really. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=258145
			}
		}
		int start = range == null ? 0 : range.getOffset();
		int end = range == null ? 1 : start + range.getLength();
		marker.setAttributes(
			new String[] {IMarker.MESSAGE, IMarker.SEVERITY, IMarker.CHAR_START, IMarker.CHAR_END, IMarker.SOURCE_ID},
			new Object[] {messagenew Integer(severity), new Integer(start), new Integer(end), .});
catch (CoreException e) {
	}
protected void deleteGeneratedFiles(IFile[] deletedGeneratedFiles) {
	// no op by default
protected SourceFile findSourceFile(IFile fileboolean mustExist) {
	if (mustExist && !file.exists()) return null;
	// assumes the file exists in at least one of the source folders & is not excluded
	if (this..length > 1) {
		IPath sourceFileFullPath = file.getFullPath();
		for (int j = 0, m = this..lengthj < mj++) {
			if (this.[j]..getFullPath().isPrefixOf(sourceFileFullPath)) {
				md = this.[j];
				if (md.exclusionPatterns == null && md.inclusionPatterns == null)
					break;
				if (!Util.isExcluded(filemd.inclusionPatternsmd.exclusionPatterns))
					break;
			}
		}
	}
	return new SourceFile(filemd);
protected void finishedWith(String sourceLocatorCompilationResult resultchar[] mainTypeNameArrayList definedTypeNamesArrayList duplicateTypeNames) {
	if (duplicateTypeNames == null) {
		this..record(sourceLocatorresult.qualifiedReferencesresult.simpleNameReferencesresult.rootReferencesmainTypeNamedefinedTypeNames);
		return;
	}
	char[][] simpleRefs = result.simpleNameReferences;
	// for each duplicate type p1.p2.A, add the type name A (package was already added)
	next : for (int i = 0, l = duplicateTypeNames.size(); i < li++) {
		char[][] compoundName = (char[][]) duplicateTypeNames.get(i);
		char[] typeName = compoundName[compoundName.length - 1];
		int sLength = simpleRefs.length;
		for (int j = 0; j < sLengthj++)
			if (CharOperation.equals(simpleRefs[j], typeName))
				continue next;
		System.arraycopy(simpleRefs, 0, simpleRefs = new char[sLength + 1][], 0, sLength);
		simpleRefs[sLength] = typeName;
	}
	this..record(sourceLocatorresult.qualifiedReferencessimpleRefsresult.rootReferencesmainTypeNamedefinedTypeNames);
protected IContainer createFolder(IPath packagePath, IContainer outputFolderthrows CoreException {
	if (packagePath.isEmpty()) return outputFolder;
	IFolder folder = outputFolder.getFolder(packagePath);
	if (!folder.exists()) {
		createFolder(packagePath.removeLastSegments(1), outputFolder);
		folder.create(IResource.FORCE | IResource.DERIVED, truenull);
	}
	return folder;
/* (non-Javadoc)
 * @see org.eclipse.jdt.internal.core.builder.ICompilationUnitLocator#fromIFile(org.eclipse.core.resources.IFile)
 */
public ICompilationUnit fromIFile(IFile file) {
	return findSourceFile(filetrue);
protected void initializeAnnotationProcessorManager(Compiler newCompiler) {
	if (annotationManager != null) {
		annotationManager.configureFromPlatform(newCompilerthisthis..);
		annotationManager.setErr(new PrintWriter(.));
		annotationManager.setOut(new PrintWriter(.));
	}
	newCompiler.annotationProcessorManager = annotationManager;
protected RuntimeException internalException(CoreException t) {
	if (this.)
		return new AbortCompilation(trueimageBuilderException);
	return imageBuilderException;
protected boolean isExcludedFromProject(IPath childPaththrows JavaModelException {
	// answer whether the folder should be ignored when walking the project as a source folder
	if (childPath.segmentCount() > 2) return false// is a subfolder of a package
	for (int j = 0, k = this..lengthj < kj++) {
		if (childPath.equals(this.[j]..getFullPath())) return true;
		if (childPath.equals(this.[j]..getFullPath())) return true;
	}
	// skip default output folder which may not be used by any source folder
	return childPath.equals(this...getOutputLocation());
protected Compiler newCompiler() {
	// disable entire javadoc support if not interested in diagnostics
	Map projectOptions = this...getOptions(true);
	String option = (StringprojectOptions.get(.);
	if (option == null || option.equals(.)) { // TODO (frederic) see why option is null sometimes while running model tests!?
		option = (StringprojectOptions.get(.);
		if (option == null || option.equals(.)) {
			if (option == null || option.equals(.)) {
				option = (StringprojectOptions.get(.);
				if (option == null || option.equals(.)) { // Unused import need also to look inside javadoc comment
				}
			}
		}
	}
	// called once when the builder is initialized... can override if needed
	CompilerOptions compilerOptions = new CompilerOptions(projectOptions);
	compilerOptions.performMethodsFullRecovery = true;
	compilerOptions.performStatementsRecovery = true;
	Compiler newCompiler = new Compiler(
		DefaultErrorHandlingPolicies.proceedWithAllProblems(),
		compilerOptions,
		this,
		ProblemFactory.getProblemFactory(Locale.getDefault()));
	CompilerOptions options = newCompiler.options;
	// temporary code to allow the compiler to revert to a single thread
	String setting = System.getProperty("jdt.compiler.useSingleThread"); //$NON-NLS-1$
	newCompiler.useSingleThread = setting != null && setting.equals("true"); //$NON-NLS-1$
	// enable the compiler reference info support
	options.produceReferenceInfo = true;
	if (options.complianceLevel >= .
			&& options.processAnnotations) {
		// support for Java 6 annotation processors
	}
	return newCompiler;
protected CompilationParticipantResult[] notifyParticipants(SourceFile[] unitsAboutToCompile) {
	CompilationParticipantResult[] results = new CompilationParticipantResult[unitsAboutToCompile.length];
	for (int i = unitsAboutToCompile.length; --i >= 0;)
		results[i] = new CompilationParticipantResult(unitsAboutToCompile[i]);
	// TODO (kent) do we expect to have more than one participant?
	// and if so should we pass the generated files from the each processor to the others to process?
	// and what happens if some participants do not expect to be called with only a few files, after seeing 'all' the files?
	for (int i = 0, l = this...lengthi < li++)
		this..[i].buildStarting(resultsthis instanceof BatchImageBuilder);
	SimpleSet uniqueFiles = null;
	int added = 0;
	for (int i = results.length; --i >= 0;) {
		CompilationParticipantResult result = results[i];
		if (result == nullcontinue;
		IFile[] deletedGeneratedFiles = result.deletedFiles;
		if (deletedGeneratedFiles != null)
			deleteGeneratedFiles(deletedGeneratedFiles);
		IFile[] addedGeneratedFiles = result.addedFiles;
		if (addedGeneratedFiles != null) {
			for (int j = addedGeneratedFiles.length; --j >= 0;) {
				SourceFile sourceFile = findSourceFile(addedGeneratedFiles[j], true);
				if (sourceFile == nullcontinue;
				if (uniqueFiles == null) {
					uniqueFiles = new SimpleSet(unitsAboutToCompile.length + 3);
					for (int f = unitsAboutToCompile.length; --f >= 0;)
						uniqueFiles.add(unitsAboutToCompile[f]);
				}
				if (uniqueFiles.addIfNotIncluded(sourceFile) == sourceFile) {
					// is there enough room to add all the addedGeneratedFiles.length ?
					if (toAdd == null) {
						toAdd = new CompilationParticipantResult[addedGeneratedFiles.length];
else {
						int length = toAdd.length;
						if (added == length)
							System.arraycopy(toAdd, 0, toAdd = new CompilationParticipantResult[length + addedGeneratedFiles.length], 0, length);
					}
					toAdd[added++] = newResult;
				}
			}
		}
	}
	if (added >0 ) {
		int length = results.length;
		System.arraycopy(results, 0, results = new CompilationParticipantResult[length + added], 0 , length);
		System.arraycopy(toAdd, 0, resultslengthadded);
	}
	return results;
protected abstract void processAnnotationResults(CompilationParticipantResult[] results);
protected void processAnnotations(CompilationParticipantResult[] results) {
	boolean hasAnnotationProcessor = false;
	for (int i = 0, l = this...length; !hasAnnotationProcessor && i < li++)
		hasAnnotationProcessor = this..[i].isAnnotationProcessor();
	if (!hasAnnotationProcessorreturn;
	boolean foundAnnotations = this. != null && this.. > 0;
	for (int i = results.length; --i >= 0;)
		results[i].reset(foundAnnotations && this..includes(results[i].));
	// even if no files have annotations, must still tell every annotation processor in case the file used to have them
	for (int i = 0, l = this...lengthi < li++)
	// any added/changed/deleted generated files have already been taken care
	// just record the problems and dependencies - do not expect there to be many
	// must be called after we're finished with the compilation unit results but before incremental loop adds affected files
	CategorizedProblem[] problems = result.problems;
	if (problems != null && problems.length > 0) {
		// existing problems have already been removed so just add these as new problems
		try {
			storeProblemsFor(result.sourceFileproblems);
catch (CoreException e) {
			// must continue with compile loop so just log the CoreException
			Util.log(e"JavaBuilder logging CompilationParticipant's CoreException to help debugging"); //$NON-NLS-1$
		}
	}
	String[] dependencies = result.dependencies;
	if (dependencies != null) {
		if (refs != null)
			refs.addDependencies(dependencies);
	}
Creates a marker from each problem and adds it to the resource. The marker is as follows: - its type is T_PROBLEM - its plugin ID is the JavaBuilder's plugin ID - its message is the problem's message - its priority reflects the severity of the problem - its range is the problem's range - it has an extra attribute "ID" which holds the problem's id - it's IMarker attribute is positioned to JavaBuilder.SOURCE_ID if the problem was generated by JDT; else the IMarker attribute is carried from the problem to the marker in extra attributes, if present.
protected void storeProblemsFor(SourceFile sourceFileCategorizedProblem[] problemsthrows CoreException {
	if (sourceFile == null || problems == null || problems.length == 0) return;
	 // once a classpath error is found, ignore all other problems for this project so the user can see the main error
	// but still try to compile as many source files as possible to help the case when the base libraries are in source
	if (!this.return// only want the one error recorded on this source file
	HashSet managedMarkerTypes = JavaModelManager.getJavaModelManager()..managedMarkerTypes();
	problems: for (int i = 0, l = problems.lengthi < li++) {
		CategorizedProblem problem = problems[i];
		int id = problem.getID();
		// we may use a different resource for certain problems such as IProblem.MissingNonNullByDefaultAnnotationOnPackage
		// but at the start of the next problem we should reset it to the source file's resource
		IResource resource = sourceFile.resource;
		// handle missing classfile situation
			String missingClassfileName = problem.getArguments()[0];
				..println(Messages.bind(.missingClassfileName));
			boolean isInvalidClasspathError = ..equals(this...getOption(.true));
			// insert extra classpath problem, and make it the only problem for this project (optional)
				JavaBuilder.removeProblemsAndTasksFor(this..); // make this the only problem for this project
			}
			marker.setAttributes(
				new String[] {IMarker.MESSAGE, IMarker.SEVERITY, ., IMarker.SOURCE_ID},
				new Object[] {
					Messages.bind(.missingClassfileName),
					new Integer(isInvalidClasspathError ? IMarker.SEVERITY_ERROR : IMarker.SEVERITY_WARNING),
				}
			);
			// even if we're not keeping more markers, still fall through rest of the problem reporting, so that offending
			// IsClassPathCorrect problem gets recorded since it may help locate the offending reference
		}
		String markerType = problem.getMarkerType();
		boolean managedProblem = false;
				|| (managedProblem = managedMarkerTypes.contains(markerType))) {
				// for this kind of problem, marker needs to be created on the package instead of on the source file
				// see bug 372012
				char[] fileName = sourceFile.getFileName();
				int pkgEnd = CharOperation.lastIndexOf('/'fileName);
				if (pkgEnd == -1)
					pkgEnd = CharOperation.lastIndexOf(.fileName);
				PackageFragment pkg = null;
				if (pkgEnd != -1)
					pkg = (PackageFragment) Util.getPackageFragment(sourceFile.getFileName(), pkgEnd, -1 /*no jar separator for java files*/);
				if (pkg != null) {
					try {
						IMarker[] existingMarkers = pkg.resource().findMarkers(.false, IResource.DEPTH_ZERO);
						int len = existingMarkers.length;
						for (int j=0; j < lenj++) {
							if (((Integer)existingMarkers[j].getAttribute(.)).intValue() == .) {
								continue problems; // marker already present
							}
						}
catch (CoreException e) {
						// marker retrieval failed, cannot do much
							e.printStackTrace();
						}
					}
					IResource tempRes = pkg.resource();
					if (tempRes != null) {
						resource = tempRes;
					}
				}
			}
			IMarker marker = resource.createMarker(markerType);
			int standardLength = attributeNames.length;
			String[] allNames = attributeNames;
			int managedLength = managedProblem ? 0 : 1;
			String[] extraAttributeNames = problem.getExtraMarkerAttributeNames();
			int extraLength = extraAttributeNames == null ? 0 : extraAttributeNames.length;
			if (managedLength > 0 || extraLength > 0) {
				allNames = new String[standardLength + managedLength + extraLength];
				System.arraycopy(attributeNames, 0, allNames, 0, standardLength);
				if (managedLength > 0)
					allNames[standardLength] = IMarker.SOURCE_ID;
				System.arraycopy(extraAttributeNames, 0, allNamesstandardLength + managedLengthextraLength);
			}
			Object[] allValues = new Object[allNames.length];
			// standard attributes
			int index = 0;
			allValues[index++] = problem.getMessage(); // message
			allValues[index++] = problem.isError() ?  : // severity
			allValues[index++] = new Integer(id); // ID
			allValues[index++] = new Integer(problem.getSourceStart()); // start
			allValues[index++] = new Integer(problem.getSourceEnd() + 1); // end
			allValues[index++] = new Integer(problem.getSourceLineNumber()); // line
			allValues[index++] = Util.getProblemArgumentsForMarker(problem.getArguments()); // arguments
			allValues[index++] = new Integer(problem.getCategoryID()); // category ID
			// SOURCE_ID attribute for JDT problems
			if (managedLength > 0)
				allValues[index++] = .;
			// optional extra attributes
			if (extraLength > 0)
				System.arraycopy(problem.getExtraMarkerAttributeValues(), 0, allValuesindexextraLength);
			marker.setAttributes(allNamesallValues);
			if (!this.return// only want the one error recorded on this source file
		}
	}
protected void storeTasksFor(SourceFile sourceFileCategorizedProblem[] tasksthrows CoreException {
	if (sourceFile == null || tasks == null || tasks.length == 0) return;
	IResource resource = sourceFile.resource;
	for (int i = 0, l = tasks.lengthi < li++) {
		CategorizedProblem task = tasks[i];
		if (task.getID() == .) {
			IMarker marker = resource.createMarker(.);
			Integer priority = ;
			String compilerPriority = task.getArguments()[2];
				priority = ;
			else if (..equals(compilerPriority))
				priority = ;
			int standardLength = attributeNames.length;
			String[] allNames = attributeNames;
			String[] extraAttributeNames = task.getExtraMarkerAttributeNames();
			int extraLength = extraAttributeNames == null ? 0 : extraAttributeNames.length;
			if (extraLength > 0) {
				allNames = new String[standardLength + extraLength];
				System.arraycopy(attributeNames, 0, allNames, 0, standardLength);
				System.arraycopy(extraAttributeNames, 0, allNamesstandardLengthextraLength);
			}
			Object[] allValues = new Object[allNames.length];
			// standard attributes
			int index = 0;
			allValues[index++] = task.getMessage();
			allValues[index++] = priority;
			allValues[index++] = new Integer(task.getID());
			allValues[index++] = new Integer(task.getSourceStart());
			allValues[index++] = new Integer(task.getSourceEnd() + 1);
			allValues[index++] = new Integer(task.getSourceLineNumber());
			allValues[index++] = .;
			allValues[index++] = .;
			// optional extra attributes
			if (extraLength > 0)
				System.arraycopy(task.getExtraMarkerAttributeValues(), 0, allValuesindexextraLength);
			marker.setAttributes(allNamesallValues);
		}
	}
protected void updateProblemsFor(SourceFile sourceFileCompilationResult resultthrows CoreException {
	CategorizedProblem[] problems = result.getProblems();
	if (problems == null || problems.length == 0) return;
	storeProblemsFor(sourceFileproblems);
protected void updateTasksFor(SourceFile sourceFileCompilationResult resultthrows CoreException {
	CategorizedProblem[] tasks = result.getTasks();
	if (tasks == null || tasks.length == 0) return;
	storeTasksFor(sourceFiletasks);
protected char[] writeClassFile(ClassFile classFileSourceFile compilationUnitboolean isTopLevelTypethrows CoreException {
	String fileName = new String(classFile.fileName()); // the qualified type name "p1/p2/A"
	IPath filePath = new Path(fileName);
	IContainer outputFolder = compilationUnit.sourceLocation.binaryFolder;
	IContainer container = outputFolder;
	if (filePath.segmentCount() > 1) {
		container = createFolder(filePath.removeLastSegments(1), outputFolder);
		filePath = new Path(filePath.lastSegment());
	}
	IFile file = container.getFile(filePath.addFileExtension(.));
	writeClassFileContents(classFilefilefileNameisTopLevelTypecompilationUnit);
	// answer the name of the class file as in Y or Y$M
	return filePath.lastSegment().toCharArray();
protected void writeClassFileContents(ClassFile classFile, IFile fileString qualifiedFileNameboolean isTopLevelTypeSourceFile compilationUnitthrows CoreException {
//	InputStream input = new SequenceInputStream(
//			new ByteArrayInputStream(classFile.header, 0, classFile.headerOffset),
//			new ByteArrayInputStream(classFile.contents, 0, classFile.contentsOffset));
	InputStream input = new ByteArrayInputStream(classFile.getBytes());
	if (file.exists()) {
		// Deal with shared output folders... last one wins... no collision cases detected
			..println("Writing changed class file " + file.getName());//$NON-NLS-1$
		if (!file.isDerived())
			file.setDerived(truenull);
		file.setContents(inputtruefalsenull);
else {
		// Default implementation just writes out the bytes for the new class file...
			..println("Writing new class file " + file.getName());//$NON-NLS-1$
		file.create(input, IResource.FORCE | IResource.DERIVED, null);
	}
New to GrepCode? Check out our FAQ X