/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.compiler;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
/**
* Part of the source element parser responsible for building the output. It gets notified of
* structural information as they are detected, relying on the requestor to assemble them together,
* based on the notifications it got.
*
* The structural investigation includes: - package statement - import statements - top-level types:
* package member, member types (member types of member types...) - fields - methods
*
* If reference information is requested, then all source constructs are investigated and type,
* field & method references are provided as well.
*
* Any (parsing) problem encountered is also provided.
*
* All positions are relative to the exact source fed to the parser.
*
* Elements which are complex are notified in two steps: - enter<Element> : once the element header
* has been identified - exit<Element> : once the element has been fully consumed
*
* other simpler elements (package, import) are read all at once: - accept<Element>
*/
public interface IDocumentElementRequestor {
/**
* @param declarationStart - a source position corresponding to the start of the package
* declaration
* @param declarationEnd - a source position corresponding to the end of the package declaration
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param name - the name of the package
* @param nameStartPosition - a source position corresponding to the first character of the name
* @param onDemand - a boolean equals to true if the import is an import on demand
*/
void acceptImport(
int declarationStart,
int declarationEnd,
int[] javaDocPositions,
char[] name,
int nameStartPosition,
boolean onDemand,
int modifiers);
/**
* @param declarationStart - a source position corresponding to the start of the package
* declaration
* @param declarationEnd - a source position corresponding to the end of the package declaration
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this initializer
* @param modifiersStart - a source position corresponding to the start of the textual
* modifiers, is < 0 if there are no textual modifiers
* @param bodyStart - the position of the '{'
* @param bodyEnd - the position of the '}'
*/
void acceptInitializer(
int declarationStart,
int declarationEnd,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
int bodyStart,
int bodyEnd);
/*
* Table of line separator position. This table is passed once at the end
* of the parse action, so as to allow computation of normalized ranges.
*
* A line separator might corresponds to several characters in the source,
*
*/
void acceptLineSeparatorPositions(int[] positions);
/**
* @param declarationStart - a source position corresponding to the start of the package
* declaration
* @param declarationEnd - a source position corresponding to the end of the package declaration
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param name - the name of the package
* @param nameStartPosition - a source position corresponding to the first character of the name
*/
void acceptPackage(
int declarationStart,
int declarationEnd,
int[] javaDocPositions,
char[] name,
int nameStartPosition);
/**
* @param problem - Used to report a problem while running the JDOM
*/
void acceptProblem(CategorizedProblem problem);
/**
* @param declarationStart - a source position corresponding to the start of this class.
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this class
* @param modifiersStart - a source position corresponding to the start of the textual
* modifiers, is < 0 if there are no textual modifiers
* @param classStart - a source position corresponding to the start of the keyword 'class'
* @param name - the name of the class
* @param nameStart - a source position corresponding to the start of the name
* @param nameEnd - a source position corresponding to the end of the name
* @param superclass - the name of the superclass
* @param superclassStart - a source position corresponding to the start of the superclass name
* @param superclassEnd - a source position corresponding to the end of the superclass name
* @param superinterfaces - the name of the superinterfaces
* @param superinterfaceStarts - an array of source positions corresponding to the start of
* their respective superinterface names
* @param superinterfaceEnds - an array of source positions corresponding to the end of their
* respective superinterface names
* @param bodyStart - a source position corresponding to the open bracket of the class body
*/
void enterClass(
int declarationStart,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
int classStart,
char[] name,
int nameStart,
int nameEnd,
char[] superclass,
int superclassStart,
int superclassEnd,
char[][] superinterfaces,
int[] superinterfaceStarts,
int[] superinterfaceEnds,
int bodyStart);
void enterCompilationUnit();
/**
* @param declarationStart - a source position corresponding to the first character of this
* constructor declaration
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this constructor converted to a flag
* @param modifiersStart - a source position corresponding to the first character of the textual
* modifiers
* @param name - the name of this constructor
* @param nameStart - a source position corresponding to the first character of the name
* @param nameEnd - a source position corresponding to the last character of the name
* @param parameterTypes - a list of parameter type names
* @param parameterTypeStarts - a list of source positions corresponding to the first character
* of each parameter type name
* @param parameterTypeEnds - a list of source positions corresponding to the last character of
* each parameter type name
* @param parameterNames - a list of the names of the parameters
* @param parametersEnd - a source position corresponding to the last character of the parameter
* list
* @param exceptionTypes - a list of the exception types
* @param exceptionTypeStarts - a list of source positions corresponding to the first character
* of the respective exception types
* @param exceptionTypeEnds - a list of source positions corresponding to the last character of
* the respective exception types
* @param bodyStart - a source position corresponding to the start of this constructor's body
*/
void enterConstructor(
int declarationStart,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
char[] name,
int nameStart,
int nameEnd,
char[][] parameterTypes,
int[] parameterTypeStarts,
int[] parameterTypeEnds,
char[][] parameterNames,
int[] parameterNameStarts,
int[] parameterNameEnds,
int parametersEnd,
char[][] exceptionTypes,
int[] exceptionTypeStarts,
int[] exceptionTypeEnds,
int bodyStart);
/**
* @param declarationStart - a source position corresponding to the first character of this
* field
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this field converted to a flag
* @param modifiersStart - a source position corresponding to the first character of the textual
* modifiers
* @param type - the name of the field type
* @param typeStart - a source position corresponding to the start of the fields type
* @param typeEnd - a source position corresponding to the end of the fields type
* @param typeDimensionCount - the array dimension indicated on the type (for example, 'int[]
* v')
* @param name - the name of this constructor
* @param nameStart - a source position corresponding to the first character of the name
* @param nameEnd - a source position corresponding to the last character of the name
* @param extendedTypeDimensionCount - the array dimension indicated on the variable, (for
* example, 'int v[]')
* @param extendedTypeDimensionEnd - a source position corresponding to the end of the extened
* type dimension. This position should be -1 in case there is no extended dimension
* for the type.
*/
void enterField(
int declarationStart,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
char[] type,
int typeStart,
int typeEnd,
int typeDimensionCount,
char[] name,
int nameStart,
int nameEnd,
int extendedTypeDimensionCount,
int extendedTypeDimensionEnd);
/**
* @param declarationStart - a source position corresponding to the start of this class.
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this class
* @param modifiersStart - a source position corresponding to the start of the textual
* modifiers, is < 0 if there are no textual modifiers
* @param interfaceStart - a source position corresponding to the start of the keyword
* 'interface'
* @param name - the name of the class
* @param nameStart - a source position corresponding to the start of the name
* @param nameEnd - a source position corresponding to the end of the name
* @param superinterfaces - the name of the superinterfaces
* @param superinterfaceStarts - an array of source positions corresponding to the start of
* their respective superinterface names
* @param superinterfaceEnds - an array of source positions corresponding to the end of their
* respective superinterface names
* @param bodyStart - a source position corresponding to the open bracket of the class body
*/
void enterInterface(
int declarationStart,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
int interfaceStart,
char[] name,
int nameStart,
int nameEnd,
char[][] superinterfaces,
int[] superinterfaceStarts,
int[] superinterfaceEnds,
int bodyStart);
/**
* @param declarationStart - a source position corresponding to the first character of this
* constructor declaration
* @param javaDocPositions - answer back an array of sourceStart/sourceEnd positions of the
* available JavaDoc comments. The array is a flattened structure: 2*n entries with
* consecutives start and end positions. If no JavaDoc is available, then null is
* answered instead of an empty array. e.g. { 10, 20, 25, 45 } --> javadoc1 from 10
* to 20, javadoc2 from 25 to 45 The array is equals to null if there are no javadoc
* comments
* @param modifiers - the modifiers for this constructor converted to a flag
* @param modifiersStart - a source position corresponding to the first character of the textual
* modifiers
* @param returnType - the name of the return type
* @param returnTypeStart - a source position corresponding to the first character of the return
* type
* @param returnTypeEnd - a source position corresponding to the last character of the return
* type
* @param returnTypeDimensionCount - the array dimension count as supplied on the return type
* (for example, 'public int[] foo() {}')
* @param name - the name of this constructor
* @param nameStart - a source position corresponding to the first character of the name
* @param nameEnd - a source position corresponding to the last character of the name
* @param parameterTypes - a list of parameter type names
* @param parameterTypeStarts - a list of source positions corresponding to the first character
* of each parameter type name
* @param parameterTypeEnds - a list of source positions corresponding to the last character of
* each parameter type name
* @param parameterNames - a list of the names of the parameters
* @param parametersEnd - a source position corresponding to the last character of the parameter
* list
* @param extendedReturnTypeDimensionCount - the array dimension count as supplied on the end of
* the parameter list (for example, 'public int foo()[] {}')
* @param extendedReturnTypeDimensionEnd - a source position corresponding to the last character
* of the extended return type dimension. This position should be -1 in case there is
* no extended dimension for the type.
* @param exceptionTypes - a list of the exception types
* @param exceptionTypeStarts - a list of source positions corresponding to the first character
* of the respective exception types
* @param exceptionTypeEnds - a list of source positions corresponding to the last character of
* the respective exception types
* @param bodyStart - a source position corresponding to the start of this method's body
*/
void enterMethod(
int declarationStart,
int[] javaDocPositions,
int modifiers,
int modifiersStart,
char[] returnType,
int returnTypeStart,
int returnTypeEnd,
int returnTypeDimensionCount,
char[] name,
int nameStart,
int nameEnd,
char[][] parameterTypes,
int[] parameterTypeStarts,
int[] parameterTypeEnds,
char[][] parameterNames,
int[] parameterNameStarts,
int[] parameterNameEnds,
int parametersEnd,
int extendedReturnTypeDimensionCount,
int extendedReturnTypeDimensionEnd,
char[][] exceptionTypes,
int[] exceptionTypeStarts,
int[] exceptionTypeEnds,
int bodyStart);
/**
* @param bodyEnd - a source position corresponding to the closing bracket of the class
* @param declarationEnd - a source position corresponding to the end of the class declaration.
* This can include whitespace and comments following the closing bracket.
*/
void exitClass(
int bodyEnd,
int declarationEnd);
/**
* @param declarationEnd - a source position corresponding to the end of the compilation unit
*/
void exitCompilationUnit(
int declarationEnd);
/**
* @param bodyEnd - a source position corresponding to the closing bracket of the method
* @param declarationEnd - a source position corresponding to the end of the method declaration.
* This can include whitespace and comments following the closing bracket.
*/
void exitConstructor(
int bodyEnd,
int declarationEnd);
/**
* @param bodyEnd - a source position corresponding to the end of the field.
* @param declarationEnd - a source position corresponding to the end of the field. This can
* include whitespace and comments following the semi-colon.
*/
void exitField(
int bodyEnd,
int declarationEnd);
/**
* @param bodyEnd - a source position corresponding to the closing bracket of the interface
* @param declarationEnd - a source position corresponding to the end of the interface
* declaration. This can include whitespace and comments following the closing
* bracket.
*/
void exitInterface(
int bodyEnd,
int declarationEnd);
/**
* @param bodyEnd - a source position corresponding to the closing bracket of the method
* @param declarationEnd - a source position corresponding to the end of the method declaration.
* This can include whitespace and comments following the closing bracket.
*/
void exitMethod(
int bodyEnd,
int declarationEnd);
}