IncrementalImageBuilder.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.phpdt.internal.core.builder |
 |
 |
PHPeclipse |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LINE_COMMENT | Number of line comments |  |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| COMMENTS | Comment lines | |
| EXEC_COMMENTS | Comments in executable code | |
| JAVA0031 | JAVA0031 Case statement not properly closed | |
| SIZE | Size of the file in bytes | |
| JAVA0266 | JAVA0266 Use of System.out | |
| JAVA0032 | JAVA0032 Switch statement missing default | |
| JAVA0035 | JAVA0035 Missing braces in for statement | |
| LINES | Number of lines in the source file | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| EXITS | Procedure exits | |
| CYCLOMATIC | Cyclomatic complexity | |
| LOOPS | Number of loops | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| ELOC | Effective lines of code | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| UNIQUE_OPERANDS | Number of unique operands | |
| OPERANDS | Number of operands | |
| PROGRAM_LENGTH | Halstead program length | |
| LOGICAL_LINES | Number of statements | |
| OPERATORS | Number of operators | |
| RETURNS | Number of return points from functions | |
| JAVA0076 | JAVA0076 Use of magic number | |
| UNIQUE_OPERATORS | Number of unique operators | |
| LOC | Lines of code | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0160 | JAVA0160 Method does not throw specified exception | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0171 | JAVA0171 Unused local variable | |
| COMPARISONS | Number of comparison operators | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| WHITESPACE | Number of whitespace lines | |
| DOC_COMMENT | Number of javadoc comment lines | |
| JAVA0075 | JAVA0075 Method parameter hides field | |
| DECL_COMMENTS | Comments in declarations | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| NEST_DEPTH | Maximum nesting depth | |
/*******************************************************************************
* Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package net.sourceforge.phpdt.internal.core.builder;
import java.util.ArrayList;
import net.sourceforge.phpdt.core.compiler.IProblem;
import net.sourceforge.phpdt.internal.compiler.CompilationResult;
import net.sourceforge.phpdt.internal.compiler.problem.ProblemHandler;
import net.sourceforge.phpdt.internal.core.util.SimpleLookupTable;
import net.sourceforge.phpdt.internal.core.util.Util;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
/**
* The incremental image builder
*/
public class IncrementalImageBuilder extends AbstractImageBuilder {
protected ArrayList sourceFiles;
protected ArrayList previousSourceFiles;
protected ArrayList qualifiedStrings;
protected ArrayList simpleStrings;
protected SimpleLookupTable secondaryTypesToRemove;
protected boolean hasStructuralChanges;
protected int compileLoop;
public static int MaxCompileLoop = 5; // perform a full build if it takes
// more than ? incremental compile
// loops
protected IncrementalImageBuilder(PHPBuilder javaBuilder) {
super(javaBuilder);
this.nameEnvironment.isIncrementalBuild = true;
this.newState.copyFrom(javaBuilder.lastState);
this.sourceFiles = new ArrayList(33);
this.previousSourceFiles = null;
this.qualifiedStrings = new ArrayList(33);
this.simpleStrings = new ArrayList(33);
this.hasStructuralChanges = false;
this.compileLoop = 0;
}
public boolean build(SimpleLookupTable deltas) {
// initialize builder
// walk this project's deltas, find changed source files
// walk prereq projects' deltas, find changed class files & add affected
// source files
// use the build state # to skip the deltas for certain prereq projects
// ignore changed zip/jar files since they caused a full build
// compile the source files & acceptResult()
// compare the produced class files against the existing ones on disk
// recompile all dependent source files of any type with structural
// changes
// or new/removed secondary type
// keep a loop counter to abort & perform a full build
if (PHPBuilder.DEBUG)
System.out.println("INCREMENTAL build"); //$NON-NLS-1$
try {
resetCollections();
notifier.subTask(Util.bind("build.analyzingDeltas")); //$NON-NLS-1$
IResourceDelta sourceDelta = (IResourceDelta) deltas
.get(javaBuilder.currentProject);
if (sourceDelta != null) {
sourceDelta.accept(new ParserVisitor(
javaBuilder.currentProject, notifier.monitor));
if (!findSourceFiles(sourceDelta))
return false;
}
notifier.updateProgressDelta(0.10f);
// Object[] keyTable = deltas.keyTable;
// Object[] valueTable = deltas.valueTable;
// // final IdentifierIndexManager indexManager =
// PHPeclipsePlugin.getDefault()
// // .getIndexManager(javaBuilder.currentProject);
// for (int i = 0, l = valueTable.length; i < l; i++) {
// IResourceDelta delta = (IResourceDelta) valueTable[i];
// if (delta != null) {
// IResource resource = delta.getResource();
// int resourceType = resource.getType();
// if (resourceType == IResource.FILE) {
// switch (delta.getKind()) {
// case IResourceDelta.ADDED :
// if ((resource.getFileExtension() != null)
// && PHPFileUtil.isPHPFile((IFile) resource)) {
// // update indexfile for the project:
// // indexManager.addFile((IFile) resource);
// }
// break;
// case IResourceDelta.CHANGED :
// if ((resource.getFileExtension() != null)
// && PHPFileUtil.isPHPFile((IFile) resource)) {
// // update indexfile for the project:
// // indexManager.changeFile((IFile) resource);
// }
// break;
// case IResourceDelta.REMOVED :
// if ((resource.getFileExtension() != null)
// && PHPFileUtil.isPHPFile((IFile) resource)) {
// // update indexfile for the project:
// // indexManager.removeFile((IFile) resource);
// }
// break;
// }
// }
// // ClasspathLocation[] classFoldersAndJars =
// (ClasspathLocation[])
// // javaBuilder.binaryLocationsPerProject.get(keyTable[i]);
// // if (classFoldersAndJars != null)
// // if (!findAffectedSourceFiles(delta, classFoldersAndJars))
// return
// // false;
// }
// }
notifier.updateProgressDelta(0.10f);
notifier.subTask(Util.bind("build.analyzingSources")); //$NON-NLS-1$
addAffectedSourceFiles();
notifier.updateProgressDelta(0.05f);
this.compileLoop = 0;
float increment = 0.40f;
while (sourceFiles.size() > 0) { // added to in acceptResult
if (++this.compileLoop > MaxCompileLoop) {
if (PHPBuilder.DEBUG)
System.out
.println("ABORTING incremental build... exceeded loop count"); //$NON-NLS-1$
return false;
}
notifier.checkCancel();
SourceFile[] allSourceFiles = new SourceFile[sourceFiles.size()];
sourceFiles.toArray(allSourceFiles);
resetCollections();
workQueue.addAll(allSourceFiles);
notifier.setProgressPerCompilationUnit(increment
/ allSourceFiles.length);
increment = increment / 2;
compile(allSourceFiles);
// removeSecondaryTypes();
addAffectedSourceFiles();
}
if (this.hasStructuralChanges
&& javaBuilder.javaProject.hasCycleMarker())
javaBuilder.mustPropagateStructuralChanges();
} catch (AbortIncrementalBuildException e) {
// abort the incremental build and let the batch builder handle the
// problem
if (PHPBuilder.DEBUG)
System.out
.println("ABORTING incremental build... cannot find " + e.qualifiedTypeName + //$NON-NLS-1$
". Could have been renamed inside its existing source file."); //$NON-NLS-1$
return false;
} catch (CoreException e) {
throw internalException(e);
} finally {
cleanUp();
}
return true;
}
protected void addAffectedSourceFiles() {
if (qualifiedStrings.isEmpty() && simpleStrings.isEmpty())
return;
// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are
// just 'X'
// char[][][] qualifiedNames = ReferenceCollection
// .internQualifiedNames(qualifiedStrings);
// if a well known qualified name was found then we can skip over these
// if (qualifiedNames.length < qualifiedStrings.size())
// qualifiedNames = null;
// char[][] simpleNames =
// ReferenceCollection.internSimpleNames(simpleStrings);
// if a well known name was found then we can skip over these
// if (simpleNames.length < simpleStrings.size())
// simpleNames = null;
// Object[] keyTable = newState.references.keyTable;
// Object[] valueTable = newState.references.valueTable;
// next : for (int i = 0, l = valueTable.length; i < l; i++) {
// ReferenceCollection refs = (ReferenceCollection) valueTable[i];
// if (refs != null && refs.includes(qualifiedNames, simpleNames)) {
// String typeLocator = (String) keyTable[i];
// IFile file = javaBuilder.currentProject.getFile(typeLocator);
// if (file.exists()) {
// ClasspathMultiDirectory md = sourceLocations[0];
// if (sourceLocations.length > 1) {
// IPath sourceFileFullPath = file.getFullPath();
// for (int j = 0, m = sourceLocations.length; j < m; j++) {
// if (sourceLocations[j].sourceFolder.getFullPath().isPrefixOf(
// sourceFileFullPath)) {
// md = sourceLocations[j];
// if (md.exclusionPatterns == null
// || !ProjectPrefUtil.isExcluded(file, md.exclusionPatterns))
// break;
// }
// }
// }
// SourceFile sourceFile = new SourceFile(file, md, encoding);
// if (sourceFiles.contains(sourceFile))
// continue next;
// if (compiledAllAtOnce && previousSourceFiles != null
// && previousSourceFiles.contains(sourceFile))
// continue next; // can skip previously compiled files since already
// // saw hierarchy related problems
// if (PHPBuilder.DEBUG)
// System.out.println(" adding affected source file " + typeLocator);
// //$NON-NLS-1$
// // // update indexfile for the project:
// sourceFiles.add(sourceFile);
// }
// }
// }
}
protected void addDependentsOf(IPath path, boolean hasStructuralChanges) {
if (hasStructuralChanges) {
newState.tagAsStructurallyChanged();
this.hasStructuralChanges = true;
}
// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are
// just 'X'
path = path.setDevice(null);
String packageName = path.removeLastSegments(1).toString();
if (!qualifiedStrings.contains(packageName))
qualifiedStrings.add(packageName);
String typeName = path.lastSegment();
int memberIndex = typeName.indexOf('$');
if (memberIndex > 0)
typeName = typeName.substring(0, memberIndex);
if (!simpleStrings.contains(typeName)) {
if (PHPBuilder.DEBUG)
System.out.println(" will look for dependents of " //$NON-NLS-1$
+ typeName + " in " + packageName); //$NON-NLS-1$
simpleStrings.add(typeName);
}
}
protected void cleanUp() {
super.cleanUp();
this.sourceFiles = null;
this.previousSourceFiles = null;
this.qualifiedStrings = null;
this.simpleStrings = null;
this.secondaryTypesToRemove = null;
this.hasStructuralChanges = false;
this.compileLoop = 0;
}
// protected boolean findAffectedSourceFiles(IResourceDelta delta,
// ClasspathLocation[] classFoldersAndJars) {
// for (int i = 0, l = classFoldersAndJars.length; i < l; i++) {
// ClasspathLocation bLocation = classFoldersAndJars[i];
// // either a .class file folder or a zip/jar file
// if (bLocation != null) { // skip unchanged output folder
// IPath p = bLocation.getProjectRelativePath();
// if (p != null) {
// IResourceDelta binaryDelta = delta.findMember(p);
// if (binaryDelta != null) {
// if (bLocation instanceof ClasspathJar) {
// if (JavaBuilder.DEBUG)
// System.out.println("ABORTING incremental build... found delta to jar/zip
// file"); //$NON-NLS-1$
// return false; // do full build since jar file was changed (added/removed
// were caught as classpath change)
// }
// if (binaryDelta.getKind() == IResourceDelta.ADDED ||
// binaryDelta.getKind()
// == IResourceDelta.REMOVED) {
// if (JavaBuilder.DEBUG)
// System.out.println("ABORTING incremental build... found added/removed
// binary folder"); //$NON-NLS-1$
// return false; // added/removed binary folder should not make it here
// (classpath change), but handle anyways
// }
// int segmentCount = binaryDelta.getFullPath().segmentCount();
// IResourceDelta[] children = binaryDelta.getAffectedChildren(); // .class
// files from class folder
// for (int j = 0, m = children.length; j < m; j++)
// findAffectedSourceFiles(children[j], segmentCount);
// notifier.checkCancel();
// }
// }
// }
// }
// return true;
// }
protected void findAffectedSourceFiles(IResourceDelta binaryDelta,
int segmentCount) {
// When a package becomes a type or vice versa, expect 2 deltas,
// one on the folder & one on the class file
IResource resource = binaryDelta.getResource();
switch (resource.getType()) {
case IResource.FOLDER:
switch (binaryDelta.getKind()) {
case IResourceDelta.ADDED:
case IResourceDelta.REMOVED:
IPath packagePath = resource.getFullPath().removeFirstSegments(
segmentCount);
String packageName = packagePath.toString();
if (binaryDelta.getKind() == IResourceDelta.ADDED) {
// see if any known source file is from the same package...
// classpath already includes new package
// if (!newState.isKnownPackage(packageName)) {
// if (PHPBuilder.DEBUG)
// System.out.println("Found added package " + packageName);
// //$NON-NLS-1$
// addDependentsOf(packagePath, false);
// return;
// }
if (PHPBuilder.DEBUG)
System.out
.println("Skipped dependents of added package " + packageName); //$NON-NLS-1$
} else {
// see if the package still exists on the classpath
// if (!nameEnvironment.isPackage(packageName)) {
// if (JavaBuilder.DEBUG)
// System.out.println("Found removed package " +
// packageName);
// //$NON-NLS-1$
// addDependentsOf(packagePath, false);
// return;
// }
if (PHPBuilder.DEBUG)
System.out
.println("Skipped dependents of removed package " + packageName); //$NON-NLS-1$
}
// fall thru & traverse the sub-packages and .class files
case IResourceDelta.CHANGED:
IResourceDelta[] children = binaryDelta.getAffectedChildren();
for (int i = 0, l = children.length; i < l; i++)
findAffectedSourceFiles(children[i], segmentCount);
}
return;
case IResource.FILE:
// if (ProjectPrefUtil.isClassFileName(resource.getName())) {
// IPath typePath =
// resource.getFullPath().removeFirstSegments(segmentCount).removeFileExtension();
// switch (binaryDelta.getKind()) {
// case IResourceDelta.ADDED :
// case IResourceDelta.REMOVED :
// if (JavaBuilder.DEBUG)
// System.out.println("Found added/removed class file " + typePath);
// //$NON-NLS-1$
// addDependentsOf(typePath, false);
// return;
// case IResourceDelta.CHANGED :
// if ((binaryDelta.getFlags() & IResourceDelta.CONTENT) == 0)
// return; // skip it since it really isn't changed
// if (JavaBuilder.DEBUG)
// System.out.println("Found changed class file " + typePath);
// //$NON-NLS-1$
// addDependentsOf(typePath, false);
// }
// return;
// }
}
}
protected boolean findSourceFiles(IResourceDelta delta)
throws CoreException {
for (int i = 0, l = sourceLocations.length; i < l; i++) {
ClasspathMultiDirectory md = sourceLocations[i];
if (md.sourceFolder.equals(javaBuilder.currentProject)) {
// skip nested source & output folders when the project is a
// source
// folder
int segmentCount = delta.getFullPath().segmentCount();
IResourceDelta[] children = delta.getAffectedChildren();
for (int j = 0, m = children.length; j < m; j++)
if (!isExcludedFromProject(children[j].getFullPath()))
findSourceFiles(children[j], md, segmentCount);
} else {
IResourceDelta sourceDelta = delta.findMember(md.sourceFolder
.getProjectRelativePath());
if (sourceDelta != null) {
if (sourceDelta.getKind() == IResourceDelta.REMOVED) {
if (PHPBuilder.DEBUG)
System.out
.println("ABORTING incremental build... found removed source folder"); //$NON-NLS-1$
return false; // removed source folder should not make
// it here, but
// handle anyways (ADDED is supported)
}
int segmentCount = sourceDelta.getFullPath().segmentCount();
IResourceDelta[] children = sourceDelta
.getAffectedChildren();
for (int j = 0, m = children.length; j < m; j++)
findSourceFiles(children[j], md, segmentCount);
}
}
notifier.checkCancel();
}
return true;
}
protected void findSourceFiles(IResourceDelta sourceDelta,
ClasspathMultiDirectory md, int segmentCount) throws CoreException {
// When a package becomes a type or vice versa, expect 2 deltas,
// one on the folder & one on the source file
IResource resource = sourceDelta.getResource();
if (md.exclusionPatterns != null
&& Util.isExcluded(resource, md.exclusionPatterns))
return;
switch (resource.getType()) {
case IResource.FOLDER:
switch (sourceDelta.getKind()) {
case IResourceDelta.ADDED:
IPath addedPackagePath = resource.getFullPath()
.removeFirstSegments(segmentCount);
// createFolder(addedPackagePath, md.binaryFolder); // ensure
// package
// exists in the
// output folder
// add dependents even when the package thinks it exists to be
// on
// the safe side
if (PHPBuilder.DEBUG)
System.out
.println("Found added package " + addedPackagePath); //$NON-NLS-1$
addDependentsOf(addedPackagePath, true);
// fall thru & collect all the source files
case IResourceDelta.CHANGED:
IResourceDelta[] children = sourceDelta.getAffectedChildren();
for (int i = 0, l = children.length; i < l; i++)
findSourceFiles(children[i], md, segmentCount);
return;
case IResourceDelta.REMOVED:
IPath removedPackagePath = resource.getFullPath()
.removeFirstSegments(segmentCount);
if (sourceLocations.length > 1) {
for (int i = 0, l = sourceLocations.length; i < l; i++) {
if (sourceLocations[i].sourceFolder.getFolder(
removedPackagePath).exists()) {
// only a package fragment was removed, same as
// removing
// multiple source files
// createFolder(removedPackagePath,
// md.binaryFolder); // ensure
// package
// exists
// in the
// output
// folder
IResourceDelta[] removedChildren = sourceDelta
.getAffectedChildren();
for (int j = 0, m = removedChildren.length; j < m; j++)
findSourceFiles(removedChildren[j], md,
segmentCount);
return;
}
}
}
// IFolder removedPackageFolder = md.binaryFolder
// .getFolder(removedPackagePath);
// if (removedPackageFolder.exists())
// removedPackageFolder.delete(IResource.FORCE, null);
// add dependents even when the package thinks it does not exist
// to
// be on the safe side
if (PHPBuilder.DEBUG)
System.out
.println("Found removed package " + removedPackagePath); //$NON-NLS-1$
addDependentsOf(removedPackagePath, true);
newState.removePackage(sourceDelta);
}
return;
case IResource.FILE:
String resourceName = resource.getName();
if (net.sourceforge.phpdt.internal.compiler.util.Util
.isJavaFileName(resourceName)) {
IPath typePath = resource.getFullPath().removeFirstSegments(
segmentCount).removeFileExtension();
String typeLocator = resource.getProjectRelativePath()
.toString();
switch (sourceDelta.getKind()) {
case IResourceDelta.ADDED:
if (PHPBuilder.DEBUG)
System.out
.println("Compile this added source file " + typeLocator); //$NON-NLS-1$
sourceFiles.add(new SourceFile((IFile) resource, md,
((IFile) resource).getCharset()));
String typeName = typePath.toString();
// if (!newState.isDuplicateLocator(typeName, typeLocator))
// { // adding
// // dependents
// // results
// // in
// // 2
// // duplicate
// // errors
// if (PHPBuilder.DEBUG)
// System.out.println("Found added source file " +
// typeName); //$NON-NLS-1$
// addDependentsOf(typePath, true);
// }
return;
case IResourceDelta.REMOVED:
// char[][] definedTypeNames = newState
// .getDefinedTypeNamesFor(typeLocator);
// if (definedTypeNames == null) { // defined a single type
// matching
// // typePath
// removeClassFile(typePath, md.binaryFolder);
// if ((sourceDelta.getFlags() & IResourceDelta.MOVED_TO) !=
// 0) {
// // remove problems and tasks for a compilation unit that
// is
// // being moved (to another package or renamed)
// // if the target file is a compilation unit, the new cu
// will
// // be recompiled
// // if the target file is a non-java resource, then
// markers
// // are removed
// // see bug 2857
// IResource movedFile = javaBuilder.workspaceRoot
// .getFile(sourceDelta.getMovedToPath());
// PHPBuilder.removeProblemsAndTasksFor(movedFile);
// }
// } else {
if (PHPBuilder.DEBUG)
System.out
.println("Found removed source file " + typePath.toString()); //$NON-NLS-1$
addDependentsOf(typePath, true); // add dependents of the
// source file since it may be
// involved in a name
// collision
// if (definedTypeNames.length > 0) { // skip it if it
// failed to
// // successfully define a
// // type
// IPath packagePath = typePath.removeLastSegments(1);
// for (int i = 0, l = definedTypeNames.length; i < l; i++)
// removeClassFile(packagePath.append(new String(
// definedTypeNames[i])), md.binaryFolder);
// }
// }
// newState.removeLocator(typeLocator);
return;
case IResourceDelta.CHANGED:
if ((sourceDelta.getFlags() & IResourceDelta.CONTENT) == 0)
return; // skip it since it really isn't changed
if (PHPBuilder.DEBUG)
System.out
.println("Compile this changed source file " + typeLocator); //$NON-NLS-1$
sourceFiles.add(new SourceFile((IFile) resource, md,
((IFile) resource).getCharset()));
}
return;
// } else if (ProjectPrefUtil.isClassFileName(resourceName)) {
// return; // skip class files
} else if (md.hasIndependentOutputFolder) {
if (javaBuilder.filterExtraResource(resource))
return;
// copy all other resource deltas to the output folder
IPath resourcePath = resource.getFullPath()
.removeFirstSegments(segmentCount);
// IResource outputFile = md.binaryFolder.getFile(resourcePath);
switch (sourceDelta.getKind()) {
case IResourceDelta.ADDED:
// if (outputFile.exists()) {
// if (PHPBuilder.DEBUG)
// System.out.println("Deleting existing file " +
// resourcePath); //$NON-NLS-1$
// outputFile.delete(IResource.FORCE, null);
// }
if (PHPBuilder.DEBUG)
System.out
.println("Copying added file " + resourcePath); //$NON-NLS-1$
// createFolder(resourcePath.removeLastSegments(1),
// md.binaryFolder); // ensure
// package
// exists
// in
// the
// output
// folder
// resource.copy(outputFile.getFullPath(), IResource.FORCE,
// null);
// outputFile.setDerived(true);
return;
case IResourceDelta.REMOVED:
// if (outputFile.exists()) {
// if (PHPBuilder.DEBUG)
// System.out.println("Deleting removed file " +
// resourcePath); //$NON-NLS-1$
// outputFile.delete(IResource.FORCE, null);
// }
return;
case IResourceDelta.CHANGED:
if ((sourceDelta.getFlags() & IResourceDelta.CONTENT) == 0)
return; // skip it since it really isn't changed
// if (outputFile.exists()) {
// if (PHPBuilder.DEBUG)
// System.out.println("Deleting existing file " +
// resourcePath); //$NON-NLS-1$
// outputFile.delete(IResource.FORCE, null);
// }
if (PHPBuilder.DEBUG)
System.out
.println("Copying changed file " + resourcePath); //$NON-NLS-1$
// createFolder(resourcePath.removeLastSegments(1),
// md.binaryFolder); // ensure
// package
// exists
// in
// the
// output
// folder
// resource.copy(outputFile.getFullPath(), IResource.FORCE,
// null);
// outputFile.setDerived(true);
}
return;
}
}
}
protected void finishedWith(String sourceLocator, CompilationResult result,
char[] mainTypeName, ArrayList definedTypeNames,
ArrayList duplicateTypeNames) throws CoreException {
// char[][] previousTypeNames =
// newState.getDefinedTypeNamesFor(sourceLocator);
// if (previousTypeNames == null)
// previousTypeNames = new char[][]{mainTypeName};
// IPath packagePath = null;
// next : for (int i = 0, l = previousTypeNames.length; i < l; i++) {
// char[] previous = previousTypeNames[i];
// for (int j = 0, m = definedTypeNames.size(); j < m; j++)
// if (CharOperation.equals(previous, (char[]) definedTypeNames.get(j)))
// continue next;
// SourceFile sourceFile = (SourceFile) result.getCompilationUnit();
// if (packagePath == null) {
// int count = sourceFile.sourceLocation.sourceFolder.getFullPath()
// .segmentCount();
// packagePath = sourceFile.resource.getFullPath().removeFirstSegments(
// count).removeLastSegments(1);
// }
// if (secondaryTypesToRemove == null)
// this.secondaryTypesToRemove = new SimpleLookupTable();
// ArrayList types = (ArrayList) secondaryTypesToRemove
// .get(sourceFile.sourceLocation.binaryFolder);
// if (types == null)
// types = new ArrayList(definedTypeNames.size());
// types.add(packagePath.append(new String(previous)));
// secondaryTypesToRemove.put(sourceFile.sourceLocation.binaryFolder,
// types);
// }
// super.finishedWith(sourceLocator, result, mainTypeName,
// definedTypeNames, duplicateTypeNames);
}
// protected void removeClassFile(IPath typePath, IContainer outputFolder)
// throws CoreException {
// if (typePath.lastSegment().indexOf('$') == -1) { // is not a nested type
// newState.removeQualifiedTypeName(typePath.toString());
// // add dependents even when the type thinks it does not exist to be on
// // the safe side
// if (PHPBuilder.DEBUG)
// System.out.println("Found removed type " + typePath); //$NON-NLS-1$
// addDependentsOf(typePath, true); // when member types are removed, their
// // enclosing type is structurally
// // changed
// }
// IFile classFile = outputFolder.getFile(typePath
// .addFileExtension(PHPBuilder.CLASS_EXTENSION));
// if (classFile.exists()) {
// if (PHPBuilder.DEBUG)
// System.out.println("Deleting class file of removed type " + typePath);
// //$NON-NLS-1$
// classFile.delete(IResource.FORCE, null);
// }
// }
// protected void removeSecondaryTypes() throws CoreException {
// if (secondaryTypesToRemove != null) { // delayed deleting secondary types
// // until the end of the compile loop
// Object[] keyTable = secondaryTypesToRemove.keyTable;
// Object[] valueTable = secondaryTypesToRemove.valueTable;
// for (int i = 0, l = keyTable.length; i < l; i++) {
// IContainer outputFolder = (IContainer) keyTable[i];
// if (outputFolder != null) {
// ArrayList paths = (ArrayList) valueTable[i];
// for (int j = 0, m = paths.size(); j < m; j++)
// removeClassFile((IPath) paths.get(j), outputFolder);
// }
// }
// this.secondaryTypesToRemove = null;
// if (previousSourceFiles != null && previousSourceFiles.size() > 1)
// this.previousSourceFiles = null; // cannot optimize recompile case when
// // a secondary type is deleted
// }
// }
protected void resetCollections() {
previousSourceFiles = sourceFiles.isEmpty() ? null
: (ArrayList) sourceFiles.clone();
sourceFiles.clear();
qualifiedStrings.clear();
simpleStrings.clear();
workQueue.clear();
}
protected void updateProblemsFor(SourceFile sourceFile,
CompilationResult result) throws CoreException {
IMarker[] markers = PHPBuilder.getProblemsFor(sourceFile.resource);
IProblem[] problems = result.getProblems();
if (problems == null && markers.length == 0)
return;
// axelcl start insert - calculate line numbers
if (problems != null) {
for (int i = 0; i < problems.length; i++) {
if (problems[i].getSourceLineNumber() == 1) {
problems[i].setSourceLineNumber(ProblemHandler
.searchLineNumber(result.lineSeparatorPositions,
problems[i].getSourceStart()));
}
}
}
// axelcl end insert
notifier.updateProblemCounts(markers, problems);
PHPBuilder.removeProblemsFor(sourceFile.resource);
storeProblemsFor(sourceFile, problems);
}
protected void updateTasksFor(SourceFile sourceFile,
CompilationResult result) throws CoreException {
IMarker[] markers = PHPBuilder.getTasksFor(sourceFile.resource);
IProblem[] tasks = result.getTasks();
if (tasks == null && markers.length == 0)
return;
PHPBuilder.removeTasksFor(sourceFile.resource);
storeTasksFor(sourceFile, tasks);
}
// protected void writeClassFileBytes(byte[] bytes, IFile file, String
// qualifiedFileName, boolean isSecondaryType) throws CoreException {
// // Before writing out the class file, compare it to the previous file
// // If structural changes occured then add dependent source files
// if (file.exists()) {
// if (writeClassFileCheck(file, qualifiedFileName, bytes)) {
// if (JavaBuilder.DEBUG)
// System.out.println("Writing changed class file " +
// file.getName());//$NON-NLS-1$
// file.setContents(new ByteArrayInputStream(bytes), true, false, null);
// if (!file.isDerived())
// file.setDerived(true);
// } else if (JavaBuilder.DEBUG) {
// System.out.println("Skipped over unchanged class file " +
// file.getName());//$NON-NLS-1$
// }
// } else {
// if (isSecondaryType)
// addDependentsOf(new Path(qualifiedFileName), true); // new secondary type
// if (JavaBuilder.DEBUG)
// System.out.println("Writing new class file " +
// file.getName());//$NON-NLS-1$
// file.create(new ByteArrayInputStream(bytes), IResource.FORCE, null);
// file.setDerived(true);
// }
// }
// protected boolean writeClassFileCheck(IFile file, String fileName, byte[]
// newBytes) throws CoreException {
// try {
// byte[] oldBytes = ProjectPrefUtil.getResourceContentsAsByteArray(file);
// if (this.compileLoop > 1) { // only optimize files which were recompiled
// during the dependent pass, see 33990
// notEqual : if (newBytes.length == oldBytes.length) {
// for (int i = newBytes.length; --i >= 0;)
// if (newBytes[i] != oldBytes[i]) break notEqual;
// return false; // bytes are identical so skip them
// }
// }
// IPath location = file.getLocation();
// if (location == null) return false; // unable to determine location of
// this class file
// ClassFileReader reader = new ClassFileReader(oldBytes,
// location.toString().toCharArray());
// // ignore local types since they're only visible inside a single method
// if (!(reader.isLocal() || reader.isAnonymous()) &&
// reader.hasStructuralChanges(newBytes)) {
// if (JavaBuilder.DEBUG)
// System.out.println("Type has structural changes " + fileName);
// //$NON-NLS-1$
// addDependentsOf(new Path(fileName), true);
// }
// } catch (ClassFormatException e) {
// addDependentsOf(new Path(fileName), true);
// }
// return true;
// }
public String toString() {
return "incremental image builder for:\n\tnew state: " + newState; //$NON-NLS-1$
}
/*
* Debug helper
*
* static void dump(IResourceDelta delta) { StringBuffer buffer = new
* StringBuffer(); IPath path = delta.getFullPath(); for (int i =
* path.segmentCount(); --i > 0;) buffer.append(" "); switch
* (delta.getKind()) { case IResourceDelta.ADDED: buffer.append('+'); break;
* case IResourceDelta.REMOVED: buffer.append('-'); break; case
* IResourceDelta.CHANGED: '); break; case IResourceDelta.NO_CHANGE:
* buffer.append('='); break; default: buffer.append('?'); break; }
* buffer.append(path); System.out.println(buffer.toString());
* IResourceDelta[] children = delta.getAffectedChildren(); for (int i = 0,
* l = children.length; i < l; i++) dump(children[i]); }
*/
}
The table below shows all metrics for IncrementalImageBuilder.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 37.00 | Number of blocks | |
| BLOCK_COMMENT | 14.00 | Number of block comment lines | |
| COMMENTS | 471.00 | Comment lines | |
| COMMENT_DENSITY | 1.62 | Comment density | |
| COMPARISONS | 41.00 | Number of comparison operators | |
| CYCLOMATIC | 86.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 7.00 | Comments in declarations | |
| DOC_COMMENT | 13.00 | Number of javadoc comment lines | |
| ELOC | 290.00 | Effective lines of code | |
| EXEC_COMMENTS | 32.00 | Comments in executable code | |
| EXITS | 71.00 | Procedure exits | |
| FUNCTIONS | 13.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 82.95 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 63.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 1.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 8.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 6.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 26.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 5.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 0.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 1.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 5.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 1.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 0.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 1.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 1.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 9.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 0.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 0.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 2403.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 1.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 1.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 5.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 0.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 14.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 1.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 825.00 | Number of lines in the source file | |
| LINE_COMMENT | 444.00 | Number of line comments | |
| LOC | 327.00 | Lines of code | |
| LOGICAL_LINES | 171.00 | Number of statements | |
| LOOPS | 9.00 | Number of loops | |
| NEST_DEPTH | 5.00 | Maximum nesting depth | |
| OPERANDS | 788.00 | Number of operands | |
| OPERATORS | 1445.00 | Number of operators | |
| PARAMS | 19.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 2233.00 | Halstead program length | |
| PROGRAM_VOCAB | 299.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 44.00 | Number of return points from functions | |
| SIZE | 31071.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 247.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 52.00 | Number of unique operators | |
| WHITESPACE | 27.00 | Number of whitespace lines | |