DocumentElementParser.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.phpdt.internal.compiler |
 |
 |
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 |  |
| COMMENTS | Comment lines | |
| SIZE | Size of the file in bytes | |
| LINES | Number of lines in the source file | |
| COMMENT_DENSITY | Comment density | |
| JAVA0030 | JAVA0030 Private field not used | |
| DECL_COMMENTS | Comments in declarations | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| PROGRAM_VOLUME | Halstead program volume | |
| CYCLOMATIC | Cyclomatic complexity | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| EXEC_COMMENTS | Comments in executable code | |
| COMPARISONS | Number of comparison operators | |
| ELOC | Effective lines of code | |
| RETURNS | Number of return points from functions | |
| LOC | Lines of code | |
| BLOCKS | Number of blocks | |
| OPERATORS | Number of operators | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| LOGICAL_LINES | Number of statements | |
| PROGRAM_LENGTH | Halstead program length | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| OPERANDS | Number of operands | |
| JAVA0067 | JAVA0067 Array descriptor on identifier name | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| WHITESPACE | Number of whitespace lines | |
| LOOPS | Number of loops | |
| EXITS | Procedure exits | |
| FUNCTIONS | Number of function declarations | |
| DOC_COMMENT | Number of javadoc comment lines | |
| PARAMS | Number of formal parameter declarations | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| UNIQUE_OPERANDS | Number of unique operands | |
/***********************************************************************************************************************************
* 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.compiler;
import net.sourceforge.phpdt.core.compiler.IProblem;
import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
/*
* A document element parser extracts structural information from a piece of
* source, providing detailed source positions info.
*
* also see @IDocumentElementRequestor
*
* The structural investigation includes: - the package statement - import
* statements - top-level types: package member, member types (member types of
* member types...) - fields - methods
*
* Any (parsing) problem encountered is also provided.
*/
public class DocumentElementParser extends UnitParser {
IDocumentElementRequestor requestor;
private int localIntPtr;
private int lastFieldEndPosition;
private int lastFieldBodyEndPosition;
private int typeStartPosition;
private long selectorSourcePositions;
private int typeDims;
private int extendsDim;
private int declarationSourceStart;
/* int[] stack for storing javadoc positions */
int[][] intArrayStack;
int intArrayPtr;
// CompilerOptions options;
public DocumentElementParser(final IDocumentElementRequestor requestor,
IProblemFactory problemFactory, CompilerOptions options) {
super(new ProblemReporter(DefaultErrorHandlingPolicies
.exitAfterAllProblems(), options, problemFactory) {
public void record(IProblem problem, CompilationResult unitResult) {
requestor.acceptProblem(problem);
}
});
// false,
// options.sourceLevel >= CompilerOptions.JDK1_4);
this.requestor = requestor;
intArrayStack = new int[30][];
this.options = options;
}
/**
*
* INTERNAL USE-ONLY
*/
// protected void adjustInterfaceModifiers() {
// intStack[intPtr - 2] |= AccInterface;
// }
/*
* Will clear the comment stack when looking for a potential JavaDoc which
* might contain @deprecated.
*
* Additionally, before investigating for @deprecated, retrieve the
* positions of the JavaDoc comments so as to notify requestor with them.
*/
// public void checkAnnotation() {
//
// /* persisting javadoc positions */
// pushOnIntArrayStack(this.getJavaDocPositions());
// boolean deprecated = false;
// int lastAnnotationIndex = -1;
// int commentPtr = scanner.commentPtr;
//
// //since jdk1.2 look only in the last java doc comment...
// nextComment : for (lastAnnotationIndex = scanner.commentPtr;
// lastAnnotationIndex >= 0; lastAnnotationIndex--){
// //look for @deprecated into the first javadoc comment preceeding the
// declaration
// int commentSourceStart = scanner.commentStarts[lastAnnotationIndex];
// // javadoc only (non javadoc comment have negative end positions.)
// if (modifiersSourceStart != -1 && modifiersSourceStart <
// commentSourceStart) {
// continue nextComment;
// }
// if (scanner.commentStops[lastAnnotationIndex] < 0) {
// continue nextComment;
// }
// int commentSourceEnd = scanner.commentStops[lastAnnotationIndex] - 1;
// //stop is one over
// char[] comment = scanner.source;
//
// deprecated =
// checkDeprecation(
// commentSourceStart,
// commentSourceEnd,
// comment);
// break nextComment;
// }
// if (deprecated) {
// checkAndSetModifiers(AccDeprecated);
// }
// // modify the modifier source start to point at the first comment
// if (commentPtr >= 0) {
// declarationSourceStart = scanner.commentStarts[0];
// }
// }
/**
*
* INTERNAL USE-ONLY
*/
// protected void consumeClassBodyDeclaration() {
// // ClassBodyDeclaration ::= Diet Block
// //push an Initializer
// //optimize the push/pop
//
// super.consumeClassBodyDeclaration();
// Initializer initializer = (Initializer) astStack[astPtr];
// requestor.acceptInitializer(
// initializer.declarationSourceStart,
// initializer.declarationSourceEnd,
// intArrayStack[intArrayPtr--],
// 0,
// modifiersSourceStart,
// initializer.block.sourceStart,
// initializer.block.sourceEnd);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeClassDeclaration() {
// super.consumeClassDeclaration();
// // we know that we have a TypeDeclaration on the top of the astStack
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// return;
// }
// requestor.exitClass(endStatementPosition, // '}' is the end of the body
// ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeClassHeader() {
// //ClassHeader ::= $empty
// super.consumeClassHeader();
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// intArrayPtr--;
// return;
// }
// TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
// TypeReference[] superInterfaces = typeDecl.superInterfaces;
// char[][] interfaceNames = null;
// int[] interfaceNameStarts = null;
// int[] interfaceNameEnds = null;
// if (superInterfaces != null) {
// int superInterfacesLength = superInterfaces.length;
// interfaceNames = new char[superInterfacesLength][];
// interfaceNameStarts = new int[superInterfacesLength];
// interfaceNameEnds = new int[superInterfacesLength];
// for (int i = 0; i < superInterfacesLength; i++) {
// TypeReference superInterface = superInterfaces[i];
// interfaceNames[i] =
// CharOperation.concatWith(superInterface.getTypeName(), '.');
// interfaceNameStarts[i] = superInterface.sourceStart;
// interfaceNameEnds[i] = superInterface.sourceEnd;
// }
// }
// // flush the comments related to the class header
// scanner.commentPtr = -1;
// TypeReference superclass = typeDecl.superclass;
// if (superclass == null) {
// requestor.enterClass(
// typeDecl.declarationSourceStart,
// intArrayStack[intArrayPtr--],
// typeDecl.modifiers,
// typeDecl.modifiersSourceStart,
// typeStartPosition,
// typeDecl.name,
// typeDecl.sourceStart,
// typeDecl.sourceEnd,
// null,
// -1,
// -1,
// interfaceNames,
// interfaceNameStarts,
// interfaceNameEnds,
// scanner.currentPosition - 1);
// } else {
// requestor.enterClass(
// typeDecl.declarationSourceStart,
// intArrayStack[intArrayPtr--],
// typeDecl.modifiers,
// typeDecl.modifiersSourceStart,
// typeStartPosition,
// typeDecl.name,
// typeDecl.sourceStart,
// typeDecl.sourceEnd,
// CharOperation.concatWith(superclass.getTypeName(), '.'),
// superclass.sourceStart,
// superclass.sourceEnd,
// interfaceNames,
// interfaceNameStarts,
// interfaceNameEnds,
// scanner.currentPosition - 1);
//
// }
// }
// protected void consumeClassHeaderName() {
// // ClassHeaderName ::= Modifiersopt 'class' 'Identifier'
// TypeDeclaration typeDecl;
// if (nestedMethod[nestedType] == 0) {
// if (nestedType != 0) {
// typeDecl = new
// MemberTypeDeclaration(this.compilationUnit.compilationResult);
// } else {
// typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
// }
// } else {
// // Record that the block has a declaration for local types
// typeDecl = new
// LocalTypeDeclaration(this.compilationUnit.compilationResult);
// markEnclosingMemberWithLocalType();
// blockReal();
// }
//
// //highlight the name of the type
// long pos = identifierPositionStack[identifierPtr];
// typeDecl.sourceEnd = (int) pos;
// typeDecl.sourceStart = (int) (pos >>> 32);
// typeDecl.name = identifierStack[identifierPtr--];
// identifierLengthPtr--;
//
// //compute the declaration source too
// // 'class' and 'interface' push an int position
// typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
// intPtr--;
// int declarationSourceStart = intStack[intPtr--];
// typeDecl.modifiersSourceStart = intStack[intPtr--];
// typeDecl.modifiers = intStack[intPtr--];
// if (typeDecl.declarationSourceStart > declarationSourceStart) {
// typeDecl.declarationSourceStart = declarationSourceStart;
// }
// typeDecl.bodyStart = typeDecl.sourceEnd + 1;
// pushOnAstStack(typeDecl);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeCompilationUnit() {
// // CompilationUnit ::= EnterCompilationUnit PackageDeclarationopt
// ImportDeclarationsopt
// requestor.exitCompilationUnit(scanner.source.length - 1);
// }
/**
*
* INTERNAL USE-ONLY
*/
// protected void consumeConstructorDeclaration() {
// // ConstructorDeclaration ::= ConstructorHeader ConstructorBody
// super.consumeConstructorDeclaration();
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// return;
// }
// ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
// requestor.exitConstructor(endStatementPosition, cd.declarationSourceEnd);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeConstructorHeader() {
// // ConstructorHeader ::= ConstructorHeaderName MethodHeaderParameters
// MethodHeaderThrowsClauseopt
// super.consumeConstructorHeader();
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// intArrayPtr--;
// return;
// }
// ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
// Argument[] arguments = cd.arguments;
// char[][] argumentTypes = null;
// char[][] argumentNames = null;
// int[] argumentTypeStarts = null;
// int[] argumentTypeEnds = null;
// int[] argumentNameStarts = null;
// int[] argumentNameEnds = null;
// if (arguments != null) {
// int argumentLength = arguments.length;
// argumentTypes = new char[argumentLength][];
// argumentNames = new char[argumentLength][];
// argumentNameStarts = new int[argumentLength];
// argumentNameEnds = new int[argumentLength];
// argumentTypeStarts = new int[argumentLength];
// argumentTypeEnds = new int[argumentLength];
// for (int i = 0; i < argumentLength; i++) {
// Argument argument = arguments[i];
// TypeReference argumentType = argument.type;
// argumentTypes[i] = returnTypeName(argumentType);
// argumentNames[i] = argument.name;
// argumentNameStarts[i] = argument.sourceStart;
// argumentNameEnds[i] = argument.sourceEnd;
// argumentTypeStarts[i] = argumentType.sourceStart;
// argumentTypeEnds[i] = argumentType.sourceEnd;
// }
// }
// TypeReference[] thrownExceptions = cd.thrownExceptions;
// char[][] exceptionTypes = null;
// int[] exceptionTypeStarts = null;
// int[] exceptionTypeEnds = null;
// if (thrownExceptions != null) {
// int thrownExceptionLength = thrownExceptions.length;
// exceptionTypes = new char[thrownExceptionLength][];
// exceptionTypeStarts = new int[thrownExceptionLength];
// exceptionTypeEnds = new int[thrownExceptionLength];
// for (int i = 0; i < thrownExceptionLength; i++) {
// TypeReference exception = thrownExceptions[i];
// exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(),
// '.');
// exceptionTypeStarts[i] = exception.sourceStart;
// exceptionTypeEnds[i] = exception.sourceEnd;
// }
// }
// requestor
// .enterConstructor(
// cd.declarationSourceStart,
// intArrayStack[intArrayPtr--],
// cd.modifiers,
// cd.modifiersSourceStart,
// cd.selector,
// cd.sourceStart,
// (int) (selectorSourcePositions & 0xFFFFFFFFL),
// // retrieve the source end of the name
// argumentTypes,
// argumentTypeStarts,
// argumentTypeEnds,
// argumentNames,
// argumentNameStarts,
// argumentNameEnds,
// rParenPos,
// // right parenthesis
// exceptionTypes,
// exceptionTypeStarts,
// exceptionTypeEnds,
// scanner.currentPosition - 1);
// }
// protected void consumeConstructorHeaderName() {
// // ConstructorHeaderName ::= Modifiersopt 'Identifier' '('
// ConstructorDeclaration cd = new
// ConstructorDeclaration(this.compilationUnit.compilationResult);
//
// //name -- this is not really revelant but we do .....
// cd.selector = identifierStack[identifierPtr];
// selectorSourcePositions = identifierPositionStack[identifierPtr--];
// identifierLengthPtr--;
//
// //modifiers
// cd.declarationSourceStart = intStack[intPtr--];
// cd.modifiersSourceStart = intStack[intPtr--];
// cd.modifiers = intStack[intPtr--];
//
// //highlight starts at the selector starts
// cd.sourceStart = (int) (selectorSourcePositions >>> 32);
// pushOnAstStack(cd);
//
// cd.sourceEnd = lParenPos;
// cd.bodyStart = lParenPos + 1;
// }
// protected void consumeDefaultModifiers() {
// checkAnnotation(); // might update modifiers with AccDeprecated
// pushOnIntStack(modifiers); // modifiers
// pushOnIntStack(-1);
// pushOnIntStack(
// declarationSourceStart >= 0 ? declarationSourceStart :
// scanner.startPosition);
// resetModifiers();
// }
// protected void consumeDiet() {
// // Diet ::= $empty
// super.consumeDiet();
// /* persisting javadoc positions
// * Will be consume in consumeClassBodyDeclaration
// */
// pushOnIntArrayStack(this.getJavaDocPositions());
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeEnterCompilationUnit() {
// // EnterCompilationUnit ::= $empty
// requestor.enterCompilationUnit();
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeEnterVariable() {
// // EnterVariable ::= $empty
// boolean isLocalDeclaration = isLocalDeclaration();
// if (!isLocalDeclaration && (variablesCounter[nestedType] != 0)) {
// requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
// }
// char[] name = identifierStack[identifierPtr];
// long namePosition = identifierPositionStack[identifierPtr--];
// int extendedTypeDimension = intStack[intPtr--];
//
// AbstractVariableDeclaration declaration;
// if (nestedMethod[nestedType] != 0) {
// // create the local variable declarations
// declaration =
// new LocalDeclaration(null, name, (int) (namePosition >>> 32), (int)
// namePosition);
// } else {
// // create the field declaration
// declaration =
// new FieldDeclaration(null, name, (int) (namePosition >>> 32), (int)
// namePosition);
// }
// identifierLengthPtr--;
// TypeReference type;
// int variableIndex = variablesCounter[nestedType];
// int typeDim = 0;
// if (variableIndex == 0) {
// // first variable of the declaration (FieldDeclaration or
// LocalDeclaration)
// if (nestedMethod[nestedType] != 0) {
// // local declaration
// declaration.declarationSourceStart = intStack[intPtr--];
// declaration.modifiersSourceStart = intStack[intPtr--];
// declaration.modifiers = intStack[intPtr--];
// type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
// pushOnAstStack(type);
// } else {
// // field declaration
// type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
// pushOnAstStack(type);
// declaration.declarationSourceStart = intStack[intPtr--];
// declaration.modifiersSourceStart = intStack[intPtr--];
// declaration.modifiers = intStack[intPtr--];
// }
// } else {
// type = (TypeReference) astStack[astPtr - variableIndex];
// typeDim = type.dimensions();
// AbstractVariableDeclaration previousVariable =
// (AbstractVariableDeclaration) astStack[astPtr];
// declaration.declarationSourceStart =
// previousVariable.declarationSourceStart;
// declaration.modifiers = previousVariable.modifiers;
// declaration.modifiersSourceStart = previousVariable.modifiersSourceStart;
// }
//
// localIntPtr = intPtr;
//
// if (extendedTypeDimension == 0) {
// declaration.type = type;
// } else {
// int dimension = typeDim + extendedTypeDimension;
// //on the identifierLengthStack there is the information about the
// type....
// int baseType;
// if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
// //it was a baseType
// declaration.type = TypeReference.baseTypeReference(-baseType, dimension);
// declaration.type.sourceStart = type.sourceStart;
// declaration.type.sourceEnd = type.sourceEnd;
// } else {
// declaration.type = this.copyDims(type, dimension);
// }
// }
// variablesCounter[nestedType]++;
// nestedMethod[nestedType]++;
// pushOnAstStack(declaration);
//
// int[] javadocPositions = intArrayStack[intArrayPtr];
// if (!isLocalDeclaration) {
// requestor
// .enterField(
// declaration.declarationSourceStart,
// javadocPositions,
// declaration.modifiers,
// declaration.modifiersSourceStart,
// returnTypeName(declaration.type),
// type.sourceStart,
// type.sourceEnd,
// typeDims,
// name,
// (int) (namePosition >>> 32),
// (int) namePosition,
// extendedTypeDimension,
// extendedTypeDimension == 0 ? -1 : endPosition);
// }
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeExitVariableWithInitialization() {
// // ExitVariableWithInitialization ::= $empty
// // the scanner is located after the comma or the semi-colon.
// // we want to include the comma or the semi-colon
// super.consumeExitVariableWithInitialization();
// nestedMethod[nestedType]--;
// lastFieldEndPosition = scanner.currentPosition - 1;
// lastFieldBodyEndPosition = ((AbstractVariableDeclaration)
// astStack[astPtr]).initialization.sourceEnd;
// }
// protected void consumeExitVariableWithoutInitialization() {
// // ExitVariableWithoutInitialization ::= $empty
// // do nothing by default
// super.consumeExitVariableWithoutInitialization();
// nestedMethod[nestedType]--;
// lastFieldEndPosition = scanner.currentPosition - 1;
// lastFieldBodyEndPosition = scanner.startPosition - 1;
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeFieldDeclaration() {
// // See consumeLocalVariableDeclarationDefaultModifier() in case of
// change: duplicated code
// // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
// // the super.consumeFieldDeclaration will reinitialize the
// variableCounter[nestedType]
// int variableIndex = variablesCounter[nestedType];
// super.consumeFieldDeclaration();
// intArrayPtr--;
// if (isLocalDeclaration())
// return;
// if (variableIndex != 0) {
// requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
// }
// }
// protected void consumeFormalParameter() {
// // FormalParameter ::= Type VariableDeclaratorId ==> false
// // FormalParameter ::= Modifiers Type VariableDeclaratorId ==> true
// /*
// astStack :
// identifierStack : type identifier
// intStack : dim dim
// ==>
// astStack : Argument
// identifierStack :
// intStack :
// */
//
// identifierLengthPtr--;
// char[] name = identifierStack[identifierPtr];
// long namePositions = identifierPositionStack[identifierPtr--];
// TypeReference type = getTypeReference(intStack[intPtr--] +
// intStack[intPtr--]);
// intPtr -= 3;
// Argument arg =
// new Argument(
// name,
// namePositions,
// type,
// intStack[intPtr + 1]); // modifiers
// pushOnAstStack(arg);
// intArrayPtr--;
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeInterfaceDeclaration() {
// super.consumeInterfaceDeclaration();
// // we know that we have a TypeDeclaration on the top of the astStack
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// return;
// }
// requestor.exitInterface(endStatementPosition, // the '}' is the end of
// the body
// ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeInterfaceHeader() {
// //InterfaceHeader ::= $empty
// super.consumeInterfaceHeader();
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// intArrayPtr--;
// return;
// }
// TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
// TypeReference[] superInterfaces = typeDecl.superInterfaces;
// char[][] interfaceNames = null;
// int[] interfaceNameStarts = null;
// int[] interfacenameEnds = null;
// int superInterfacesLength = 0;
// if (superInterfaces != null) {
// superInterfacesLength = superInterfaces.length;
// interfaceNames = new char[superInterfacesLength][];
// interfaceNameStarts = new int[superInterfacesLength];
// interfacenameEnds = new int[superInterfacesLength];
// }
// if (superInterfaces != null) {
// for (int i = 0; i < superInterfacesLength; i++) {
// TypeReference superInterface = superInterfaces[i];
// interfaceNames[i] =
// CharOperation.concatWith(superInterface.getTypeName(), '.');
// interfaceNameStarts[i] = superInterface.sourceStart;
// interfacenameEnds[i] = superInterface.sourceEnd;
// }
// }
// // flush the comments related to the interface header
// scanner.commentPtr = -1;
// requestor.enterInterface(
// typeDecl.declarationSourceStart,
// intArrayStack[intArrayPtr--],
// typeDecl.modifiers,
// typeDecl.modifiersSourceStart,
// typeStartPosition,
// typeDecl.name,
// typeDecl.sourceStart,
// typeDecl.sourceEnd,
// interfaceNames,
// interfaceNameStarts,
// interfacenameEnds,
// scanner.currentPosition - 1);
// }
// protected void consumeInterfaceHeaderName() {
// // InterfaceHeaderName ::= Modifiersopt 'interface' 'Identifier'
// TypeDeclaration typeDecl;
// if (nestedMethod[nestedType] == 0) {
// if (nestedType != 0) {
// typeDecl = new
// MemberTypeDeclaration(this.compilationUnit.compilationResult);
// } else {
// typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
// }
// } else {
// // Record that the block has a declaration for local types
// typeDecl = new
// LocalTypeDeclaration(this.compilationUnit.compilationResult);
// markEnclosingMemberWithLocalType();
// blockReal();
// }
//
// //highlight the name of the type
// long pos = identifierPositionStack[identifierPtr];
// typeDecl.sourceEnd = (int) pos;
// typeDecl.sourceStart = (int) (pos >>> 32);
// typeDecl.name = identifierStack[identifierPtr--];
// identifierLengthPtr--;
//
// //compute the declaration source too
// // 'class' and 'interface' push an int position
// typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
// intPtr--;
// int declarationSourceStart = intStack[intPtr--];
// typeDecl.modifiersSourceStart = intStack[intPtr--];
// typeDecl.modifiers = intStack[intPtr--];
// if (typeDecl.declarationSourceStart > declarationSourceStart) {
// typeDecl.declarationSourceStart = declarationSourceStart;
// }
// typeDecl.bodyStart = typeDecl.sourceEnd + 1;
// pushOnAstStack(typeDecl);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeLocalVariableDeclaration() {
// // See consumeLocalVariableDeclarationDefaultModifier() in case of
// change: duplicated code
// // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
//
// super.consumeLocalVariableDeclaration();
// intArrayPtr--;
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeMethodDeclaration(boolean isNotAbstract) {
// // MethodDeclaration ::= MethodHeader MethodBody
// // AbstractMethodDeclaration ::= MethodHeader ';'
// super.consumeMethodDeclaration(isNotAbstract);
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// return;
// }
// MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
// requestor.exitMethod(endStatementPosition, md.declarationSourceEnd);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeMethodHeader() {
// // MethodHeader ::= MethodHeaderName MethodHeaderParameters
// MethodHeaderExtendedDims ThrowsClauseopt
// super.consumeMethodHeader();
// if (isLocalDeclaration()) {
// // we ignore the local variable declarations
// intArrayPtr--;
// return;
// }
// MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
//
// TypeReference returnType = md.returnType;
// char[] returnTypeName = returnTypeName(returnType);
// Argument[] arguments = md.arguments;
// char[][] argumentTypes = null;
// char[][] argumentNames = null;
// int[] argumentTypeStarts = null;
// int[] argumentTypeEnds = null;
// int[] argumentNameStarts = null;
// int[] argumentNameEnds = null;
// if (arguments != null) {
// int argumentLength = arguments.length;
// argumentTypes = new char[argumentLength][];
// argumentNames = new char[argumentLength][];
// argumentNameStarts = new int[argumentLength];
// argumentNameEnds = new int[argumentLength];
// argumentTypeStarts = new int[argumentLength];
// argumentTypeEnds = new int[argumentLength];
// for (int i = 0; i < argumentLength; i++) {
// Argument argument = arguments[i];
// TypeReference argumentType = argument.type;
// argumentTypes[i] = returnTypeName(argumentType);
// argumentNames[i] = argument.name;
// argumentNameStarts[i] = argument.sourceStart;
// argumentNameEnds[i] = argument.sourceEnd;
// argumentTypeStarts[i] = argumentType.sourceStart;
// argumentTypeEnds[i] = argumentType.sourceEnd;
// }
// }
// TypeReference[] thrownExceptions = md.thrownExceptions;
// char[][] exceptionTypes = null;
// int[] exceptionTypeStarts = null;
// int[] exceptionTypeEnds = null;
// if (thrownExceptions != null) {
// int thrownExceptionLength = thrownExceptions.length;
// exceptionTypeStarts = new int[thrownExceptionLength];
// exceptionTypeEnds = new int[thrownExceptionLength];
// exceptionTypes = new char[thrownExceptionLength][];
// for (int i = 0; i < thrownExceptionLength; i++) {
// TypeReference exception = thrownExceptions[i];
// exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(),
// '.');
// exceptionTypeStarts[i] = exception.sourceStart;
// exceptionTypeEnds[i] = exception.sourceEnd;
// }
// }
// requestor
// .enterMethod(
// md.declarationSourceStart,
// intArrayStack[intArrayPtr--],
// md.modifiers,
// md.modifiersSourceStart,
// returnTypeName,
// returnType.sourceStart,
// returnType.sourceEnd,
// typeDims,
// md.selector,
// md.sourceStart,
// (int) (selectorSourcePositions & 0xFFFFFFFFL),
// argumentTypes,
// argumentTypeStarts,
// argumentTypeEnds,
// argumentNames,
// argumentNameStarts,
// argumentNameEnds,
// rParenPos,
// extendsDim,
// extendsDim == 0 ? -1 : endPosition,
// exceptionTypes,
// exceptionTypeStarts,
// exceptionTypeEnds,
// scanner.currentPosition - 1);
// }
// protected void consumeMethodHeaderExtendedDims() {
// // MethodHeaderExtendedDims ::= Dimsopt
// // now we update the returnType of the method
// MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
// int extendedDims = intStack[intPtr--];
// extendsDim = extendedDims;
// if (extendedDims != 0) {
// TypeReference returnType = md.returnType;
// md.sourceEnd = endPosition;
// int dims = returnType.dimensions() + extendedDims;
// int baseType;
// if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
// //it was a baseType
// int sourceStart = returnType.sourceStart;
// int sourceEnd = returnType.sourceEnd;
// returnType = TypeReference.baseTypeReference(-baseType, dims);
// returnType.sourceStart = sourceStart;
// returnType.sourceEnd = sourceEnd;
// md.returnType = returnType;
// } else {
// md.returnType = this.copyDims(md.returnType, dims);
// }
// if (currentToken == TokenNameLBRACE) {
// md.bodyStart = endPosition + 1;
// }
// }
// }
// protected void consumeMethodHeaderName() {
// // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
// MethodDeclaration md = new
// MethodDeclaration(this.compilationUnit.compilationResult);
//
// //name
// md.selector = identifierStack[identifierPtr];
// selectorSourcePositions = identifierPositionStack[identifierPtr--];
// identifierLengthPtr--;
// //type
// md.returnType = getTypeReference(typeDims = intStack[intPtr--]);
// //modifiers
// md.declarationSourceStart = intStack[intPtr--];
// md.modifiersSourceStart = intStack[intPtr--];
// md.modifiers = intStack[intPtr--];
//
// //highlight starts at selector start
// md.sourceStart = (int) (selectorSourcePositions >>> 32);
// pushOnAstStack(md);
// md.bodyStart = scanner.currentPosition-1;
// }
// protected void consumeModifiers() {
// checkAnnotation(); // might update modifiers with AccDeprecated
// pushOnIntStack(modifiers); // modifiers
// pushOnIntStack(modifiersSourceStart);
// pushOnIntStack(
// declarationSourceStart >= 0 ? declarationSourceStart :
// modifiersSourceStart);
// resetModifiers();
// }
/**
*
* INTERNAL USE-ONLY
*/
// protected void consumePackageDeclarationName() {
// /* persisting javadoc positions */
// pushOnIntArrayStack(this.getJavaDocPositions());
//
// super.consumePackageDeclarationName();
// ImportReference importReference = compilationUnit.currentPackage;
//
// requestor.acceptPackage(
// importReference.declarationSourceStart,
// importReference.declarationSourceEnd,
// intArrayStack[intArrayPtr--],
// CharOperation.concatWith(importReference.getImportName(), '.'),
// importReference.sourceStart);
// }
// protected void consumePushModifiers() {
// checkAnnotation(); // might update modifiers with AccDeprecated
// pushOnIntStack(modifiers); // modifiers
// if (modifiersSourceStart < 0) {
// pushOnIntStack(-1);
// pushOnIntStack(
// declarationSourceStart >= 0 ? declarationSourceStart :
// scanner.startPosition);
// } else {
// pushOnIntStack(modifiersSourceStart);
// pushOnIntStack(
// declarationSourceStart >= 0 ? declarationSourceStart :
// modifiersSourceStart);
// }
// resetModifiers();
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeSingleTypeImportDeclarationName() {
// // SingleTypeImportDeclarationName ::= 'import' Name
//
// /* persisting javadoc positions */
// pushOnIntArrayStack(this.getJavaDocPositions());
//
// super.consumeSingleTypeImportDeclarationName();
// ImportReference importReference = (ImportReference) astStack[astPtr];
// requestor.acceptImport(
// importReference.declarationSourceStart,
// importReference.declarationSourceEnd,
// intArrayStack[intArrayPtr--],
// CharOperation.concatWith(importReference.getImportName(), '.'),
// importReference.sourceStart,
// false);
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeStaticInitializer() {
// // StaticInitializer ::= StaticOnly Block
// //push an Initializer
// //optimize the push/pop
// super.consumeStaticInitializer();
// Initializer initializer = (Initializer) astStack[astPtr];
// requestor.acceptInitializer(
// initializer.declarationSourceStart,
// initializer.declarationSourceEnd,
// intArrayStack[intArrayPtr--],
// AccStatic,
// intStack[intPtr--],
// initializer.block.sourceStart,
// initializer.declarationSourceEnd);
// }
// protected void consumeStaticOnly() {
// // StaticOnly ::= 'static'
// checkAnnotation(); // might update declaration source start
// pushOnIntStack(modifiersSourceStart);
// pushOnIntStack(
// declarationSourceStart >= 0 ? declarationSourceStart :
// modifiersSourceStart);
// jumpOverMethodBody();
// nestedMethod[nestedType]++;
// resetModifiers();
// }
// /**
// *
// * INTERNAL USE-ONLY
// */
// protected void consumeTypeImportOnDemandDeclarationName() {
// // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
//
// /* persisting javadoc positions */
// pushOnIntArrayStack(this.getJavaDocPositions());
//
// super.consumeTypeImportOnDemandDeclarationName();
// ImportReference importReference = (ImportReference) astStack[astPtr];
// requestor.acceptImport(
// importReference.declarationSourceStart,
// importReference.declarationSourceEnd,
// intArrayStack[intArrayPtr--],
// CharOperation.concatWith(importReference.getImportName(), '.'),
// importReference.sourceStart,
// true);
// }
public CompilationUnitDeclaration endParse(int act) {
if (scanner.recordLineSeparator) {
requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
}
return super.endParse(act);
}
/*
* Flush annotations defined prior to a given positions.
*
* Note: annotations are stacked in syntactical order
*
* Either answer given <position>, or the end position of a comment line
* immediately following the <position> (same line)
*
* e.g. void foo(){ } // end of method foo
*/
// public int flushAnnotationsDefinedPriorTo(int position) {
//
// return lastFieldEndPosition =
// super.flushAnnotationsDefinedPriorTo(position);
// }
// protected TypeReference getTypeReference(int dim) { /* build a Reference
// on a variable that may be qualified or not
// This variable is a type reference and dim will be its dimensions*/
//
// int length;
// TypeReference ref;
// if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
// // single variable reference
// if (dim == 0) {
// ref =
// new SingleTypeReference(
// identifierStack[identifierPtr],
// identifierPositionStack[identifierPtr--]);
// } else {
// ref =
// new ArrayTypeReference(
// identifierStack[identifierPtr],
// dim,
// identifierPositionStack[identifierPtr--]);
// ref.sourceEnd = endPosition;
// }
// } else {
// if (length < 0) { //flag for precompiled type reference on base types
// ref = TypeReference.baseTypeReference(-length, dim);
// ref.sourceStart = intStack[intPtr--];
// if (dim == 0) {
// ref.sourceEnd = intStack[intPtr--];
// } else {
// intPtr--;
// ref.sourceEnd = endPosition;
// }
// } else { //Qualified variable reference
// char[][] tokens = new char[length][];
// identifierPtr -= length;
// long[] positions = new long[length];
// System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
// System.arraycopy(
// identifierPositionStack,
// identifierPtr + 1,
// positions,
// 0,
// length);
// if (dim == 0) {
// ref = new QualifiedTypeReference(tokens, positions);
// } else {
// ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
// ref.sourceEnd = endPosition;
// }
// }
// };
// return ref;
// }
public void initialize() {
// positionning the parser for a new compilation unit
// avoiding stack reallocation and all that....
super.initialize(false);
intArrayPtr = -1;
}
/**
*
* INTERNAL USE-ONLY
*/
// private boolean isLocalDeclaration() {
// int nestedDepth = nestedType;
// while (nestedDepth >= 0) {
// if (nestedMethod[nestedDepth] != 0) {
// return true;
// }
// nestedDepth--;
// }
// return false;
// }
/*
* Investigate one entire unit.
*/
public void parseCompilationUnit(ICompilationUnit unit) {
char[] regionSource = unit.getContents();
try {
initialize();
goForCompilationUnit();
referenceContext = compilationUnit = new CompilationUnitDeclaration(
problemReporter(), new CompilationResult(unit, 0, 0, 10), // this.options.maxProblemsPerUnit),
regionSource.length);
scanner.resetTo(0, regionSource.length);
scanner.setSource(regionSource);
parse();
} catch (AbortCompilation ex) {
}
}
/*
* Investigate one constructor declaration.
*/
// public void parseConstructor(char[] regionSource) {
// try {
// initialize();
// goForClassBodyDeclarations();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0, 10),
// //this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
// }
/*
* Investigate one field declaration statement (might have multiple
* declarations in it).
*/
// public void parseField(char[] regionSource) {
// try {
// initialize();
// goForFieldDeclaration();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
// /*
// * Investigate one import statement declaration.
// */
// public void parseImport(char[] regionSource) {
// try {
// initialize();
// goForImportDeclaration();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
// /*
// * Investigate one initializer declaration.
// * regionSource need to content exactly an initializer declaration.
// * e.g: static { i = 4; }
// * { name = "test"; }
// */
// public void parseInitializer(char[] regionSource) {
// try {
// initialize();
// goForInitializer();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
// /*
// * Investigate one method declaration.
// */
// public void parseMethod(char[] regionSource) {
// try {
// initialize();
// goForGenericMethodDeclaration();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
// /*
// * Investigate one package statement declaration.
// */
// public void parsePackage(char[] regionSource) {
// try {
// initialize();
// goForPackageDeclaration();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
// /*
// * Investigate one type declaration, its fields, methods and member types.
// */
// public void parseType(char[] regionSource) {
// try {
// initialize();
// goForTypeDeclaration();
// referenceContext =
// compilationUnit =
// compilationUnit =
// new CompilationUnitDeclaration(
// problemReporter(),
// new CompilationResult(regionSource, 0, 0,
// this.options.maxProblemsPerUnit),
// regionSource.length);
// scanner.resetTo(0, regionSource.length);
// scanner.setSource(regionSource);
// parse();
// } catch (AbortCompilation ex) {
// }
//
// }
/**
* Returns this parser's problem reporter initialized with its reference
* context. Also it is assumed that a problem is going to be reported, so
* initializes the compilation result's line positions.
*/
public ProblemReporter problemReporter() {
problemReporter.referenceContext = referenceContext;
return problemReporter;
}
protected void pushOnIntArrayStack(int[] positions) {
try {
intArrayStack[++intArrayPtr] = positions;
} catch (IndexOutOfBoundsException e) {
// intPtr is correct
int oldStackLength = intArrayStack.length;
int oldStack[][] = intArrayStack;
intArrayStack = new int[oldStackLength + StackIncrement][];
System.arraycopy(oldStack, 0, intArrayStack, 0, oldStackLength);
intArrayStack[intArrayPtr] = positions;
}
}
// protected void resetModifiers() {
// super.resetModifiers();
// declarationSourceStart = -1;
// }
/*
* Syntax error was detected. Will attempt to perform some recovery action
* in order to resume to the regular parse loop.
*/
protected boolean resumeOnSyntaxError() {
return false;
}
/*
* Answer a char array representation of the type name formatted like: -
* type name + dimensions Example: "A[][]".toCharArray()
* "java.lang.String".toCharArray()
*/
// private char[] returnTypeName(TypeReference type) {
// int dimension = type.dimensions();
// if (dimension != 0) {
// char[] dimensionsArray = new char[dimension * 2];
// for (int i = 0; i < dimension; i++) {
// dimensionsArray[i*2] = '[';
// dimensionsArray[(i*2) + 1] = ']';
// }
// return CharOperation.concat(
// CharOperation.concatWith(type.getTypeName(), '.'),
// dimensionsArray);
// }
// return CharOperation.concatWith(type.getTypeName(), '.');
// }
// public String toString() {
// StringBuffer buffer = new StringBuffer();
// buffer.append("intArrayPtr = " + intArrayPtr + "\n"); //$NON-NLS-1$
// //$NON-NLS-2$
// buffer.append(super.toString());
// return buffer.toString();
// }
// /**
// * INTERNAL USE ONLY
// */
// protected TypeReference typeReference(
// int dim,
// int localIdentifierPtr,
// int localIdentifierLengthPtr) {
// /* build a Reference on a variable that may be qualified or not
// * This variable is a type reference and dim will be its dimensions.
// * We don't have any side effect on the stacks' pointers.
// */
//
// int length;
// TypeReference ref;
// if ((length = identifierLengthStack[localIdentifierLengthPtr]) == 1) {
// // single variable reference
// if (dim == 0) {
// ref =
// new SingleTypeReference(
// identifierStack[localIdentifierPtr],
// identifierPositionStack[localIdentifierPtr--]);
// } else {
// ref =
// new ArrayTypeReference(
// identifierStack[localIdentifierPtr],
// dim,
// identifierPositionStack[localIdentifierPtr--]);
// ref.sourceEnd = endPosition;
// }
// } else {
// if (length < 0) { //flag for precompiled type reference on base types
// ref = TypeReference.baseTypeReference(-length, dim);
// ref.sourceStart = intStack[localIntPtr--];
// if (dim == 0) {
// ref.sourceEnd = intStack[localIntPtr--];
// } else {
// localIntPtr--;
// ref.sourceEnd = endPosition;
// }
// } else { //Qualified variable reference
// char[][] tokens = new char[length][];
// localIdentifierPtr -= length;
// long[] positions = new long[length];
// System.arraycopy(identifierStack, localIdentifierPtr + 1, tokens, 0,
// length);
// System.arraycopy(
// identifierPositionStack,
// localIdentifierPtr + 1,
// positions,
// 0,
// length);
// if (dim == 0)
// ref = new QualifiedTypeReference(tokens, positions);
// else
// ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
// }
// };
// return ref;
// }
}
The table below shows all metrics for DocumentElementParser.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 13.00 | Number of blocks | |
| BLOCK_COMMENT | 49.00 | Number of block comment lines | |
| COMMENTS | 1258.00 | Comment lines | |
| COMMENT_DENSITY | 19.66 | Comment density | |
| COMPARISONS | 0.00 | Number of comparison operators | |
| CYCLOMATIC | 11.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 28.00 | Comments in declarations | |
| DOC_COMMENT | 32.00 | Number of javadoc comment lines | |
| ELOC | 64.00 | Effective lines of code | |
| EXEC_COMMENTS | 3.00 | Comments in executable code | |
| EXITS | 12.00 | Procedure exits | |
| FUNCTIONS | 8.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 34.82 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 16.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 | 0.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 | 8.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 0.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.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 | 1.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 | 1.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 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.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 | 0.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 | 1.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 1.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 | 1.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 2.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 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 0.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 5.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 1.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 | 1376.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 | 0.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 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 1.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 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.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 | 1355.00 | Number of lines in the source file | |
| LINE_COMMENT | 1177.00 | Number of line comments | |
| LOC | 75.00 | Lines of code | |
| LOGICAL_LINES | 44.00 | Number of statements | |
| LOOPS | 0.00 | Number of loops | |
| NEST_DEPTH | 2.00 | Maximum nesting depth | |
| OPERANDS | 170.00 | Number of operands | |
| OPERATORS | 319.00 | Number of operators | |
| PARAMS | 8.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 489.00 | Halstead program length | |
| PROGRAM_VOCAB | 117.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 8.00 | Number of return points from functions | |
| SIZE | 43436.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 83.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 34.00 | Number of unique operators | |
| WHITESPACE | 22.00 | Number of whitespace lines | |