Attachment #7020 for bug #27134




											currentPosition++;
									} //jump over the \\
								}
								recordComment(TokenNameCOMMENT_LINE);
								if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){
									throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);
								}

									return TokenNameCOMMENT_LINE;
								}
							} catch (IndexOutOfBoundsException e) {
								recordComment(TokenNameCOMMENT_LINE);
								if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition-1);
								if (tokenizeComments) {
									this.currentPosition--; // reset one character behind

											currentPosition++;
									} //jump over the \\
								}
								int token = isJavadoc ? TokenNameCOMMENT_JAVADOC : TokenNameCOMMENT_BLOCK;
								recordComment(token);
								if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){
									throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);
								}
								if (tokenizeComments) {
									/*
									if (isJavadoc)
										return TokenNameCOMMENT_JAVADOC;
									return TokenNameCOMMENT_BLOCK;
									*/
									return token;
								}
							} catch (IndexOutOfBoundsException e) {
								throw new InvalidInputException(UNTERMINATED_COMMENT);

Lines 23-28 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java (+1 lines)
23	public ImportReference currentPackage;	23	public ImportReference currentPackage;
24	public ImportReference[] imports;	24	public ImportReference[] imports;
25	public TypeDeclaration[] types;	25	public TypeDeclaration[] types;
		26	public int[][] comments;
26		27
27	public boolean ignoreFurtherInvestigation = false; // once pointless to investigate due to errors	28	public boolean ignoreFurtherInvestigation = false; // once pointless to investigate due to errors
28	public boolean ignoreMethodBodies = false;	29	public boolean ignoreMethodBodies = false;

Lines 529-535 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/JavadocParser.java (-1 / +1 lines)
529	if (iToken == 0) {	529	if (iToken == 0) {
530	return null;	530	return null;
531	}	531	}
532	if ((iToken % 2) == 0) { // dots must be followed by an identifier	532	if ((iToken % 2) == 0) { // cannot leave on a dot
533	throw new InvalidInputException();	533	throw new InvalidInputException();
534	}	534	}
535	break nextToken;	535	break nextToken;

Lines 23-28 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Scanner.java (-7 / +19 lines)
23	* The mirror implementation is using the backward compatible ITerminalSymbols constant	23	* The mirror implementation is using the backward compatible ITerminalSymbols constant
24	* definitions (stable with 2.0), whereas the internal implementation uses TerminalTokens	24	* definitions (stable with 2.0), whereas the internal implementation uses TerminalTokens
25	* which constant values reflect the latest parser generation state.	25	* which constant values reflect the latest parser generation state.
		26	* @see org.eclipse.jdt.core.compiler.ITerminalSymbols
		27	* @see org.eclipse.jdt.internal.core.util.PublicScanner
26	*/	28	*/
27	public class Scanner implements TerminalTokens {	29	public class Scanner implements TerminalTokens {
28		30
Lines 395-401 Link Here
395	}	397	}
396		398
397	public final char[] getRawTokenSourceEnd() {	399	public final char[] getRawTokenSourceEnd() {
398	int length = this.eofPosition - this.currentPosition;	400	int length = this.eofPosition - this.currentPosition - 1;
399	char[] sourceEnd = new char[length];	401	char[] sourceEnd = new char[length];
400	System.arraycopy(source, this.currentPosition, sourceEnd, 0, length);	402	System.arraycopy(source, this.currentPosition, sourceEnd, 0, length);
401	return sourceEnd;	403	return sourceEnd;
Lines 1312-1318 Link Here
1312	}	1314	}
1313	}	1315	}
1314	}	1316	}
1315	recordComment(false);	1317	recordComment(TokenNameCOMMENT_LINE);
1316	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);	1318	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);
1317	if ((currentCharacter == '\r') \|\| (currentCharacter == '\n')) {	1319	if ((currentCharacter == '\r') \|\| (currentCharacter == '\n')) {
1318	checkNonExternalizedString();	1320	checkNonExternalizedString();
Lines 1331-1337 Link Here
1331	}	1333	}
1332	} catch (IndexOutOfBoundsException e) {	1334	} catch (IndexOutOfBoundsException e) {
1333	currentPosition--;	1335	currentPosition--;
1334	recordComment(false);	1336	recordComment(TokenNameCOMMENT_LINE);
1335	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);	1337	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);
1336	if (tokenizeComments) {	1338	if (tokenizeComments) {
1337	return TokenNameCOMMENT_LINE;	1339	return TokenNameCOMMENT_LINE;
Lines 1386-1391 Link Here
1386	if (source[currentPosition] == '\\')	1388	if (source[currentPosition] == '\\')
1387	currentPosition++; //jump over the \\	1389	currentPosition++; //jump over the \\
1388	}	1390	}
		1391
		1392	// In case of /**/ set back to non-javadoc comment
		1393	if (currentCharacter == '/') {
		1394	isJavadoc = false;
		1395	}
		1396
1389	//loop until end of comment */	1397	//loop until end of comment */
1390	while ((currentCharacter != '/') \|\| (!star)) {	1398	while ((currentCharacter != '/') \|\| (!star)) {
1391	if ((currentCharacter == '\r') \|\| (currentCharacter == '\n')) {	1399	if ((currentCharacter == '\r') \|\| (currentCharacter == '\n')) {
Lines 1414-1425 Link Here
1414	currentPosition++;	1422	currentPosition++;
1415	} //jump over the \\	1423	} //jump over the \\
1416	}	1424	}
1417	recordComment(isJavadoc);	1425	int token = isJavadoc ? TokenNameCOMMENT_JAVADOC : TokenNameCOMMENT_BLOCK;
		1426	recordComment(token);
1418	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);	1427	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition);
1419	if (tokenizeComments) {	1428	if (tokenizeComments) {
		1429	/*
1420	if (isJavadoc)	1430	if (isJavadoc)
1421	return TokenNameCOMMENT_JAVADOC;	1431	return TokenNameCOMMENT_JAVADOC;
1422	return TokenNameCOMMENT_BLOCK;	1432	return TokenNameCOMMENT_BLOCK;
		1433	*/
		1434	return token;
1423	}	1435	}
1424	} catch (IndexOutOfBoundsException e) {	1436	} catch (IndexOutOfBoundsException e) {
1425	throw new InvalidInputException(UNTERMINATED_COMMENT);	1437	throw new InvalidInputException(UNTERMINATED_COMMENT);
Lines 2217-2233 Link Here
2217	}	2229	}
2218	}	2230	}
2219	}	2231	}
2220	public final void recordComment(boolean isJavadoc) {	2232	public void recordComment(int token) {
2221		2233
2222	// a new comment is recorded	2234	// a new comment is recorded
2223	try {	2235	try {
2224	this.commentStops[++this.commentPtr] = isJavadoc ? this.currentPosition : -this.currentPosition;	2236	this.commentStops[++this.commentPtr] = (token==TokenNameCOMMENT_JAVADOC) ? this.currentPosition : -this.currentPosition;
2225	} catch (IndexOutOfBoundsException e) {	2237	} catch (IndexOutOfBoundsException e) {
2226	int oldStackLength = this.commentStops.length;	2238	int oldStackLength = this.commentStops.length;
2227	int[] oldStack = this.commentStops;	2239	int[] oldStack = this.commentStops;
2228	this.commentStops = new int[oldStackLength + 30];	2240	this.commentStops = new int[oldStackLength + 30];
2229	System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);	2241	System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);
2230	this.commentStops[this.commentPtr] = isJavadoc ? this.currentPosition : -this.currentPosition;	2242	this.commentStops[this.commentPtr] = (token==TokenNameCOMMENT_JAVADOC) ? this.currentPosition : -this.currentPosition;
2231	//grows the positions buffers too	2243	//grows the positions buffers too
2232	int[] old = this.commentStarts;	2244	int[] old = this.commentStarts;
2233	this.commentStarts = new int[oldStackLength + 30];	2245	this.commentStarts = new int[oldStackLength + 30];




import java.util.Map;

import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.*;
import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.NameLookup;

/**
 * Umbrella owner and abstract syntax tree node factory.

 * subclassed.
 * </p>
 * 
 * @see #parseCompilationUnit(char[]) and other similar methods
 * @see ASTNode
 * @since 2.0
 */

	 * Java Scanner used to validate preconditions for the creation of specific nodes
	 * like CharacterLiteral, NumberLiteral, StringLiteral or SimpleName.
	 */
	DOMScanner scanner;

	/**
	 * Flags to set options while DOM parsing.
	 */
	public final static int ResolveBindings = 0x00000001;
	
	/**
	 * 
	 */
	public final static int InsideComments  = 0x00000002;
	
	/**
	 * Creates a new, empty abstract syntax tree using default options.
	 * 
	 * @see JavaCore#getDefaultOptions()

	 * @see JavaCore#getDefaultOptions()
	 */
	public AST(Map options) {
		this.scanner = new DOMScanner(
			true /*comment*/, 
			true /*whitespace*/, 
			false /*nls*/, 

	 *    this AST
	 */
	public long modificationCount() {
		return this.modCount;
	}

	/**

	 */
	void modifying() {
		// increase the modification count
		this.modCount++;	
	}

	/**

	 * @return the compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @deprecated Use #parseCompilationUnit(CompilationUnit, int)
	 */
	public static CompilationUnit parseCompilationUnit(
		ICompilationUnit unit,
		boolean resolveBindings) {

		return parseCompilationUnit(unit, resolveBindings?ResolveBindings:0);
	}

	/**
	 * Parses the source string of the given Java model compilation unit element
	 * and creates and returns a corresponding abstract syntax tree. The source 
	 * string is obtained from the Java model element using
	 * <code>ICompilationUnit.getSource()</code>.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>
	 * </p>
	 * 
	 * @param unit the Java model compilation unit whose source code is to be parsed
	 * @param options an integer which sets parse options. 
	 * @return the compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 */
	public static CompilationUnit parseCompilationUnit(ICompilationUnit unit, int options) {
		ICompilationUnit unit,
		boolean resolveBindings) {

		return parseCompilationUnit(unit, options, DefaultWorkingCopyOwner.PRIMARY);
	}
	
	/**

	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @see WorkingCopyOwner
	 * @deprecated Use #parseCompilationUnit(CompilationUnit, int, WorkingCopyOwner)
	 * @since 3.0
	 * TODO (frederic) remove for 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
			ICompilationUnit unit,
			boolean resolveBindings,
			WorkingCopyOwner owner) {
		return parseCompilationUnit(unit, resolveBindings?ResolveBindings:0, owner);
	}

	/**
	 * Parses the source string of the given Java model compilation unit element
	 * and creates and returns a corresponding abstract syntax tree. The source 
	 * string is obtained from the Java model element using
	 * <code>ICompilationUnit.getSource()</code>.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>
	 * </p>
	 * <p>
	 * When bindings are created, instead of considering compilation units on disk only
	 * one can supply a <code>WorkingCopyOwner</code>. Working copies owned 
	 * by this owner take precedence over the underlying compilation units when looking
	 * up names and drawing the connections.
	 * </p>
	 * 
	 * @param unit the Java model compilation unit whose source code is to be parsed
	 * @param options an integer which sets parse options. 
	 * @param owner the owner of working copies that take precedence over underlying 
	 *   compilation units
	 * @return the compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @see WorkingCopyOwner
	 * @since 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
		ICompilationUnit unit,
		int options,
		WorkingCopyOwner owner) {
				
		if (unit == null) {

			throw new IllegalArgumentException();
		}

		if ((options & ResolveBindings) == ResolveBindings) {
			NameLookup lookup = null;
			CompilationUnitDeclaration compilationUnitDeclaration = null;
			try {

				
				// parse and resolve
				compilationUnitDeclaration = CompilationUnitResolver.resolve(unit, false/*don't cleanup*/, source);
				ASTConverter converter = new ASTConverter(unit.getJavaProject().getOptions(true), options);
				AST ast = new AST();
				BindingResolver resolver = new DefaultBindingResolver(compilationUnitDeclaration.scope);
				ast.setBindingResolver(resolver);

				}
			}
		} else {
			return parseCompilationUnit(source, options);
		}
	}


	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 2.1
	 * @deprecated Use #parseCompilationUnit(IClassFile, int)
	 */
	public static CompilationUnit parseCompilationUnit(
		IClassFile classFile,
		boolean resolveBindings) {
			
		return parseCompilationUnit(classFile, resolveBindings?ResolveBindings:0);
	}

	/**
	 * Parses the source string corresponding to the given Java class file
	 * element and creates and returns a corresponding abstract syntax tree.
	 * The source string is obtained from the Java model element using
	 * <code>IClassFile.getSource()</code>, and is only available for a class
	 * files with attached source.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>
	 * </p>
	 * 
	 * @param classFile the Java model compilation unit whose source code is to be parsed
	 * @param options an integer which sets parse options. 
	 * @return the compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 */
	public static CompilationUnit parseCompilationUnit(IClassFile classFile, int options) {
		
		return parseCompilationUnit(classFile, options, DefaultWorkingCopyOwner.PRIMARY);
	}

	/**
	 * Parses the source string corresponding to the given Java class file
	 * element and creates and returns a corresponding abstract syntax tree.

	 * @see ASTNode#getLength()
	 * @see WorkingCopyOwner
	 * @since 3.0
	 * @deprecated Use #parseCompilationUnit(IClassFile, int, WorkingCopyOwner)
	 * TODO (frederic) remove for 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
			IClassFile classFile,
			boolean resolveBindings,
			WorkingCopyOwner owner) {
		return parseCompilationUnit(classFile, resolveBindings?ResolveBindings:0, owner);
	}

	/**
	 * Parses the source string corresponding to the given Java class file
	 * element and creates and returns a corresponding abstract syntax tree.
	 * The source string is obtained from the Java model element using
	 * <code>IClassFile.getSource()</code>, and is only available for a class
	 * files with attached source.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>
	 * </p>
	 * <p>
	 * When bindings are created, instead of considering compilation units on disk only
	 * one can supply a <code>WorkingCopyOwner</code>. Working copies owned 
	 * by this owner take precedence over the underlying compilation units when looking
	 * up names and drawing the connections.
	 * </p>
	 * 
	 * @param classFile the Java model compilation unit whose source code is to be parsed
	 * @param options an integer which sets parse options. 
	 * @param owner the owner of working copies that take precedence over underlying 
	 *   compilation units
	 * @return the compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @see WorkingCopyOwner
	 * @since 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
		IClassFile classFile,
		int options,
		WorkingCopyOwner owner) {
			
		if (classFile == null) {

			throw new IllegalArgumentException();
		}
		source = sourceString.toCharArray();
		if ((options & ResolveBindings) == 0) {
			return AST.parseCompilationUnit(source);
		}
		StringBuffer buffer = new StringBuffer(SuffixConstants.SUFFIX_STRING_java);

					buffer.toString(),
					project,
					false/*don't cleanup*/);
			ASTConverter converter = new ASTConverter(project.getOptions(true), options);
			AST ast = new AST();
			BindingResolver resolver = new DefaultBindingResolver(compilationUnitDeclaration.scope);
			ast.setBindingResolver(resolver);
			converter.setAST(ast);
		
			CompilationUnit cu = converter.convert(compilationUnitDeclaration, source);
			cu.setLineEndTable(compilationUnitDeclaration.compilationResult.lineSeparatorPositions);
			resolver.storeModificationCount(ast.modificationCount());
			return cu;
		} catch(JavaModelException e) {
			/* if a JavaModelException is thrown trying to retrieve the name environment
			 * then we simply do a parsing without creating bindings.
			 * Therefore all binding resolution will return null.
			 */
			return parseCompilationUnit(source);			
		} finally {
			if (compilationUnitDeclaration != null) {
				compilationUnitDeclaration.cleanUp();
			}
			if (lookup != null) {
				lookup.setUnitsToLookInside(null);
			}
		}
	}
	
	/**
	 * Parses the given string as the hypothetical contents of the named
	 * compilation unit and creates and returns a corresponding abstract syntax tree.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the given source string (the given source string itself
	 * is not remembered with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * If the given project is not <code>null</code>, the various names
	 * and types appearing in the compilation unit can be resolved to "bindings"
	 * by calling the <code>resolveBinding</code> methods. These bindings 
	 * draw connections between the different parts of a program, and 
	 * generally afford a more powerful vantage point for clients who wish to
	 * analyze a program's structure more deeply. These bindings come at a 
	 * considerable cost in both time and space, however, and should not be
	 * requested frivolously. The additional space is not reclaimed until the 
	 * AST, all its nodes, and all its bindings become garbage. So it is very
	 * important to not retain any of these objects longer than absolutely
	 * necessary. Bindings are resolved at the time the AST is created. Subsequent
	 * modifications to the AST do not affect the bindings returned by
	 * <code>resolveBinding</code> methods in any way; these methods return the
	 * same binding as before the AST was modified (including modifications
	 * that rearrange subtrees by reparenting nodes).
	 * If the given project is <code>null</code>, the analysis 
	 * does not go beyond parsing and building the tree, and all 
	 * <code>resolveBinding</code> methods return <code>null</code> from the 
	 * outset.
	 * </p>
	 * <p>
	 * The name of the compilation unit must be supplied for resolving bindings.
	 * This name should include the ".java" suffix and match the name of the main
	 * (public) class or interface declared in the source. For example, if the source
	 * declares a public class named "Foo", the name of the compilation should be
	 * "Foo.java". For the purposes of resolving bindings, types declared in the
	 * source string hide types by the same name available through the classpath
	 * of the given project.
	 * </p>
	 * 
	 * @param source the string to be parsed as a Java compilation unit
	 * @param unitName the name of the compilation unit that would contain the source
	 *    string, or <code>null</code> if <code>javaProject</code> is also <code>null</code>
	 * @param project the Java project used to resolve names, or 
	 *    <code>null</code> if bindings are not resolved
	 * @return the compilation unit node
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @deprecated Use #parseCompilationUnit(char(], int, String, JavaProject)
	 */
	public static CompilationUnit parseCompilationUnit(
			char[] source,
			String unitName,
			IJavaProject project) {
		
		return parseCompilationUnit(source, unitName, project, DefaultWorkingCopyOwner.PRIMARY);
	}
	
	/**
	 * Parses the given string as the hypothetical contents of the named
	 * compilation unit and creates and returns a corresponding abstract syntax tree.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the given source string (the given source string itself
	 * is not remembered with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * If the given project is not <code>null</code>, the various names
	 * and types appearing in the compilation unit can be resolved to "bindings"
	 * by calling the <code>resolveBinding</code> methods. These bindings 
	 * draw connections between the different parts of a program, and 
	 * generally afford a more powerful vantage point for clients who wish to
	 * analyze a program's structure more deeply. These bindings come at a 
	 * considerable cost in both time and space, however, and should not be
	 * requested frivolously. The additional space is not reclaimed until the 
	 * AST, all its nodes, and all its bindings become garbage. So it is very
	 * important to not retain any of these objects longer than absolutely
	 * necessary. Bindings are resolved at the time the AST is created. Subsequent
	 * modifications to the AST do not affect the bindings returned by
	 * <code>resolveBinding</code> methods in any way; these methods return the
	 * same binding as before the AST was modified (including modifications
	 * that rearrange subtrees by reparenting nodes).
	 * If the given project is <code>null</code>, the analysis 
	 * does not go beyond parsing and building the tree, and all 
	 * <code>resolveBinding</code> methods return <code>null</code> from the 
	 * outset.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>.
	 * Note that if the given project is <code>null</code>, bindings won't be
	 * resolved even if resolve binding option is set.
	 * </p>
	 * <p>
	 * The name of the compilation unit must be supplied for resolving bindings.
	 * This name should include the ".java" suffix and match the name of the main
	 * (public) class or interface declared in the source. For example, if the source
	 * declares a public class named "Foo", the name of the compilation should be
	 * "Foo.java". For the purposes of resolving bindings, types declared in the
	 * source string hide types by the same name available through the classpath
	 * of the given project.
	 * </p>
	 * 
	 * @param source the string to be parsed as a Java compilation unit
	 * @param options an integer which sets parse options. 
	 * @param unitName the name of the compilation unit that would contain the source
	 *    string, or <code>null</code> if <code>javaProject</code> is also <code>null</code>
	 * @param project the Java project used to resolve names, or 
	 *    <code>null</code> if bindings are not resolved
	 * @return the compilation unit node
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
			char[] source,
			int options,
			String unitName,
			IJavaProject project) {
		
		return parseCompilationUnit(source, options, unitName, project, DefaultWorkingCopyOwner.PRIMARY);
	}

	/**
	 * Parses the given string as the hypothetical contents of the named
	 * compilation unit and creates and returns a corresponding abstract syntax tree.

	 * outset.
	 * </p>
	 * <p>
	 * When bindings are created, instead of considering compilation units on disk only
	 * one can supply a <code>WorkingCopyOwner</code>. Working copies owned 
	 * by this owner take precedence over the underlying compilation units when looking
	 * up names and drawing the connections.
	 * </p>
	 * <p>
	 * The name of the compilation unit must be supplied for resolving bindings.
	 * This name should include the ".java" suffix and match the name of the main
	 * (public) class or interface declared in the source. For example, if the source

	 *    string, or <code>null</code> if <code>javaProject</code> is also <code>null</code>
	 * @param project the Java project used to resolve names, or 
	 *    <code>null</code> if bindings are not resolved
	 * @param owner the owner of working copies that take precedence over underlying 
	 *   compilation units
	 * @return the compilation unit node
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @see WorkingCopyOwner
	 * @since 3.0
	 * @deprecated Use #parseCompilationUnit(char(], int, String, JavaProject, WorkingCopyOwner)
	 * TODO (frederic) remove for 3.0
	 */
	public static CompilationUnit parseCompilationUnit(
			char[] source,
			String unitName,
			IJavaProject project,
			WorkingCopyOwner owner) {
		return parseCompilationUnit(source, ResolveBindings, unitName, project, owner);
	}

	/**
	 * Parses the given string as the hypothetical contents of the named
	 * compilation unit and creates and returns a corresponding abstract syntax tree.

	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the compilation unit:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>.
	 * Note that if the given project is <code>null</code>, bindings won't be
	 * resolved even if resolve binding option is set.
	 * </p>
	 * <p>
	 * When bindings are created, instead of considering compilation units on disk only

	 * </p>
	 * 
	 * @param source the string to be parsed as a Java compilation unit
	 * @param options an integer which sets parse options. 
	 * @param unitName the name of the compilation unit that would contain the source
	 *    string, or <code>null</code> if <code>javaProject</code> is also <code>null</code>
	 * @param project the Java project used to resolve names, or 

	 */
	public static CompilationUnit parseCompilationUnit(
		char[] source,
		int options,
		String unitName,
		IJavaProject project,
		WorkingCopyOwner owner) {

					unitName,
					project,
					false/*don't cleanup*/);
			ASTConverter converter = new ASTConverter(project.getOptions(true), (ResolveBindings | options));
			AST ast = new AST();
			BindingResolver resolver = new DefaultBindingResolver(compilationUnitDeclaration.scope);
			ast.setBindingResolver(resolver);

			}
		}
	}

	/**
	 * Parses the given string as a Java compilation unit and creates and 
	 * returns a corresponding abstract syntax tree.

	 * @see ASTNode#getLength()
	 */
	public static CompilationUnit parseCompilationUnit(char[] source) {
		return parseCompilationUnit(source, 0); // No bindings, no comments
	}

	/**
	 * Parses the given string as a Java compilation unit and creates and 
	 * returns a corresponding abstract syntax tree.
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the given source string (the given source string itself
	 * is not remembered with the AST). 
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included. There are a handful of exceptions
	 * (including compilation units and the various body declarations); the
	 * specification for these node type spells out the details.
	 * Source ranges nest properly: the source range for a child is always
	 * within the source range of its parent, and the source ranges of sibling
	 * nodes never overlap.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the source:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>.
	 * </p>
	 * 
	 * @param source the string to be parsed as a Java compilation unit
	 * @param options an integer which sets parse options. 
	 * @return CompilationUnit
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 */
	public static CompilationUnit parseCompilationUnit(char[] source, int options) {
		if (source == null) {
			throw new IllegalArgumentException();
		}
		CompilationUnitDeclaration compilationUnitDeclaration = 
			CompilationUnitResolver.parse(source, JavaCore.getOptions()); // no better custom options

		ASTConverter converter = new ASTConverter(JavaCore.getOptions(), options);
		AST ast = new AST();
		ast.setBindingResolver(new BindingResolver());
		converter.setAST(ast);

	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 * @deprecated Use parsePartialCompilationUnit(ICompilationUnit, int, int)
	 * TODO (frederic) remove for 3.0
	 */
	public static CompilationUnit parsePartialCompilationUnit(
		ICompilationUnit unit,
		int position,
		boolean resolveBindings) {
			return parsePartialCompilationUnit(
				unit,
				position,
				resolveBindings?ResolveBindings:0);
	}

	/**
	 * Parses the source string of the given Java model compilation unit element
	 * and creates and returns an abridged abstract syntax tree. This method
	 * differs from
	 * {@link #parseCompilationUnit(ICompilationUnit,boolean)
	 * parseCompilationUnit(ICompilationUnit,boolean)} only in 
	 * that the resulting AST does not have nodes for the entire compilation
	 * unit. Rather, the AST is only fleshed out for the node that include
	 * the given source position. This kind of limited AST is sufficient for
	 * certain purposes but totally unsuitable for others. In places where it
	 * can be used, the limited AST offers the advantage of being smaller and
	 * faster to faster to construct.
	 * </p>
	 * <p>
	 * The resulting AST always includes nodes for all of the compilation unit's
	 * package, import, and top-level type declarations. It also always contains
	 * nodes for all the body declarations for those top-level types, as well
	 * as body declarations for any member types. However, some of the body
	 * declarations may be abridged. In particular, the statements ordinarily
	 * found in the body of a method declaration node will not be included
	 * (the block will be empty) unless the source position falls somewhere
	 * within the source range of that method declaration node. The same is true
	 * for initializer declarations; the statements ordinarily found in the body
	 * of initializer node will not be included unless the source position falls
	 * somewhere within the source range of that initializer declaration node.
	 * Field declarations are never abridged. Note that the AST for the body of
	 * that one unabridged method (or initializer) is 100% complete; it has all
	 * its statements, including any local or anonymous type declarations 
	 * embedded within them. When the the given position is not located within
	 * the source range of any body declaration of a top-level type, the AST
	 * returned is a skeleton that includes nodes for all and only the major
	 * declarations; this kind of AST is still quite useful because it contains
	 * all the constructs that introduce names visible to the world outside the
	 * compilation unit.
	 * </p>
	 * <p>
	 * In all other respects, this method works the same as
	 * {@link #parseCompilationUnit(ICompilationUnit,boolean)
	 * parseCompilationUnit(ICompilationUnit,boolean)}.
	 * The source string is obtained from the Java model element using
	 * <code>ICompilationUnit.getSource()</code>.
	 * </p>
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the source:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>.
	 * </p>
	 * 
	 * @param unit the Java model compilation unit whose source code is to be parsed
	 * @param position a position into the corresponding body declaration
	 * @param options an integer which sets parse options. 
	 * @return the abridged compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 */
	public static CompilationUnit parsePartialCompilationUnit(
			ICompilationUnit unit,
			int position,
			int options) {
		return parsePartialCompilationUnit(unit, position, options, DefaultWorkingCopyOwner.PRIMARY);
	}

	/**
	 * Parses the source string of the given Java model compilation unit element
	 * and creates and returns an abridged abstract syntax tree. This method

	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 * @deprecated Use parsePartialCompilationUnit(ICompilationUnit, int, int, WorkingCopyOwner)
	 * TODO (frederic) remove for 3.0
	 */
	public static CompilationUnit parsePartialCompilationUnit(
			ICompilationUnit unit,
			int position,
			boolean resolveBindings,
			WorkingCopyOwner owner) {
		return parsePartialCompilationUnit(
			unit,
			position,
			resolveBindings ? ResolveBindings : 0,
			DefaultWorkingCopyOwner.PRIMARY);
	}	
	/**
	 * Parses the source string of the given Java model compilation unit element
	 * and creates and returns an abridged abstract syntax tree. This method
	 * differs from
	 * {@link #parseCompilationUnit(ICompilationUnit,boolean,WorkingCopyOwner)
	 * parseCompilationUnit(ICompilationUnit,boolean,WorkingCopyOwner)} only in 
	 * that the resulting AST does not have nodes for the entire compilation
	 * unit. Rather, the AST is only fleshed out for the node that include
	 * the given source position. This kind of limited AST is sufficient for
	 * certain purposes but totally unsuitable for others. In places where it
	 * can be used, the limited AST offers the advantage of being smaller and
	 * faster to faster to construct.
	 * </p>
	 * <p>
	 * The resulting AST always includes nodes for all of the compilation unit's
	 * package, import, and top-level type declarations. It also always contains
	 * nodes for all the body declarations for those top-level types, as well
	 * as body declarations for any member types. However, some of the body
	 * declarations may be abridged. In particular, the statements ordinarily
	 * found in the body of a method declaration node will not be included
	 * (the block will be empty) unless the source position falls somewhere
	 * within the source range of that method declaration node. The same is true
	 * for initializer declarations; the statements ordinarily found in the body
	 * of initializer node will not be included unless the source position falls
	 * somewhere within the source range of that initializer declaration node.
	 * Field declarations are never abridged. Note that the AST for the body of
	 * that one unabridged method (or initializer) is 100% complete; it has all
	 * its statements, including any local or anonymous type declarations 
	 * embedded within them. When the the given position is not located within
	 * the source range of any body declaration of a top-level type, the AST
	 * returned is a skeleton that includes nodes for all and only the major
	 * declarations; this kind of AST is still quite useful because it contains
	 * all the constructs that introduce names visible to the world outside the
	 * compilation unit.
	 * </p>
	 * <p>
	 * In all other respects, this method works the same as
	 * {@link #parseCompilationUnit(ICompilationUnit,boolean,WorkingCopyOwner)
	 * parseCompilationUnit(ICompilationUnit,boolean,WorkingCopyOwner)}.
	 * The source string is obtained from the Java model element using
	 * <code>ICompilationUnit.getSource()</code>.
	 * </p>
	 * <p>
	 * The returned compilation unit node is the root node of a new AST.
	 * Each node in the subtree carries source range(s) information relating back
	 * to positions in the source string (the source string is not remembered
	 * with the AST).
	 * The source range usually begins at the first character of the first token 
	 * corresponding to the node; leading whitespace and comments are <b>not</b>
	 * included. The source range usually extends through the last character of
	 * the last token corresponding to the node; trailing whitespace and
	 * comments are <b>not</b> included.
	 * If a syntax error is detected while parsing, the relevant node(s) of the
	 * tree will be flagged as <code>MALFORMED</code>.
	 * </p>
	 * <p>
	 * Several options are available while parsing the source:
	 *<ul>
	 *<li>- <code>ResolveBindings</code>
	 * 		When this flag is set, the various names and types appearing in
	 * 		the compilation unit can be resolved to "bindings" by calling
	 * 		the <code>resolveBinding</code> methods. These bindings draw
	 * 		connections between the different parts of a program, and generally
	 * 		afford a more powerful vantage point for clients who wish to
	 * 		analyze a program's structure more deeply. These bindings come
	 * 		at a considerable cost in both time and space, however, and should
	 * 		not be requested frivolously. The additional space is not reclaimed
	 * 		until the AST, all its nodes, and all its bindings become garbage.
	 * 		So it is very important to not retain any of these objects longer
	 * 		than absolutely necessary. Bindings are resolved at the time the
	 * 		AST is created. Subsequent modifications to the AST do not affect
	 * 		the bindings returned by <code>resolveBinding</code> methods in
	 * 		any way; these methods return the same binding as before the AST
	 * 		was modified (including modifications that rearrange subtrees by
	 * 		reparenting nodes).
	 * 		When this flag is not set, the analysis does not go beyond parsing
	 * 		and building the tree, and all <code>resolveBinding</code> methods
	 * 		return <code>null</code> from the  outset.
	 * </li>
	 * <li>- <code>InsideComments</code>
	 * 		When this flag is set, all comments of the compilation unit are stored
	 * 		and parsed to identify possible Javadoc tags.
	 * 		Comments are stored in a list <code>comments</code> of <code>Comment</code>.
	 * 		There are three different kind of comments: line, block and javadoc.
	 * 		Javadoc comments are those which were already defined since version 2.0,
	 * 		but they are now structured and not only a flat text.
	 * 		@see Javadoc for more details on this AST node structure
	 * </li>
	 * </ul>
	 * Use OR operator to set several options simultaneously. For example, to set
	 * both bindings resolution and comments, set options parameter to:
	 * <code>ResolveBindings | InsideComments</code>.
	 * </p>
	 * <p>
	 * When bindings are created, instead of considering compilation units on disk only
	 * one can supply a <code>WorkingCopyOwner</code>. Working copies owned 
	 * by this owner take precedence over the underlying compilation units when looking
	 * up names and drawing the connections.
	 * </p>
	 * 
	 * @param unit the Java model compilation unit whose source code is to be parsed
	 * @param position a position into the corresponding body declaration
	 * @param options an integer which sets parse options. 
	 * @param owner the owner of working copies that take precedence over underlying 
	 *   compilation units
	 * @return the abridged compilation unit node
	 * @exception IllegalArgumentException if the given Java element does not 
	 * exist or the source range is null or if its source string cannot be obtained
	 * @see ASTNode#getFlags()
	 * @see ASTNode#MALFORMED
	 * @see ASTNode#getStartPosition()
	 * @see ASTNode#getLength()
	 * @since 3.0
	 */
	public static CompilationUnit parsePartialCompilationUnit(
		ICompilationUnit unit,
		int position,
		int options,
		WorkingCopyOwner owner) {
				
		if (unit == null) {


		NodeSearcher searcher = new NodeSearcher(position);

		final Map javaOptions = unit.getJavaProject().getOptions(true);
		if ((options & ResolveBindings) == ResolveBindings) {
			NameLookup lookup = null;
			CompilationUnitDeclaration compilationUnitDeclaration = null;
			try {

					false/*don't cleanup*/,
					source);
				
				ASTConverter converter = new ASTConverter(javaOptions, options);
				AST ast = new AST();
				BindingResolver resolver = new DefaultBindingResolver(compilationUnitDeclaration.scope);
				ast.setBindingResolver(resolver);

				CompilationUnitDeclaration compilationUnitDeclaration2 = CompilationUnitResolver.parse(
					source,
					searcher,
					javaOptions);
				
				ASTConverter converter = new ASTConverter(javaOptions, options^ResolveBindings);
				AST ast = new AST();
				final BindingResolver resolver = new BindingResolver();
				ast.setBindingResolver(resolver);

			CompilationUnitDeclaration compilationUnitDeclaration = CompilationUnitResolver.parse(
				source,
				searcher,
				javaOptions);
			
			ASTConverter converter = new ASTConverter(javaOptions, options);
			AST ast = new AST();
			final BindingResolver resolver = new BindingResolver();
			ast.setBindingResolver(resolver);

	 * @return the binding resolver for this AST
	 */
	BindingResolver getBindingResolver() {
		return this.resolver;
	}

	/** 

	 * 
	 * @return a new unparented Javadoc comment node
	 */
	public Comment newComment() {
		Comment result = new Comment(this);
		return result;
	}
	public Javadoc newJavadoc() {
		Javadoc result = new Javadoc(this);
		return result;
	}
	public JavadocEmbeddedTag newJavadocEmbeddedTag() {
		JavadocEmbeddedTag result = new JavadocEmbeddedTag(this);
		return result;
	}
	public JavadocTag newJavadocTag() {
		JavadocTag result = new JavadocTag(this);
		return result;
	}
	public JavadocArgument newJavadocArgument() {
		JavadocArgument result = new JavadocArgument(this);
		return result;
	}
	





	private AST ast;
	private char[] compilationUnitSource;
	private DOMScanner scanner;
	//private boolean resolveBindings;
	private int options;
	private Set pendingThisExpressionScopeResolution;
	private Set pendingNameScopeResolution;	
	
	/**
	 * @deprecated
	 */
	public ASTConverter(Map compilerOptions, boolean resolveBindings) {
		this(compilerOptions, resolveBindings ? AST.ResolveBindings : 0);
	}
	
	public ASTConverter(Map compilerOptions, int options) {
		this.options = options;
		scanner = new DOMScanner(
				true /*comment*/,
				false /*whitespace*/,
				false /*nls*/,
				JavaCore.VERSION_1_4.equals(compilerOptions.get(JavaCore.COMPILER_SOURCE)) ? ClassFileConstants.JDK1_4 : ClassFileConstants.JDK1_3 /*sourceLevel*/, 
				null /*taskTags*/,
				null/*taskPriorities*/);
	}
	
	public void setAST(AST ast) {
		this.ast = ast;
	}
	
	private boolean resolveBindings() {
		return (this.options & AST.ResolveBindings) == AST.ResolveBindings;
	}
			
	
	public CompilationUnit convert(org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration unit, char[] source) {
		this.compilationUnitSource = source;
		scanner.setSource(source);
		CompilationUnit compilationUnit = this.ast.newCompilationUnit();
		// handle the package declaration immediately
		// There is no node corresponding to the package declaration
		if (resolveBindings()) {
			recordNodes(compilationUnit, unit);
		}
		if (unit.currentPackage != null) {

				compilationUnit.imports().add(convertImport(imports[i]));
			}
		}
		int[][] comments = unit.comments;
		if (comments != null) {
			int commentsLength = comments.length;
			for (int i = 0; i < commentsLength; i++) {
				compilationUnit.comments().add(createComment(comments[i]));
			}
		}

		org.eclipse.jdt.internal.compiler.ast.TypeDeclaration[] types = unit.types;
		if (types != null) {
			int typesLength = types.length;

		if (unit.compilationResult.problemCount != 0) {
			propagateErrors(compilationUnit, unit.compilationResult.problems, unit.compilationResult.problemCount);
		}
		if (resolveBindings()) {
			lookupForScopes();
		}
		return compilationUnit;

		}
		packageDeclaration.setSourceRange(importReference.declarationSourceStart, importReference.declarationEnd - importReference.declarationSourceStart + 1);
		packageDeclaration.setName(name);
		if (resolveBindings()) {
			recordNodes(packageDeclaration, importReference);
			recordNodes(name, compilationUnitDeclaration);
		}

		importDeclaration.setSourceRange(importReference.declarationSourceStart, importReference.declarationEnd - importReference.declarationSourceStart + 1);
		importDeclaration.setName(name);
		importDeclaration.setOnDemand(onDemand);
		if (resolveBindings()) {
			recordNodes(importDeclaration, importReference);
		}
		return importDeclaration;

		}
		
		buildBodyDeclarations(typeDeclaration, typeDecl);
		// The javadoc comment is now got from list store in compilation unit declaration
		// @see BodyDeclaration#getComment(int)
		//setJavaDocComment(typeDecl);
		if (resolveBindings()) {
			recordNodes(typeDecl, typeDeclaration);
			recordNodes(typeName, typeDeclaration);
			typeDecl.resolveBinding();

			initializer.setBody(convert(oldInitializer.block));
			initializer.setModifiers(oldInitializer.modifiers);
			initializer.setSourceRange(oldInitializer.declarationSourceStart, oldInitializer.sourceEnd - oldInitializer.declarationSourceStart + 1);
			// The javadoc comment is now got from list store in compilation unit declaration
			// @see BodyDeclaration#getComment(int)
			//setJavaDocComment(initializer);
			bodyDeclarations.add(initializer);
			return;
		}

			name = this.ast.newSimpleName(new String(typeName[0]));
			name.setSourceRange(typeReference.sourceStart, typeReference.sourceEnd - typeReference.sourceStart + 1);
		}
		if (resolveBindings()) {
			recordNodes(name, typeReference);
		}
		return name;

	
	public SimpleName convert(org.eclipse.jdt.internal.compiler.ast.SingleNameReference nameReference) {
		SimpleName name = this.ast.newSimpleName(new String(nameReference.token));		
		if (resolveBindings()) {
			recordNodes(name, nameReference);
		}
		name.setSourceRange(nameReference.sourceStart, nameReference.sourceEnd - nameReference.sourceStart + 1);

		end = (int)(positions[1] & 0xFFFFFFFF);
		secondToken.setSourceRange(start, end - start + 1);
		QualifiedName qualifiedName = this.ast.newQualifiedName(firstToken, secondToken);
		if (resolveBindings()) {
			recordNodes(qualifiedName, node);
			recordPendingNameScopeResolution(qualifiedName);
			recordNodes(firstToken, node);

			qualifiedName = this.ast.newQualifiedName(qualifiedName, newPart);
			qualifiedName.index = newPart.index;
			qualifiedName.setSourceRange(start0, end - start0 + 1);
			if (resolveBindings()) {
				recordNodes(qualifiedName, node);
				recordNodes(newPart, node);				
				recordPendingNameScopeResolution(qualifiedName);

			}
		}
		QualifiedName name = qualifiedName;
		if (resolveBindings()) {
			recordNodes(name, node);
			recordPendingNameScopeResolution(name);
		}

		}  else {
			ThisExpression thisExpression = this.ast.newThisExpression();
			thisExpression.setSourceRange(reference.sourceStart, reference.sourceEnd - reference.sourceStart + 1);
			if (resolveBindings()) {
				recordNodes(thisExpression, reference);
				recordPendingThisExpressionScopeResolution(thisExpression);
			}

		ThisExpression thisExpression = this.ast.newThisExpression();
		thisExpression.setSourceRange(reference.sourceStart, reference.sourceEnd - reference.sourceStart + 1);
		thisExpression.setQualifier(convert(reference.qualification));
		if (resolveBindings()) {
			recordNodes(thisExpression, reference);
			recordPendingThisExpressionScopeResolution(thisExpression);
		}


	public ArrayAccess convert(org.eclipse.jdt.internal.compiler.ast.ArrayReference reference) {
		ArrayAccess arrayAccess = this.ast.newArrayAccess();
		if (resolveBindings()) {
			recordNodes(arrayAccess, reference);
		}
		arrayAccess.setSourceRange(reference.sourceStart, reference.sourceEnd - reference.sourceStart + 1);

	public Expression convert(org.eclipse.jdt.internal.compiler.ast.FieldReference reference) {
		if (reference.receiver.isSuper()) {
			SuperFieldAccess superFieldAccess = this.ast.newSuperFieldAccess();
			if (resolveBindings()) {
				recordNodes(superFieldAccess, reference);
			}
			if (reference.receiver instanceof org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) {
				Name qualifier = convert((org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) reference.receiver);
				superFieldAccess.setQualifier(qualifier);
				if (resolveBindings()) {
					recordNodes(qualifier, reference.receiver);
				}
			}

			int length = (int)(reference.nameSourcePosition & 0xFFFFFFFF) - sourceStart + 1;
			simpleName.setSourceRange(sourceStart, length);
			superFieldAccess.setName(simpleName);
			if (resolveBindings()) {
				recordNodes(simpleName, reference);
			}
			superFieldAccess.setSourceRange(reference.receiver.sourceStart, reference.sourceEnd - reference.receiver.sourceStart + 1);
			return superFieldAccess;
		} else {
			FieldAccess fieldAccess = this.ast.newFieldAccess();
			if (resolveBindings()) {
				recordNodes(fieldAccess, reference);
			}
			Expression receiver = convert(reference.receiver);

			int length = (int)(reference.nameSourcePosition & 0xFFFFFFFF) - sourceStart + 1;
			simpleName.setSourceRange(sourceStart, length);
			fieldAccess.setName(simpleName);
			if (resolveBindings()) {
				recordNodes(simpleName, reference);
			}
			fieldAccess.setSourceRange(receiver.getStartPosition(), reference.sourceEnd - receiver.getStartPosition() + 1);

					PrimitiveType primitiveType = this.ast.newPrimitiveType(getPrimitiveTypeCode(name));
					primitiveType.setSourceRange(sourceStart, end - sourceStart + 1);
					type = this.ast.newArrayType(primitiveType, dimensions);
					if (resolveBindings()) {
						// store keys for inner types
						completeRecord((ArrayType) type, typeReference);
					}

					simpleType.setSourceRange(sourceStart, end - sourceStart + 1);
					type = this.ast.newArrayType(simpleType, dimensions);
					type.setSourceRange(sourceStart, length);
					if (resolveBindings()) {
						completeRecord((ArrayType) type, typeReference);
						this.recordNodes(simpleName, typeReference);
					}

					simpleName.setSourceRange(sourceStart, length);
					type = this.ast.newSimpleType(simpleName);
					type.setSourceRange(sourceStart, length);
					if (resolveBindings()) {
						this.recordNodes(simpleName, typeReference);
					}
				}

				SimpleType simpleType = this.ast.newSimpleType(qualifiedName);
				simpleType.setSourceRange(sourceStart, length);
				type = this.ast.newArrayType(simpleType, dimensions);
				if (resolveBindings()) {
					completeRecord((ArrayType) type, typeReference);
				}				
				int end = retrieveEndOfDimensionsPosition(sourceStart+length, this.compilationUnitSource.length);

				type.setSourceRange(sourceStart, length);
			}
		}
		if (resolveBindings()) {
			this.recordNodes(type, typeReference);
		}
		return type;

			}			
		}
		
		// The javadoc comment is now got from list store in compilation unit declaration
		// @see BodyDeclaration#getComment(int)
		//setJavaDocComment(methodDecl);
		if (resolveBindings()) {
			recordNodes(methodDecl, methodDeclaration);
			recordNodes(methodName, methodDeclaration);
			methodDecl.resolveBinding();


	public ParenthesizedExpression convertToParenthesizedExpression(org.eclipse.jdt.internal.compiler.ast.Expression expression) {
		ParenthesizedExpression parenthesizedExpression = this.ast.newParenthesizedExpression();
		if (resolveBindings()) {
			recordNodes(parenthesizedExpression, expression);
		}
		parenthesizedExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

	
	public ClassInstanceCreation convert(org.eclipse.jdt.internal.compiler.ast.AllocationExpression expression) {
		ClassInstanceCreation classInstanceCreation = this.ast.newClassInstanceCreation();
		if (resolveBindings()) {
			recordNodes(classInstanceCreation, expression);
		}
		classInstanceCreation.setName(convert(expression.type));


	public ArrayCreation convert(org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression expression) {
		ArrayCreation arrayCreation = this.ast.newArrayCreation();
		if (resolveBindings()) {
			recordNodes(arrayCreation, expression);
		}
		arrayCreation.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

		for (int i = 0; i < dimensionsLength; i++) {
			if (dimensions[i] != null) {
				Expression dimension = convert(dimensions[i]);
				if (resolveBindings()) {
					recordNodes(dimension, dimensions[i]);
				}
				arrayCreation.dimensions().add(dimension);
			}
		}
		Type type = convertType(expression.type);
		if (resolveBindings()) {
			recordNodes(type, expression.type);
		}		
		ArrayType arrayType = null;

			arrayType = (ArrayType) type;
		} else {
			arrayType = this.ast.newArrayType(type, dimensionsLength);
			if (resolveBindings()) {
				completeRecord(arrayType, expression);
			}			
			int start = type.getStartPosition();

			}
		}
		arrayCreation.setType(arrayType);
		if (resolveBindings()) {
			recordNodes(arrayType, expression);
		}	
		if (expression.initializer != null) {

		 */
		setTypeForSingleVariableDeclaration(variableDecl, type, extraDimensions);
		variableDecl.setSourceRange(argument.declarationSourceStart, rightEnd - argument.declarationSourceStart + 1);
		if (resolveBindings()) {
			recordNodes(name, argument);
			recordNodes(variableDecl, argument);
			variableDecl.resolveBinding();


	public ArrayInitializer convert(org.eclipse.jdt.internal.compiler.ast.ArrayInitializer expression) {
		ArrayInitializer arrayInitializer = this.ast.newArrayInitializer();
		if (resolveBindings()) {
			recordNodes(arrayInitializer, expression);
		}
		arrayInitializer.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

			int length = expressions.length;
			for (int i = 0; i < length; i++) {
				Expression expr = convert(expressions[i]);
				if (resolveBindings()) {
					recordNodes(expr, expressions[i]);
				}
				arrayInitializer.expressions().add(expr);

			anonymousClassDeclaration.setSourceRange(start, allocation.anonymousType.bodyEnd - start + 1);
			classInstanceCreation.setAnonymousClassDeclaration(anonymousClassDeclaration);
			buildBodyDeclarations(allocation.anonymousType, anonymousClassDeclaration);
			if (resolveBindings()) {
				recordNodes(classInstanceCreation, allocation.anonymousType);
				recordNodes(anonymousClassDeclaration, allocation.anonymousType);
				anonymousClassDeclaration.resolveBinding();

				int length = arguments.length;
				for (int i = 0; i < length; i++) {
					Expression argument = convert(arguments[i]);
					if (resolveBindings()) {
						recordNodes(argument, arguments[i]);
					}
					classInstanceCreation.arguments().add(argument);
				}
			}
			if (resolveBindings()) {
				recordNodes(classInstanceCreation, allocation);
			}
			removeTrailingCommentFromExpressionEndingWithAParen(classInstanceCreation);

	
	public Assignment convert(org.eclipse.jdt.internal.compiler.ast.Assignment expression) {
		Assignment assignment = this.ast.newAssignment();
		if (resolveBindings()) {
			recordNodes(assignment, expression);
		}
		Expression lhs = convert(expression.lhs);


	public PrefixExpression convert(org.eclipse.jdt.internal.compiler.ast.PrefixExpression expression) {
		PrefixExpression prefixExpression = this.ast.newPrefixExpression();
		if (resolveBindings()) {
			recordNodes(prefixExpression, expression);
		}
		prefixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);


	public PostfixExpression convert(org.eclipse.jdt.internal.compiler.ast.PostfixExpression expression) {
		PostfixExpression postfixExpression = this.ast.newPostfixExpression();
		if (resolveBindings()) {
			recordNodes(postfixExpression, expression);
		}
		postfixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

			castExpression.setType(convertToType((org.eclipse.jdt.internal.compiler.ast.NameReference)type));
		}
		castExpression.setExpression(convert(expression.expression));
		if (resolveBindings()) {
			recordNodes(castExpression, expression);
		}
		return castExpression;

		Name name = convert(reference);
		SimpleType type = this.ast.newSimpleType(name);
		type.setSourceRange(name.getStartPosition(), name.getLength());
		if (resolveBindings()) {
			this.recordNodes(type, reference);
		}
		return type;
	}
	public Expression convert(org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess expression) {
		TypeLiteral typeLiteral = this.ast.newTypeLiteral();
		if (resolveBindings()) {
			this.recordNodes(typeLiteral, expression);
		}
		typeLiteral.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);


	public BooleanLiteral convert(org.eclipse.jdt.internal.compiler.ast.FalseLiteral expression) {
		BooleanLiteral literal = this.ast.newBooleanLiteral(false);
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

		
	public BooleanLiteral convert(org.eclipse.jdt.internal.compiler.ast.TrueLiteral expression) {
		BooleanLiteral literal = this.ast.newBooleanLiteral(true);
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

	
	public org.eclipse.jdt.core.dom.NullLiteral convert(org.eclipse.jdt.internal.compiler.ast.NullLiteral expression) {
		org.eclipse.jdt.core.dom.NullLiteral literal = this.ast.newNullLiteral();
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		CharacterLiteral literal = this.ast.newCharacterLiteral();
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setEscapedValue(new String(tokens));

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		NumberLiteral literal = this.ast.newNumberLiteral(new String(tokens));
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setSourceRange(sourceStart, length);

		char[] tokens = new char[length];
		System.arraycopy(this.compilationUnitSource, sourceStart, tokens, 0, length);
		StringLiteral literal = this.ast.newStringLiteral();
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setEscapedValue(new String(tokens));

	public StringLiteral convert(org.eclipse.jdt.internal.compiler.ast.ExtendedStringLiteral expression) {
		expression.computeConstant();
		StringLiteral literal = this.ast.newStringLiteral();
		if (resolveBindings()) {
			this.recordNodes(literal, expression);
		}
		literal.setLiteralValue(expression.constant.stringValue());

	
	public Expression convert(org.eclipse.jdt.internal.compiler.ast.BinaryExpression expression) {
		InfixExpression infixExpression = this.ast.newInfixExpression();
		if (resolveBindings()) {
			this.recordNodes(infixExpression, expression);
		}


				 || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression && ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID) && ((rightOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
				 	List extendedOperands = infixExpression.extendedOperands();
				 	InfixExpression temp = this.ast.newInfixExpression();
					if (resolveBindings()) {
						this.recordNodes(temp, expression);
					}
				 	temp.setOperator(getOperatorFor(expressionOperatorID));

				 		Expression expr = temp;
				 		temp = this.ast.newInfixExpression();
				 		
						if (resolveBindings()) {
							this.recordNodes(temp, expression);
						}				 	
				 		temp.setLeftOperand(expr);

				 	}
					int startPosition = infixExpression.getLeftOperand().getStartPosition();
					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
					if (resolveBindings()) {
						this.recordNodes(infixExpression, expression);
					}
					return infixExpression;

			
	public PrefixExpression convert(org.eclipse.jdt.internal.compiler.ast.UnaryExpression expression) {
		PrefixExpression prefixExpression = this.ast.newPrefixExpression();
		if (resolveBindings()) {
			this.recordNodes(prefixExpression, expression);
		}
		prefixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

	
	public InstanceofExpression convert(org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression expression) {
		InstanceofExpression instanceOfExpression = this.ast.newInstanceofExpression();
		if (resolveBindings()) {
			recordNodes(instanceOfExpression, expression);
		}
		Expression leftExpression = convert(expression.expression);


	public ConditionalExpression convert(org.eclipse.jdt.internal.compiler.ast.ConditionalExpression expression) {
		ConditionalExpression conditionalExpression = this.ast.newConditionalExpression();
		if (resolveBindings()) {
			recordNodes(conditionalExpression, expression);
		}
		conditionalExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);

		if (expression.isSuperAccess()) {
			// returns a SuperMethodInvocation
			SuperMethodInvocation superMethodInvocation = this.ast.newSuperMethodInvocation();
			if (resolveBindings()) {
				recordNodes(superMethodInvocation, expression);
			}
			SimpleName name = this.ast.newSimpleName(new String(expression.selector));
			int nameSourceStart =  (int) (expression.nameSourcePosition >>> 32);
			int nameSourceLength = (int)(expression.nameSourcePosition & 0xFFFFFFFF) - nameSourceStart + 1;
			name.setSourceRange(nameSourceStart, nameSourceLength);
			if (resolveBindings()) {
				recordNodes(name, expression);
			}
			superMethodInvocation.setName(name);

			if (expression.receiver instanceof org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) {
				Name qualifier = convert((org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) expression.receiver);
				superMethodInvocation.setQualifier(qualifier);
				if (resolveBindings()) {
					recordNodes(qualifier, expression.receiver);
				}
				if (qualifier != null) {

				int argumentsLength = arguments.length;
				for (int i = 0; i < argumentsLength; i++) {
					Expression expri = convert(arguments[i]);
					if (resolveBindings()) {
						recordNodes(expri, arguments[i]);
					}
					superMethodInvocation.arguments().add(expri);

		} else {
			// returns a MethodInvocation
			MethodInvocation methodInvocation = this.ast.newMethodInvocation();
			if (resolveBindings()) {
				recordNodes(methodInvocation, expression);
			}
			SimpleName name = this.ast.newSimpleName(new String(expression.selector));

			int nameSourceLength = (int)(expression.nameSourcePosition & 0xFFFFFFFF) - nameSourceStart + 1;
			name.setSourceRange(nameSourceStart, nameSourceLength);
			methodInvocation.setName(name);
			if (resolveBindings()) {
				recordNodes(name, expression);
			}
			org.eclipse.jdt.internal.compiler.ast.Expression[] arguments = expression.arguments;

				int argumentsLength = arguments.length;
				for (int i = 0; i < argumentsLength; i++) {
					Expression expri = convert(arguments[i]);
					if (resolveBindings()) {
						recordNodes(expri, arguments[i]);
					}
					methodInvocation.arguments().add(expri);
				}
			}
			Expression qualifier = convert(expression.receiver);
			if (qualifier instanceof Name && resolveBindings()) {
				recordNodes(qualifier, expression.receiver);
			}
			methodInvocation.setExpression(qualifier);


	public Expression convert(org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression expression) {
		InfixExpression infixExpression = this.ast.newInfixExpression();
		if (resolveBindings()) {
			recordNodes(infixExpression, expression);
		}
		Expression leftExpression = convert(expression.left);

	
	public Expression convert(org.eclipse.jdt.internal.compiler.ast.EqualExpression expression) {
		InfixExpression infixExpression = this.ast.newInfixExpression();
		if (resolveBindings()) {
			recordNodes(infixExpression, expression);
		}
		Expression leftExpression = convert(expression.left);


	public Expression convert(org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression expression) {
		InfixExpression infixExpression = this.ast.newInfixExpression();
		if (resolveBindings()) {
			recordNodes(infixExpression, expression);
		}
		Expression leftExpression = convert(expression.left);

		}
		newStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
		retrieveSemiColonPosition(newStatement);
		if (resolveBindings()) {
			recordNodes(newStatement, statement);
		}
		return newStatement;

			variableDeclarationFragment.setInitializer(convert(fieldDeclaration.initialization));
		}
		variableDeclarationFragment.setExtraDimensions(retrieveExtraDimension(fieldDeclaration.sourceEnd + 1, fieldDeclaration.declarationSourceEnd ));
		if (resolveBindings()) {
			recordNodes(name, fieldDeclaration);
			recordNodes(variableDeclarationFragment, fieldDeclaration);
			variableDeclarationFragment.resolveBinding();

			variableDeclarationFragment.setInitializer(convert(localDeclaration.initialization));
		}
		variableDeclarationFragment.setExtraDimensions(retrieveExtraDimension(localDeclaration.sourceEnd + 1, this.compilationUnitSource.length));
		if (resolveBindings()) {
			recordNodes(variableDeclarationFragment, localDeclaration);
			recordNodes(name, localDeclaration);
			variableDeclarationFragment.resolveBinding();

	private FieldDeclaration convertToFieldDeclaration(org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDecl) {
		VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(fieldDecl);
		FieldDeclaration fieldDeclaration = this.ast.newFieldDeclaration(variableDeclarationFragment);
		if (resolveBindings()) {
			recordNodes(variableDeclarationFragment, fieldDecl);
			variableDeclarationFragment.resolveBinding();
		}

			fieldDeclaration.setModifiers(fieldDecl.modifiers & legalModifiers);
			fieldDeclaration.setFlags(ASTNode.MALFORMED);
		}
		// The javadoc comment is now got from list store in compilation unit declaration
		// @see BodyDeclaration#getComment(int)
		//setJavaDocComment(fieldDeclaration);
		return fieldDeclaration;
	}

	private VariableDeclarationStatement convertToVariableDeclarationStatement(org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) {
		VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(localDeclaration);
		VariableDeclarationStatement variableDeclarationStatement = this.ast.newVariableDeclarationStatement(variableDeclarationFragment);
		if (resolveBindings()) {
			recordNodes(variableDeclarationFragment, localDeclaration);
		}
		variableDeclarationStatement.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd - localDeclaration.declarationSourceStart + 1);

	private VariableDeclarationExpression convertToVariableDeclarationExpression(org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) {
		VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(localDeclaration);
		VariableDeclarationExpression variableDeclarationExpression = this.ast.newVariableDeclarationExpression(variableDeclarationFragment);
		if (resolveBindings()) {
			recordNodes(variableDeclarationFragment, localDeclaration);
		}
		variableDeclarationExpression.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd - localDeclaration.declarationSourceStart + 1);

		}
	}
	
	/*
	private void setJavaDocComment(BodyDeclaration bodyDeclaration) {
		scanner.resetTo(bodyDeclaration.getStartPosition(), bodyDeclaration.getStartPosition() + bodyDeclaration.getLength());
		try {

			// ignore
		}
	}
	*/
	private Comment createComment(int[] positions) {
		// Create comment node
		Comment comment = null;
		if (positions[1]>0) { // Javadoc comments has positive end position
			comment = this.ast.newJavadoc();
		} else {
			comment = this.ast.newComment();
		}
		comment.setBlock(positions[0]>0||positions[1]>0);	// Block comment has at least one positive position
		// (Javadoc comments are considered as block)
		int start = positions[0]>0 ? positions[0] : -positions[0];
		int end = positions[1]>0 ? positions[1] : -positions[1];
		int length = end - start;
		String contents = new String(this.compilationUnitSource, start, length);
		comment.setSourceRange(start, length);
		comment.setComment(contents);
		return comment;
	}

	private void propagateErrors(CompilationUnit unit, IProblem[] problems, int problemLength) {
		// resize the problem array to the proper size
		IProblem[] resizeProblems = null;




 * matchers.
 * </p>
 * 
 * @see ASTNode#subtreeMatch(ASTMatcher, Object)
 * @since 2.0
 */
public class ASTMatcher {

	 *   <code>false</code> if they do not match or the other object has a
	 *   different node type or is <code>null</code>
	 */
	public boolean match(Comment node, Object other) {
		if (!(other instanceof Comment)) {
			return false;
		}
		Comment o = (Comment) other;
		return safeSubtreeListMatch(node.tags(), o.tags());
	}
	public boolean match(Javadoc node, Object other) {
		if (!(other instanceof Javadoc)) {
			return false;
		}
		Javadoc o = (Javadoc) other;
		return safeSubtreeListMatch(node.tags(), o.tags());
	}
	public boolean match(JavadocTag node, Object other) {
		if (!(other instanceof JavadocTag)) {
			return false;
		}
		JavadocTag o = (JavadocTag) other;
		return (node.getIdentifier().equals(o.getIdentifier()) &&
				safeEquals(node.getDescription(), o.getDescription()) &&
				safeSubtreeMatch(node.getReference(), o.getReference()));
	}
	public boolean match(JavadocEmbeddedTag node, Object other) {
		if (!(other instanceof JavadocEmbeddedTag)) {
			return false;
		}
		JavadocEmbeddedTag o = (JavadocEmbeddedTag) other;
		return (node.getIdentifier().equals(o.getIdentifier()) &&
				safeSubtreeMatch(node.getTag(), o.getTag()));
	}
	public boolean match(JavadocArgument node, Object other) {
		if (!(other instanceof JavadocArgument)) {
			return false;
		}
		JavadocArgument o = (JavadocArgument) other;
		return (node.getArgument().equals(o.getArgument()));
	}
	
	/**
	 * Returns whether the given node and the other object match.
	 * <p>




 * problem (support for this is planned for a future release).
 * </p>
 * 
 * @see AST#parseCompilationUnit(char[]) and other similar methods
 * @see ASTVisitor
 * @since 2.0
 */

	public static final int INSTANCEOF_EXPRESSION = 62;

	/**
	 * Node type constant indicating a node of type 
	 * <code>Comment</code>.
	 * @see Comment
	 */
	public static final int COMMENT = 63;

	/**
	 * Node type constant indicating a node of type 
	 * <code>JavadocTag</code>.
	 * @see JavadocTag
	 */
	public static final int JAVADOC_TAG = 64;

	/**
	 * Node type constant indicating a node of type 
	 * <code>JavadocTag</code>.
	 * @see JavadocTag
	 */
	public static final int JAVADOC_EMBEDDED_TAG = 65;

	/**
	 * Node type constant indicating a node of type 
	 * <code>JavadocTag</code>.
	 * @see JavadocTag
	 */
	public static final int JAVADOC_ARGUMENT = 66;
	
	/**
	 * Owning AST.
	 */
	private final AST owner;

	/**
	 * An unmodifiable empty map (used to implement <code>properties()</code>).
	 * 
	 * @see #properties()
	 */
	private static Map UNMODIFIABLE_EMPTY_MAP
		= Collections.unmodifiableMap(new HashMap(1));

	public ASTNode getParent() {
		return parent;
	}
	
	/**
	 * Returns the root node at or above this node; returns this node if 
	 * it is a root.

	}
	
	/**
	 * Returns the compilation unit which owns this node; returns this node if 
	 * it is a compilation unit or null if none was found.
	 * 
	 * @return the compilation unit node founds in node hierarchy or null if none was found
	 */ 
	public CompilationUnit getCompilationUnit() {
		ASTNode candidate = this;
		while (candidate != null) {
			if (candidate instanceof CompilationUnit) {
				return (CompilationUnit) candidate;
			}
			candidate = candidate.getParent();
		}
		return null;
	}
	
	/**
	 * Internal callback indicating that a field of this node is about to
	 * be modified.
	 */

	 * 
	 * @param propertyName the property name
	 * @return the property value, or <code>null</code> if none
	 * @see #setProperty(String, Object)
	 */
	public Object getProperty(String propertyName) {
		if (propertyName == null) {

	 * 
	 * @param propertyName the property name
	 * @param data the new property value, or <code>null</code> if none
	 * @see #getProperty(String)
	 */
	public void setProperty(String propertyName, Object data) {
		if (propertyName == null) {

	 * </p>
	 * 
	 * @return the bitwise-or of individual flags
	 * @see #setFlags(int)
	 * @see #MALFORMED
	 */
	public int getFlags() {

	 * </p>
	 * 
	 * @param flags the bitwise-or of individual flags
	 * @see #getFlags()
	 * @see #MALFORMED
	 */
	public void setFlags(int flags) {

	 * 
	 * @return the 0-based character index, or <code>-1</code>
	 *    if no source position information is recorded for this node
	 * @see #getLength()
	 * @see AST#parseCompilationUnit
	 */
	public int getStartPosition() {
		return this.startPosition;
	}

	/**
	 * Returns the character index into the original source file indicating
	 * where the source fragment corresponding to this node ends.
	 * 
	 * @return the 0-based character index, or <code>-1</code>
	 *    if no source position information is recorded for this node
	 * @see #getLength()
	 */
	public int getEndPosition() {
		if (this.length==0) {
			return -1;
		}else {
			return this.startPosition+this.length-1;
		}
	}

	/**

	 * @see AST#parseCompilationUnit
	 */
	public int getLength() {
		return this.length;
	}
	
	/**

	 * @param length a (possibly 0) length, 
	 *    or <code>0</code> if no source position information is recorded 
	 *    for this node
	 * @see #getStartPosition()
	 * @see #getLength()
	 * @see AST#parseCompilationUnit
	 */
	public void setSourceRange(int startPosition, int length) {

		// print the subtree by default
		appendPrintString(buffer);
	}

	/**
	 * Appends a standard Java source code representation of this subtree to the given
	 * string buffer.

		this.accept(printer);
		buffer.append(printer.getResult());
	}

	/**
	 * Estimate of size of an object header in bytes.
	 */
	static final int HEADERS = 12;

	/**
	 * Approximate base size of an AST node instance in bytes, 
	 * including object header and instance fields.
	 * That is, HEADERS + (# instance vars in ASTNode)*4.
	 */
	static final int BASE_NODE_SIZE = HEADERS + 7 * 4;

	/**
	 * Returns an estimate of the memory footprint in bytes of the entire 
	 * subtree rooted at this node.

	public final int subtreeBytes() {
		return treeSize();
	}

	/**
	 * Returns an estimate of the memory footprint in bytes of the entire 
	 * subtree rooted at this node.

Lines 93-99 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTVisitor.java (-1 / +25 lines)
93	* </ul>	93	* </ul>
94	* </p>	94	* </p>
95	*	95	*
96	* @see ASTNode#accept	96	* @see ASTNode#accept(ASTVisitor)
97	*/	97	*/
98	public abstract class ASTVisitor {	98	public abstract class ASTVisitor {
99		99
Lines 165-170 Link Here
165	public boolean visit(ClassInstanceCreation node) {	165	public boolean visit(ClassInstanceCreation node) {
166	return true;	166	return true;
167	}	167	}
		168	public boolean visit(Comment node) {
		169	return true;
		170	}
168	public boolean visit(CompilationUnit node) {	171	public boolean visit(CompilationUnit node) {
169	return true;	172	return true;
170	}	173	}
Lines 213-218 Link Here
213	public boolean visit(Javadoc node) {	216	public boolean visit(Javadoc node) {
214	return true;	217	return true;
215	}	218	}
		219	public boolean visit(JavadocTag node) {
		220	return true;
		221	}
		222	public boolean visit(JavadocEmbeddedTag node) {
		223	return true;
		224	}
		225	public boolean visit(JavadocArgument node) {
		226	return true;
		227	}
216	public boolean visit(LabeledStatement node) {	228	public boolean visit(LabeledStatement node) {
217	return true;	229	return true;
218	}	230	}
Lines 355-360 Link Here
355	public void endVisit(CompilationUnit node) {	367	public void endVisit(CompilationUnit node) {
356	// default implementation: do nothing	368	// default implementation: do nothing
357	}	369	}
		370	public void endVisit(Comment node) {
		371	// default implementation: do nothing
		372	}
358	public void endVisit(ConditionalExpression node) {	373	public void endVisit(ConditionalExpression node) {
359	// default implementation: do nothing	374	// default implementation: do nothing
360	}	375	}
Lines 398-403 Link Here
398	// default implementation: do nothing	413	// default implementation: do nothing
399	}	414	}
400	public void endVisit(Javadoc node) {	415	public void endVisit(Javadoc node) {
		416	// default implementation: do nothing
		417	}
		418	public void endVisit(JavadocTag node) {
		419	// default implementation: do nothing
		420	}
		421	public void endVisit(JavadocEmbeddedTag node) {
		422	// default implementation: do nothing
		423	}
		424	public void endVisit(JavadocArgument node) {
401	// default implementation: do nothing	425	// default implementation: do nothing
402	}	426	}
403	public void endVisit(LabeledStatement node) {	427	public void endVisit(LabeledStatement node) {




	 * Returns the Javadoc comment node.
	 * 
	 * @return the javadoc comment node, or <code>null</code> if none
	 * TODO (frederic) See if it could be interesting to store the javadoc comment instead of looking for it systematically...
	 */
	public Javadoc getJavadoc() {
		CompilationUnit unit = getCompilationUnit();
		if (unit != null) {
			Comment comment = unit.getComment(getStartPosition());
			if (comment != null && comment.isJavadoc()) {
				return (Javadoc) comment;
			}
		}
		return this.optionalJavadoc;
	}

	/**

Lines 55-60 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnit.java (-7 / +69 lines)
55	new ASTNode.NodeList(false, TypeDeclaration.class);	55	new ASTNode.NodeList(false, TypeDeclaration.class);
56		56
57	/**	57	/**
		58	* The list of comments in textual order;
		59	* initially none (elementType: <code>Javadoc</code>)
		60	*/
		61	private ASTNode.NodeList comments =
		62	new ASTNode.NodeList(false, Comment.class);
		63
		64	/**
58	* Line end table. If <code>lineEndTable[i] == p</code> then the	65	* Line end table. If <code>lineEndTable[i] == p</code> then the
59	* line number <code>i+1</code> ends at character position	66	* line number <code>i+1</code> ends at character position
60	* <code>p</code>. Except for the last line, the positions are that	67	* <code>p</code>. Except for the last line, the positions are that
Lines 92-98 Link Here
92	* For example, the source string <code>A\nB\nC</code> has	99	* For example, the source string <code>A\nB\nC</code> has
93	* line end table {1, 3, 4}.	100	* line end table {1, 3, 4}.
94	*	101	*
95	* @param lineEndtable the line end table	102	* @param lineEndTable the line end table
96	*/	103	*/
97	void setLineEndTable(int[] lineEndTable) {	104	void setLineEndTable(int[] lineEndTable) {
98	if (lineEndTable == null) {	105	if (lineEndTable == null) {
Lines 213-218 Link Here
213	}	220	}
214		221
215	/**	222	/**
		223	* Returns the live list of nodes for all comments declared in this
		224	* compilation unit, in order of appearance.
		225	*
		226	* @return the live list of comment nodes
		227	* (elementType: <code>Comment</code>)
		228	*/
		229	public List comments() {
		230	return comments;
		231	}
		232
		233	/**
216	* Finds the corresponding AST node in the given compilation unit from	234	* Finds the corresponding AST node in the given compilation unit from
217	* which the given binding originated. Returns <code>null</code> if the	235	* which the given binding originated. Returns <code>null</code> if the
218	* binding does not correspond to any node in this compilation unit.	236	* binding does not correspond to any node in this compilation unit.
Lines 293-299 Link Here
293	* key is declared, or <code>null</code> if the key is <code>null</code>	311	* key is declared, or <code>null</code> if the key is <code>null</code>
294	* or if the key does not correspond to a node in this compilation unit	312	* or if the key does not correspond to a node in this compilation unit
295	* or if bindings were not requested when this AST was built	313	* or if bindings were not requested when this AST was built
296	* @see IBinding#getKey	314	* @see IBinding#getKey()
297	* @since 2.1	315	* @since 2.1
298	*/	316	*/
299	public ASTNode findDeclaringNode(String key) {	317	public ASTNode findDeclaringNode(String key) {
Lines 318-324 Link Here
318	* position does not correspond to a source line in the original	336	* position does not correspond to a source line in the original
319	* source file or if line number information is not known for this	337	* source file or if line number information is not known for this
320	* compilation unit	338	* compilation unit
321	* @see AST#parseCompilationUnit	339	* @see AST#parseCompilationUnit(char[]) and other similar methods
322	*/	340	*/
323	public int lineNumber(int position) {	341	public int lineNumber(int position) {
324	int length = lineEndTable.length;	342	int length = lineEndTable.length;
Lines 384-391 Link Here
384	* </p>	402	* </p>
385	*	403	*
386	* @return the list of messages, possibly empty	404	* @return the list of messages, possibly empty
387	* @see #getProblems	405	* @see #getProblems()
388	* @see AST#parseCompilationUnit	406	* @see AST#parseCompilationUnit(char[]) and other similar methods
389	*/	407	*/
390	public Message[] getMessages() {	408	public Message[] getMessages() {
391	if (this.messages == null) {	409	if (this.messages == null) {
Lines 416-423 Link Here
416	* </p>	434	* </p>
417	*	435	*
418	* @return the list of detailed problem objects, possibly empty	436	* @return the list of detailed problem objects, possibly empty
419	* @see #getMessages	437	* @see #getMessages()
420	* @see AST#parseCompilationUnit	438	* @see AST#parseCompilationUnit(char[]) and other similar methods
421	* @since 2.1	439	* @since 2.1
422	*/	440	*/
423	public IProblem[] getProblems() {	441	public IProblem[] getProblems() {
Lines 474-479 Link Here
474	+ (optionalPackageDeclaration == null ? 0 : getPackage().treeSize())	492	+ (optionalPackageDeclaration == null ? 0 : getPackage().treeSize())
475	+ imports.listSize()	493	+ imports.listSize()
476	+ types.listSize();	494	+ types.listSize();
		495	}
		496
		497	/**
		498	* Get comment of the list which includes a given position
		499	*
		500	* @param position The position belonging to the looked up comment
		501	* @return Javadoc The comment which includes the given position or null if none was found
		502	*/
		503	public Comment getComment(int position) {
		504
		505	if (this.comments == null) {
		506	return null;
		507	}
		508	int size = this.comments.size();
		509	if (size == 0) {
		510	return null;
		511	}
		512	int bottom = 0, top = size - 1;
		513	int i = 0, index = -1;
		514	Comment comment = null;
		515	while (bottom <= top) {
		516	i = (bottom + top) /2;
		517	comment = (Comment) this.comments.get(i);
		518	if (position < comment.getStartPosition()) {
		519	top = i-1;
		520	} else if (position >= comment.getEndPosition()) {
		521	bottom = i+1;
		522	} else {
		523	index = i;
		524	break;
		525	}
		526	}
		527	if (index<0) {
		528	/*
		529	comment = (Comment) this.comments.get(i);
		530	if (position < comment.getStartPosition()) {
		531	index = i;
		532	} else {
		533	index = i+1;
		534	}
		535	*/
		536	return null;
		537	}
		538	return (Comment) this.comments.get(index);
477	}	539	}
478	}	540	}
479		541





package org.eclipse.jdt.core.dom;

import java.util.Map;

import org.eclipse.jdt.internal.compiler.env.*;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.*;
import org.eclipse.jdt.internal.compiler.Compiler;
import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
import org.eclipse.jdt.internal.compiler.env.ISourceType;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.parser.SourceTypeConverter;
import org.eclipse.jdt.internal.compiler.problem.*;
import org.eclipse.jdt.internal.core.*;
import java.util.*;

class CompilationUnitResolver extends Compiler {
	

	
	/**
	 * Add additional source types
	 * @param sourceTypes
	 * @param packageBinding
	 */
	public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
		CompilationResult result =

		}
	}

	private static Parser createDomParser(ProblemReporter problemReporter) {
		
		return new Parser(problemReporter, false) {
			// old annotation style check which doesn't include all leading comments into declaration
			// for backward compatibility with 2.1 DOM 
			public void checkComment() {

				if (this.currentElement != null && this.scanner.commentPtr >= 0) {
					flushCommentsDefinedPriorTo(endStatementPosition); // discard obsolete comments
				}
				boolean deprecated = false;
				boolean checkDeprecated = false;
				int lastCommentIndex = -1;
			
				//since jdk1.2 look only in the last java doc comment...
					//look for @deprecated into the first javadoc comment preceeding the declaration
					int commentSourceStart = scanner.commentStarts[lastCommentIndex];
					// javadoc only (non javadoc comment have negative end positions.)
					if (modifiersSourceStart != -1 && modifiersSourceStart < commentSourceStart) {
						continue nextComment;
					}
					if (scanner.commentStops[lastCommentIndex] < 0) {
						continue nextComment;
					}
					checkDeprecated = true;
					int commentSourceEnd = scanner.commentStops[lastCommentIndex] - 1; //stop is one over
			
					deprecated =
						this.javadocParser.checkDeprecation(commentSourceStart, commentSourceEnd);
					this.javadoc = this.javadocParser.javadoc;
					break nextComment;
				}
				if (deprecated) {
					checkAndSetModifiers(AccDeprecated);
				}
				// modify the modifier source start to point at the first comment
				if (lastCommentIndex >= 0 && checkDeprecated) {
					modifiersSourceStart = scanner.commentStarts[lastCommentIndex]; 
				}

			}
		};
	}

	/*
	 *  Low-level API performing the actual compilation

	 * @see org.eclipse.jdt.internal.compiler.Compiler#initializeParser()
	 */
	public void initializeParser() {
		this.parser = new DOMParser(this.problemReporter, false);
	}
	/*
	 * Compiler crash recovery in case of unexpected runtime exceptions

			throw new IllegalArgumentException();
		}
		CompilerOptions compilerOptions = new CompilerOptions(settings);
		DOMParser parser = new DOMParser(
			new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					compilerOptions, 
					new DefaultProblemFactory()), false);
		org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit = 
			new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(
				source, 

			throw new IllegalArgumentException();
		}
		CompilerOptions compilerOptions = new CompilerOptions(settings);
		DOMParser parser = new DOMParser(
			new ProblemReporter(
					DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
					compilerOptions, 
					new DefaultProblemFactory()), false);
		org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit = 
			new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(
				source, 

		}
	}

	/*
	 * Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
	 */
	public CompilationUnitDeclaration resolve(

			// this.reset();
		}
	}
	/*
	 * Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
	 */
	public CompilationUnitDeclaration resolve(

			generateCode);
	}

	/*
	 * Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
	 */
	public CompilationUnitDeclaration resolve(




	 * Kind constant (value 1) indicating a package binding.
	 * Bindings of this kind can be safely cast to <code>IPackageBinding</code>.
	 * 
	 * @see #getKind()
	 * @see IPackageBinding
	 */
	public static final int PACKAGE = 1;

	 * Kind constant (value 2) indicating a type binding.
	 * Bindings of this kind can be safely cast to <code>ITypeBinding</code>.
	 * 
	 * @see #getKind()
	 * @see ITypeBinding
	 */
	public static final int TYPE = 2;

	 * Kind constant (value 3) indicating a field or local variable binding.
	 * Bindings of this kind can be safely cast to <code>IVariableBinding</code>.
	 * 
	 * @see #getKind()
	 * @see IVariableBinding
	 */
	public static final int VARIABLE = 3;

	 * Kind constant (value 4) indicating a method or constructor binding.
	 * Bindings of this kind can be safely cast to <code>IMethodBinding</code>.
	 * 
	 * @see #getKind()
	 * @see IMethodBinding
	 */
	public static final int METHOD = 4;

	 * not be different; in these cases, the client should compare bindings
	 * via their binding keys (<code>getKey</code>) if available.
	 * 
	 * @see #getKey()
	 * 
	 * @param obj
	 * @return
	 */
	public boolean equals(Object obj);
	




 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;

/**
 * AST node for a Javadoc comment.
 * 
 * @since 2.0
 */
public class Javadoc extends Comment {

	/**
	 * First non-empty line of comment text before the first Javadoc tag;
	 * default is empty string.
	 */
	//String title = "";//$NON-NLS-1$

	/**
	 * Non-empty lines of comment text after the title and before the first
	 * Javadoc tag; default is empty string.
	 */
	//String[] description = { "" }; //$NON-NLS-1$
	//String description = ""; //$NON-NLS-1$

	/**
	 * Creates a new AST node for a Javadoc comment owned by the given AST.
	 * The new node has an unspecified, but legal, Javadoc comment.

	 */
	Javadoc(AST ast) {
		super(ast);
		this.block = true;
		this.text = "/** */"; //$NON-NLS-1$
	}
	
	/* (omit javadoc for this method)

	ASTNode clone(AST target) {
		Javadoc result = new Javadoc(target);
		result.setSourceRange(this.getStartPosition(), this.getLength());
		result.setText(this.text);
		//result.setTitle(this.title);
		//result.setDescription(this.description);
		return result;
	}
	

	 * and ending comment delimiters, and any embedded line breaks.
	 * 
	 * @return the javadoc comment string
	 * @deprecated Use #getText() instead
	 */
	public String getComment() {
		return getText();
	}

	/**
	 * Returns whether the comment is a javadoc comment or not.
	 * @return true if the comment is a Javadoc one, false otherwise.
	 */
	public boolean isJavadoc() {
		return true;
	}

	/**
	 * @return Returns the description as string.
	 */
	public String getDescription() {
		JavadocTag tag = getFirstSentence(false);
		if (tag != null) {
			return tag.getDescription();
		}
		return "";	//$NON-NLS-1$
	}

	/**
	 * Return the first sengtence of Javadoc comment.
	 * This is the first tag of the list which has no identifier.
	 * @param setIfNull Tells whether the first sentence should be created if none was found
	 * @return The first sentence of the Javadoc as a JavadocTag
	 * @see JavadocTag
	 */
	public JavadocTag getFirstSentence(boolean setIfNull) {
		if (this.tags.size() > 0) {
			JavadocTag tag = (JavadocTag) tags().get(0);
			if (tag.getIdentifier().length() == 0) {
				return tag;
					default:
						onlyOneComment = false;
				}
			}
			if (!onlyOneComment) {
				throw new IllegalArgumentException();
			}
		} catch (InvalidInputException e) {
			throw new IllegalArgumentException();
		}
		if (setIfNull) {
			JavadocTag tag = getAST().newJavadocTag();
			this.tags.add(0, tag);
			return tag;
		} else {
			return null;
		}
	int memSize() {
		int size = BASE_NODE_SIZE + 1 * 4;
		size += HEADERS + 2 * 4 + HEADERS + 2 * comment.length();
		return size;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.Comment#isBlock()
	 */
	public boolean isBlock() {
		// Javadoc comment is always considered as a block comment
		return true;
	}

}





	 * @return the serialized 
	 */
	public String getResult() {
		return this.buffer.toString();
	}
	
	/**
	 * Resets this printer so that it can be used again.
	 */
	public void reset() {
		this.buffer.setLength(0);
	}
	
	/**

	 */
	void printModifiers(int modifiers) {
		if (Modifier.isPublic(modifiers)) {
			this.buffer.append("public ");//$NON-NLS-1$
		}
		if (Modifier.isProtected(modifiers)) {
			this.buffer.append("protected ");//$NON-NLS-1$
		}
		if (Modifier.isPrivate(modifiers)) {
			this.buffer.append("private ");//$NON-NLS-1$
		}
		if (Modifier.isStatic(modifiers)) {
			this.buffer.append("static ");//$NON-NLS-1$
		}
		if (Modifier.isAbstract(modifiers)) {
			this.buffer.append("abstract ");//$NON-NLS-1$
		}
		if (Modifier.isFinal(modifiers)) {
			this.buffer.append("final ");//$NON-NLS-1$
		}
		if (Modifier.isSynchronized(modifiers)) {
			this.buffer.append("synchronized ");//$NON-NLS-1$
		}
		if (Modifier.isVolatile(modifiers)) {
			this.buffer.append("volatile ");//$NON-NLS-1$
		}
		if (Modifier.isNative(modifiers)) {
			this.buffer.append("native ");//$NON-NLS-1$
		}
		if (Modifier.isStrictfp(modifiers)) {
			this.buffer.append("strictfp ");//$NON-NLS-1$
		}
		if (Modifier.isTransient(modifiers)) {
			this.buffer.append("transient ");//$NON-NLS-1$
		}
	}		
	

	 * @see ASTVisitor#visit(AnonymousClassDeclaration)
	 */
	public boolean visit(AnonymousClassDeclaration node) {
		this.buffer.append("{");//$NON-NLS-1$
		for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext(); ) {
			BodyDeclaration b = (BodyDeclaration) it.next();
			b.accept(this);
		}
		this.buffer.append("}");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(ArrayAccess node) {
		node.getArray().accept(this);
		this.buffer.append("[");//$NON-NLS-1$
		node.getIndex().accept(this);
		this.buffer.append("]");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(ArrayCreation)
	 */
	public boolean visit(ArrayCreation node) {
		this.buffer.append("new ");//$NON-NLS-1$
		ArrayType at = node.getType();
		int dims = at.getDimensions();
		Type elementType = at.getElementType();
		elementType.accept(this);
		for (Iterator it = node.dimensions().iterator(); it.hasNext(); ) {
			this.buffer.append("[");//$NON-NLS-1$
			Expression e = (Expression) it.next();
			e.accept(this);
			this.buffer.append("]");//$NON-NLS-1$
			dims--;
		}
		// add empty "[]" for each extra array dimension
		for (int i= 0; i < dims; i++) {
			this.buffer.append("[]");//$NON-NLS-1$
		}
		if (node.getInitializer() != null) {
			this.buffer.append("=");//$NON-NLS-1$
			node.getInitializer().accept(this);
		}
		return false;

	 * @see ASTVisitor#visit(ArrayInitializer)
	 */
	public boolean visit(ArrayInitializer node) {
		this.buffer.append("{");//$NON-NLS-1$
		for (Iterator it = node.expressions().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			this.buffer.append(",");//$NON-NLS-1$
		}
		this.buffer.append("}");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(ArrayType node) {
		node.getComponentType().accept(this);
		this.buffer.append("[]");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(AssertStatement)
	 */
	public boolean visit(AssertStatement node) {
		this.buffer.append("assert ");//$NON-NLS-1$
		node.getExpression().accept(this);
		if (node.getMessage() != null) {
			node.getMessage().accept(this);
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(Assignment node) {
		node.getLeftHandSide().accept(this);
		this.buffer.append(node.getOperator().toString());
		node.getRightHandSide().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(Block)
	 */
	public boolean visit(Block node) {
		this.buffer.append("{");//$NON-NLS-1$
		for (Iterator it = node.statements().iterator(); it.hasNext(); ) {
			Statement s = (Statement) it.next();
			s.accept(this);
		}
		this.buffer.append("}");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(BooleanLiteral node) {
		if (node.booleanValue() == true) {
			this.buffer.append("true");//$NON-NLS-1$
		} else {
			this.buffer.append("false");//$NON-NLS-1$
		}
		return false;
	}

	 * @see ASTVisitor#visit(BreakStatement)
	 */
	public boolean visit(BreakStatement node) {
		this.buffer.append("break");//$NON-NLS-1$
		if (node.getLabel() != null) {
			this.buffer.append(" ");//$NON-NLS-1$
			node.getLabel().accept(this);
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(CastExpression)
	 */
	public boolean visit(CastExpression node) {
		this.buffer.append("(");//$NON-NLS-1$
		node.getType().accept(this);
		this.buffer.append(")");//$NON-NLS-1$
		node.getExpression().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(CatchClause)
	 */
	public boolean visit(CatchClause node) {
		this.buffer.append("catch (");//$NON-NLS-1$
		node.getException().accept(this);
		this.buffer.append(") ");//$NON-NLS-1$
		node.getBody().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(CharacterLiteral)
	 */
	public boolean visit(CharacterLiteral node) {
		this.buffer.append(node.getEscapedValue());
		return false;
	}


	public boolean visit(ClassInstanceCreation node) {
		if (node.getExpression() != null) {
			node.getExpression().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		this.buffer.append("new ");//$NON-NLS-1$
		node.getName().accept(this);
		this.buffer.append("(");//$NON-NLS-1$
		for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(")");//$NON-NLS-1$
		if (node.getAnonymousClassDeclaration() != null) {
			node.getAnonymousClassDeclaration().accept(this);
		}

	 */
	public boolean visit(ConditionalExpression node) {
		node.getExpression().accept(this);
		this.buffer.append("?");//$NON-NLS-1$
		node.getThenExpression().accept(this);
		this.buffer.append(":");//$NON-NLS-1$
		node.getElseExpression().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(ConstructorInvocation)
	 */
	public boolean visit(ConstructorInvocation node) {
		this.buffer.append("this(");//$NON-NLS-1$
		for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(");");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(ContinueStatement)
	 */
	public boolean visit(ContinueStatement node) {
		this.buffer.append("continue");//$NON-NLS-1$
		if (node.getLabel() != null) {
			this.buffer.append(" ");//$NON-NLS-1$
			node.getLabel().accept(this);
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(DoStatement)
	 */
	public boolean visit(DoStatement node) {
		this.buffer.append("do ");//$NON-NLS-1$
		node.getBody().accept(this);
		this.buffer.append(" while (");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(");");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(EmptyStatement)
	 */
	public boolean visit(EmptyStatement node) {
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(ExpressionStatement node) {
		node.getExpression().accept(this);
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(FieldAccess node) {
		node.getExpression().accept(this);
		this.buffer.append(".");//$NON-NLS-1$
		node.getName().accept(this);
		return false;
	}

		}
		printModifiers(node.getModifiers());
		node.getType().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
			VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
			f.accept(this);
			if (it.hasNext()) {
				this.buffer.append(", ");//$NON-NLS-1$
			}
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(ForStatement)
	 */
	public boolean visit(ForStatement node) {
		this.buffer.append("for (");//$NON-NLS-1$
		for (Iterator it = node.initializers().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
		}
		this.buffer.append("; ");//$NON-NLS-1$
		if (node.getExpression() != null) {
			node.getExpression().accept(this);
		}
		this.buffer.append("; ");//$NON-NLS-1$
		for (Iterator it = node.updaters().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
		}
		this.buffer.append(") ");//$NON-NLS-1$
		node.getBody().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(IfStatement)
	 */
	public boolean visit(IfStatement node) {
		this.buffer.append("if (");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(") ");//$NON-NLS-1$
		node.getThenStatement().accept(this);
		if (node.getElseStatement() != null) {
			this.buffer.append(" else ");//$NON-NLS-1$
			node.getElseStatement().accept(this);
		}
		return false;

	 * @see ASTVisitor#visit(ImportDeclaration)
	 */
	public boolean visit(ImportDeclaration node) {
		this.buffer.append("import ");//$NON-NLS-1$
		node.getName().accept(this);
		if (node.isOnDemand()) {
			this.buffer.append(".*");//$NON-NLS-1$
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(InfixExpression node) {
		node.getLeftOperand().accept(this);
		this.buffer.append(node.getOperator().toString());
		node.getRightOperand().accept(this);
		for (Iterator it = node.extendedOperands().iterator(); it.hasNext(); ) {
			this.buffer.append(node.getOperator().toString());
			Expression e = (Expression) it.next();
			e.accept(this);
		}

	 */
	public boolean visit(InstanceofExpression node) {
		node.getLeftOperand().accept(this);
		this.buffer.append(" instanceof ");//$NON-NLS-1$
		node.getRightOperand().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(Javadoc)
	 */
	public boolean visit(Javadoc node) {
		this.buffer.append("[block: "+node.isBlock());	//$NON-NLS-1$
		this.buffer.append("][javadoc: "+node.isJavadoc());	//$NON-NLS-1$
		this.buffer.append("][tags:"+node.tags().size()); //$NON-NLS-1$
		this.buffer.append("]");	//$NON-NLS-1$
		for (Iterator it = node.tags().iterator(); it.hasNext(); ) {
			JavadocTag tag = (JavadocTag) it.next();
			this.buffer.append("\n * "); //$NON-NLS-1$
			tag.accept(this);
		}
		this.buffer.append("\nText:"); //$NON-NLS-1$
		this.buffer.append(node.getText());
		return false;
	}
	public boolean visit(JavadocTag node) {
		boolean hasIdentifier = node.getIdentifier().length() > 0;
		if (hasIdentifier) {
			this.buffer.append('@');
			this.buffer.append(node.getIdentifier());
		}
		boolean hasReference = node.getReference() != null;
		if (hasReference) {
			if (hasIdentifier) {
				this.buffer.append(' ');
			}
			node.getReference().accept(this);
		}
		String txt = node.getDescription();
		if (txt.length() > 0) {
			if (hasIdentifier || hasReference) {
				this.buffer.append(' ');
			}
			this.buffer.append(txt);
		}
		return false;
	}
	public boolean visit(JavadocEmbeddedTag node) {
		boolean hasIdentifier = node.getIdentifier().length() > 0;
		this.buffer.append('{');
		if (hasIdentifier) {
			this.buffer.append('@');
			this.buffer.append(node.getIdentifier());
		}
		boolean hasTag = node.getTag() != null;
		if (hasTag) {
			if (hasIdentifier) {
				this.buffer.append(' ');
			}
			node.getTag().accept(this);
		}
		this.buffer.append('}');
		return false;
	}
	
	/*
	 * @see ASTVisitor#visit(LabeledStatement)
	 */
	public boolean visit(LabeledStatement node) {
		node.getLabel().accept(this);
		this.buffer.append(": ");//$NON-NLS-1$
		node.getBody().accept(this);
		return false;
	}

		printModifiers(node.getModifiers());
		if (!node.isConstructor()) {
			node.getReturnType().accept(this);
			this.buffer.append(" ");//$NON-NLS-1$
		}
		node.getName().accept(this);
		this.buffer.append("(");//$NON-NLS-1$
		for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
			SingleVariableDeclaration v = (SingleVariableDeclaration) it.next();
			v.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(")");//$NON-NLS-1$
		if (!node.thrownExceptions().isEmpty()) {
			this.buffer.append(" throws ");//$NON-NLS-1$
			for (Iterator it = node.thrownExceptions().iterator(); it.hasNext(); ) {
				Name n = (Name) it.next();
				n.accept(this);
				if (it.hasNext()) {
					this.buffer.append(", ");//$NON-NLS-1$
				}
			}
			this.buffer.append(" ");//$NON-NLS-1$
		}
		if (node.getBody() == null) {
			this.buffer.append(";");//$NON-NLS-1$
		} else {
			node.getBody().accept(this);
		}

	public boolean visit(MethodInvocation node) {
		if (node.getExpression() != null) {
			node.getExpression().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		node.getName().accept(this);
		this.buffer.append("(");//$NON-NLS-1$
		for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(")");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(NullLiteral)
	 */
	public boolean visit(NullLiteral node) {
		this.buffer.append("null");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(NumberLiteral)
	 */
	public boolean visit(NumberLiteral node) {
		this.buffer.append(node.getToken());
		return false;
	}


	 * @see ASTVisitor#visit(PackageDeclaration)
	 */
	public boolean visit(PackageDeclaration node) {
		this.buffer.append("package ");//$NON-NLS-1$
		node.getName().accept(this);
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(ParenthesizedExpression)
	 */
	public boolean visit(ParenthesizedExpression node) {
		this.buffer.append("(");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(")");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(PostfixExpression node) {
		node.getOperand().accept(this);
		this.buffer.append(node.getOperator().toString());
		return false;
	}


	 * @see ASTVisitor#visit(PrefixExpression)
	 */
	public boolean visit(PrefixExpression node) {
		this.buffer.append(node.getOperator().toString());
		node.getOperand().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(PrimitiveType)
	 */
	public boolean visit(PrimitiveType node) {
		this.buffer.append(node.getPrimitiveTypeCode().toString());
		return false;
	}


	 */
	public boolean visit(QualifiedName node) {
		node.getQualifier().accept(this);
		this.buffer.append(".");//$NON-NLS-1$
		node.getName().accept(this);
		return false;
	}

	 * @see ASTVisitor#visit(ReturnStatement)
	 */
	public boolean visit(ReturnStatement node) {
		this.buffer.append("return");//$NON-NLS-1$
		if (node.getExpression() != null) {
			this.buffer.append(" ");//$NON-NLS-1$
			node.getExpression().accept(this);
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(SimpleName)
	 */
	public boolean visit(SimpleName node) {
		this.buffer.append(node.getIdentifier());
		return false;
	}


	public boolean visit(SingleVariableDeclaration node) {
		printModifiers(node.getModifiers());
		node.getType().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		node.getName().accept(this);
		if (node.getInitializer() != null) {
			this.buffer.append("=");//$NON-NLS-1$
			node.getInitializer().accept(this);
		}
		return false;

	 * @see ASTVisitor#visit(StringLiteral)
	 */
	public boolean visit(StringLiteral node) {
		this.buffer.append(node.getEscapedValue());
		return false;
	}


	public boolean visit(SuperConstructorInvocation node) {
		if (node.getExpression() != null) {
			node.getExpression().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		this.buffer.append("super(");//$NON-NLS-1$
		for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(");");//$NON-NLS-1$
		return false;
	}


	public boolean visit(SuperFieldAccess node) {
		if (node.getQualifier() != null) {
			node.getQualifier().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		this.buffer.append("super.");//$NON-NLS-1$
		node.getName().accept(this);
		return false;
	}

	public boolean visit(SuperMethodInvocation node) {
		if (node.getQualifier() != null) {
			node.getQualifier().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		this.buffer.append("super.");//$NON-NLS-1$
		node.getName().accept(this);
		this.buffer.append("(");//$NON-NLS-1$
		for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
			Expression e = (Expression) it.next();
			e.accept(this);
			if (it.hasNext()) {
				this.buffer.append(",");//$NON-NLS-1$
			}
		}
		this.buffer.append(")");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(SwitchCase node) {
		if (node.isDefault()) {
			this.buffer.append("default :");//$NON-NLS-1$
		} else {
			this.buffer.append("case ");//$NON-NLS-1$
			node.getExpression().accept(this);
			this.buffer.append(":");//$NON-NLS-1$
		}
		return false;
	}

	 * @see ASTVisitor#visit(SwitchStatement)
	 */
	public boolean visit(SwitchStatement node) {
		this.buffer.append("switch (");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(") ");//$NON-NLS-1$
		this.buffer.append("{");//$NON-NLS-1$
		for (Iterator it = node.statements().iterator(); it.hasNext(); ) {
			Statement s = (Statement) it.next();
			s.accept(this);
		}
		this.buffer.append("}");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(SynchronizedStatement)
	 */
	public boolean visit(SynchronizedStatement node) {
		this.buffer.append("synchronized (");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(") ");//$NON-NLS-1$
		node.getBody().accept(this);
		return false;
	}

	public boolean visit(ThisExpression node) {
		if (node.getQualifier() != null) {
			node.getQualifier().accept(this);
			this.buffer.append(".");//$NON-NLS-1$
		}
		this.buffer.append("this");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(ThrowStatement)
	 */
	public boolean visit(ThrowStatement node) {
		this.buffer.append("throw ");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(TryStatement)
	 */
	public boolean visit(TryStatement node) {
		this.buffer.append("try ");//$NON-NLS-1$
		node.getBody().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		for (Iterator it = node.catchClauses().iterator(); it.hasNext(); ) {
			CatchClause cc = (CatchClause) it.next();
			cc.accept(this);
		}
		if (node.getFinally() != null) {
			this.buffer.append("finally ");//$NON-NLS-1$
			node.getFinally().accept(this);
		}
		return false;

			node.getJavadoc().accept(this);
		}
		printModifiers(node.getModifiers());
		this.buffer.append(node.isInterface() ? "interface " : "class ");//$NON-NLS-2$//$NON-NLS-1$
		node.getName().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		if (node.getSuperclass() != null) {
			this.buffer.append("extends ");//$NON-NLS-1$
			node.getSuperclass().accept(this);
			this.buffer.append(" ");//$NON-NLS-1$
		}
		if (!node.superInterfaces().isEmpty()) {
			this.buffer.append(node.isInterface() ? "extends " : "implements ");//$NON-NLS-2$//$NON-NLS-1$
			for (Iterator it = node.superInterfaces().iterator(); it.hasNext(); ) {
				Name n = (Name) it.next();
				n.accept(this);
				if (it.hasNext()) {
					this.buffer.append(", ");//$NON-NLS-1$
				}
			}
			this.buffer.append(" ");//$NON-NLS-1$
		}
		this.buffer.append("{");//$NON-NLS-1$
		for (Iterator it = node.bodyDeclarations().iterator(); it.hasNext(); ) {
			BodyDeclaration d = (BodyDeclaration) it.next();
			d.accept(this);
		}
		this.buffer.append("}");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(TypeDeclarationStatement node) {
		node.getTypeDeclaration().accept(this);
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 */
	public boolean visit(TypeLiteral node) {
		node.getType().accept(this);
		this.buffer.append(".class");//$NON-NLS-1$
		return false;
	}


	public boolean visit(VariableDeclarationExpression node) {
		printModifiers(node.getModifiers());
		node.getType().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
			VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
			f.accept(this);
			if (it.hasNext()) {
				this.buffer.append(", ");//$NON-NLS-1$
			}
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	public boolean visit(VariableDeclarationFragment node) {
		node.getName().accept(this);
		for (int i = 0; i < node.getExtraDimensions(); i++) {
			this.buffer.append("[]");//$NON-NLS-1$
		}
		if (node.getInitializer() != null) {
			this.buffer.append("=");//$NON-NLS-1$
			node.getInitializer().accept(this);
		}
		return false;

	public boolean visit(VariableDeclarationStatement node) {
		printModifiers(node.getModifiers());
		node.getType().accept(this);
		this.buffer.append(" ");//$NON-NLS-1$
		for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
			VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
			f.accept(this);
			if (it.hasNext()) {
				this.buffer.append(", ");//$NON-NLS-1$
			}
		}
		this.buffer.append(";");//$NON-NLS-1$
		return false;
	}


	 * @see ASTVisitor#visit(WhileStatement)
	 */
	public boolean visit(WhileStatement node) {
		this.buffer.append("while (");//$NON-NLS-1$
		node.getExpression().accept(this);
		this.buffer.append(") ");//$NON-NLS-1$
		node.getBody().accept(this);
		return false;
	}

Lines 112-118 Link Here

(-)dom/org/eclipse/jdt/core/dom/QualifiedName.java (-1 / +1 lines)
112	/**	112	/**
113	* Sets the qualifier of this qualified name to the given name.	113	* Sets the qualifier of this qualified name to the given name.
114	*	114	*
115	* @param the qualifier of this qualified name	115	* @param qualifier the qualifier of this qualified name
116	* @exception IllegalArgumentException if:	116	* @exception IllegalArgumentException if:
117	* <ul>	117	* <ul>
118	* <li>the node belongs to a different AST</li>	118	* <li>the node belongs to a different AST</li>

Lines 431-436 Link Here

(-)model/org/eclipse/jdt/internal/core/util/PublicScanner.java (-2 / +7 lines)
431	* e.g. getLineStart(1) --> 0 indicates that the first line starts at character 0.	431	* e.g. getLineStart(1) --> 0 indicates that the first line starts at character 0.
432	*	432	*
433	* In case the given line number is inconsistent, answers -1.	433	* In case the given line number is inconsistent, answers -1.
		434	*
		435	* @param lineNumber
		436	* @return int
434	*/	437	*/
435	public final int getLineStart(int lineNumber) {	438	public final int getLineStart(int lineNumber) {
436		439
Lines 2228-2235 Link Here
2228	* Reposition the scanner on some portion of the original source. The given endPosition is the last valid position.	2231	* Reposition the scanner on some portion of the original source. The given endPosition is the last valid position.
2229	* Beyond this position, the scanner will answer EOF tokens (<code>ITerminalSymbols.TokenNameEOF</code>).	2232	* Beyond this position, the scanner will answer EOF tokens (<code>ITerminalSymbols.TokenNameEOF</code>).
2230	*	2233	*
2231	* @param startPosition the given start position	2234	* @param begin the given start position
2232	* @param endPosition the given end position	2235	* @param end the given end position
2233	*/	2236	*/
2234	public void resetTo(int begin, int end) {	2237	public void resetTo(int begin, int end) {
2235	//reset the scanner to a given position where it may rescan again	2238	//reset the scanner to a given position where it may rescan again
Lines 3036-3041 Link Here
3036	/**	3039	/**
3037	* Search the line number corresponding to a specific position	3040	* Search the line number corresponding to a specific position
3038	*	3041	*
		3042	* @param position
		3043	* @return int
3039	*/	3044	*/
3040	public final int getLineNumber(int position) {	3045	public final int getLineNumber(int position) {
3041		3046




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

import java.util.Iterator;
import java.util.List;

/**
 * AST node for a comment.
 * This is a concrete class which represents line comments: <code>// comment</code>
 * and block comments <code>/* comment \*\/</code>.
 * 
 * Javadoc comment are still representated with Javadoc class which is now a sub-class
 * of this class.
 * @see Javadoc
 * 
 * @since 3.0
 */
public class Comment extends ASTNode {

	/**
	 * The comment text, including opening and closing comment 
	 * delimiters; defaults to an empty, but legal, line comment.
	 */
	String text = "//";//$NON-NLS-1$

	/**
	 * Indicates whether the comment is a block or a line comment;
	 * defaults to an unspecified, but legal, comment.
	 * Note that Javadoc comment are considered as block comments
	 * @see Javadoc
	 */
	boolean block = false;
	
	/**
	 * The tags included in the comment (element type: <code>JavadocTag</code>).
	 * Defaults to none.
	 */
	ASTNode.NodeList tags = new ASTNode.NodeList(true, JavadocTag.class);

	/**
	 * Creates a new AST node for a Javadoc comment owned by the given AST.
	 * The new node has an unspecified, but legal, Javadoc comment.
	 * <p>
	 * N.B. This constructor is package-private; all subclasses must be 
	 * declared in the same package; clients are unable to declare 
	 * additional subclasses.
	 * </p>
	 * 
	 * @param ast the AST that is to own this node
	 */
	Comment(AST ast) {
		super(ast);
	}
	
	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	public int getNodeType() {
		return COMMENT;
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	ASTNode clone(AST target) {
		Comment result = new Comment(target);
		result.setSourceRange(this.getStartPosition(), this.getLength());
		result.setText(this.text);
		result.setBlock(this.block);
		return result;
	}
	
	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
		// dispatch to correct overloaded match method
		return matcher.match(this, other);
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	void accept0(ASTVisitor visitor) {
		visitor.visit(this);
		visitor.endVisit(this);
	}

	/**
	 * Returns the Javadoc comment string, including the starting
	 * and ending comment delimiters, and any embedded line breaks.
	 * 
	 * @return the javadoc comment string
	 */
	public String getText() {
		return this.text;
	}

	/**
	 * Sets or clears the Javadoc comment string. The documentation
	 * string must include the starting and ending comment delimiters,
	 * and any embedded line breaks.
	 * 
	 * @param textComment the javadoc comment string
	 * @exception IllegalArgumentException if the Java comment string is invalid
	 */
	public void setText(String textComment) {
		if (textComment == null) {
			throw new IllegalArgumentException();
		}
		modifying();
		this.text = textComment;
	}

	/**
	 * Sets or clears the Javadoc comment string. The documentation
	 * string must include the starting and ending comment delimiters,
	 * and any embedded line breaks.
	 * 
	 * @param comment the javadoc comment string
	 * @exception IllegalArgumentException if the Java comment string is invalid
	 */
	public void setComment(String comment) {
		setText(comment);
		//this.block = (comment.indexOf('\r') >= 0 || comment.indexOf('\n') >= 0);
		if (this.block) {
			DOMCommentParser parser = new DOMCommentParser(this.getAST());
			if (parser.parse(this)) {
				if ((getStartPosition() > 0) && (this.tags != null)) {
					for(Iterator it = this.tags.iterator(); it.hasNext(); ) {
						JavadocTag tag = (JavadocTag) it.next();
						tag.setSourceRange(tag.getStartPosition()+getStartPosition(), tag.getLength());
					}
				}
			} else {
				throw new IllegalArgumentException();
			}
		}
	}
	
	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	int memSize() {
		int size = BASE_NODE_SIZE;
		if (this.text != null) {
			// Strings usually have 4 instance fields, one of which is a char[]
			size += HEADERS + 4 * 4;
			// char[] has 2 bytes per character
			size += HEADERS + 2 * this.text.length();
		}
		size += 4; // size for block
		size += 4; // size for tags
		return size;
	}
	
	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	int treeSize() {
		return memSize() + tags.listSize();
	}

	/**
	 * @return Returns the tagDeclarations.
	 */
	public List tags() {
		return tags;
	}

	/**
	 * @return Returns the isBlock.
	 */
	public boolean isBlock() {
		return block;
	}

	/**
	 * @param isBlock The isBlock to set.
	 */
	public void setBlock(boolean isBlock) {
		modifying();
		this.block = isBlock;
	}

	/**
	 * Returns whether the comment is a javadoc comment or not.
	 * @return true if the comment is a Javadoc one, false otherwise.
	 */
	public boolean isJavadoc() {
		return false;
	}
	
	/**
	 * Returns whether the comment has tags or not.
	 * @return true if some tags are written in the comment, false otherwise.
	 */
	public boolean hasTags() {
		return (this.tags != null) && (this.tags.size() > 0);
	}
}





/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

import java.util.ArrayList;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;

/**
 * Parser specialized for decoding comments.
 */
public class DOMCommentParser {

	// recognized tags
	public static final char[] TAG_DEPRECATED = "deprecated".toCharArray(); //$NON-NLS-1$
	public static final char[] TAG_PARAM = "param".toCharArray(); //$NON-NLS-1$
	public static final char[] TAG_RETURN = "return".toCharArray(); //$NON-NLS-1$
	public static final char[] TAG_THROWS = "throws".toCharArray(); //$NON-NLS-1$
	public static final char[] TAG_EXCEPTION = "exception".toCharArray(); //$NON-NLS-1$
	public static final char[] TAG_SEE = "see".toCharArray(); //$NON-NLS-1$
	public static final char[] EMBEDDED_TAG_INHERIT_DOC = "inheritdDoc".toCharArray(); //$NON-NLS-1$
	public static final char[] EMBEDDED_TAG_LINK = "link".toCharArray(); //$NON-NLS-1$
	public static final char[] EMBEDDED_TAG_LINKPLAIN = "linkplain".toCharArray(); //$NON-NLS-1$
	
	// tags expected positions
	public final static int ORDERED_TAGS_NUMBER = 3;
	public final static int PARAM_TAG_EXPECTED_ORDER = 0;
	public final static int THROWS_TAG_EXPECTED_ORDER = 1;
	public final static int SEE_TAG_EXPECTED_ORDER = 2;
	
	// Public fields
	private Comment comment;
	private DOMScanner scanner;
	private AST ast;
	
	// Private fields
	private int currentTokenType = -1;
	private int index, linePtr;
	private char[] source;
	
	// Identifier stack
	protected int identifierPtr;
	protected String[] identifierStack;
	protected int identifierLengthPtr;
	protected int[] identifierLengthStack;
	protected long[] identifierPositionStack;
	// Ast stack
	protected static int AstStackIncrement = 10;
	protected int astPtr;
	protected ASTNode[] astStack;
	//protected int astLengthPtr;
	//protected int[] astLengthStack;

	DOMCommentParser(AST ast) {
		this.ast = ast;
		this.scanner = new DOMScanner(true, true, false, ClassFileConstants.JDK1_3, null, null);
		this.scanner.recordLineSeparator = true;
		this.identifierStack = new String[10];
		this.identifierPositionStack = new long[10];
		this.identifierLengthStack = new int[20];
		this.astStack = new ASTNode[20];
		//this.astLengthStack = new int[30];
	}

	/* (non-Javadoc)
	 * Returns true if tag @deprecated is present in annotation.
	 * 
	 * If annotation checking is enabled, will also construct an Annotation node, which will be stored into Parser.annotation
	 * slot for being consumed later on.
	 */
	public boolean parse(Comment astComment) {

		// Init
		this.scanner.setSource(astComment.getText().toCharArray());
		reset();
		boolean valid = false;
		this.comment = astComment;
		Javadoc javadoc = astComment.isJavadoc() ? (Javadoc) astComment : null;
		
		// Parse
		try {
			// Verify first characters
			if (readChar() != '/' || readChar() != '*') {
				return false;
			}
			
			// Go to first non blank char
			if (this.source[this.index] == '*') {
				readChar();
				if (!astComment.isJavadoc()) {
					return readChar() == '/' && this.index == this.scanner.eofPosition;
				}
			}
			this.scanner.restartFrom(this.index);
			skipWhiteChars(true);
			int tagStart = this.index;

			// We got some text before first tag declaration
			if (this.source[this.index] != '@') {
				// read sentences before first tag
				int textStart = this.index;
				this.linePtr = this.scanner.linePtr;
				boolean endComment = false;
				while (!endComment && (this.source[this.index] != '@') && (this.index < this.scanner.eofPosition)) {
					endComment = readLine(true);	// skip '*' after line
				}
				
				// Store first sentence in javadoc
				if (javadoc != null) {
					// description
					int textEnd = this.scanner.getCurrentTokenEndPosition();
					if (this.scanner.linePtr > this.linePtr) {
						textEnd = this.scanner.getLineEnd(this.scanner.linePtr+1);
					}
					JavadocTag firstSentence = javadoc.getFirstSentence(true/*instanciate if null*/);
					firstSentence.setSourceRange(textStart, textEnd-textStart+1);
					firstSentence.setDescription(new String(this.source, textStart, textEnd-textStart+1));
				
					// embedded tags
					if (this.scanner.embeddedPtr >= 0) {
						for (int i=0; i<=this.scanner.embeddedPtr; i++) {
							JavadocEmbeddedTag embeddedTag = parseEmbeddedTag(this.scanner.embeddedTagStarts[i], this.scanner.embeddedTagStops[i]);
							firstSentence.embedded().add(embeddedTag);
						}
					}
				}
				
				// verify end of comment
				if (this.index >= this.scanner.eofPosition) {
					return endComment;
				}
				if (endComment) {
					skipWhiteChars(false);
					return this.index == this.scanner.eofPosition;
				}
			}
			
			// Loop on each @tag
			this.linePtr = this.scanner.linePtr;
			loopTag: while (this.index < this.scanner.eofPosition) {

				// We should be at the beginning of a tag declaration...
				skipWhiteChars(false);
				if (this.source[this.index] != '@') {
					break;
				}
				tagStart = this.index;
				readChar();
				this.scanner.restartFrom(this.index);

				// Consume tag declaration
				int tk = readTokenAndConsume();	// tag name
				JavadocTag javadocTag = null;
				switch (tk) {
					case TerminalTokens.TokenNameIdentifier :
						char[] tag = this.scanner.getCurrentIdentifierSource();
						skipWhiteChars(false);
						if (CharOperation.equals(tag, TAG_PARAM)) {
							javadocTag = parseParam();
						} else if (CharOperation.equals(tag, TAG_EXCEPTION)) {
							javadocTag = parseThrows();
						} else if (CharOperation.equals(tag, TAG_SEE)) {
							javadocTag = parseSee();
						} else {
							javadocTag = parseTag(new String(tag));
						}
						break;
					case TerminalTokens.TokenNamereturn :
						javadocTag = parseTag(new String(TAG_RETURN));
						break;
					case TerminalTokens.TokenNamethrows :
						javadocTag = parseThrows();
						break;
				}
				if (javadocTag == null) {
					break;
				}
				
				// Consume tag description
				int textStart = this.index;
				if (this.currentTokenType == -1) {
					skipWhiteChars(false);
					textStart = this.index; // store start again as it might be changed
				} else {
					if (this.currentTokenType != TerminalTokens.TokenNameWHITESPACE) {
						textStart = this.scanner.getCurrentTokenStartPosition(); // one token was already read, start is at the beginning of this token
					}
					consumeToken();
				}

				// If new line was encountered while parsing tag declaration then do not read the first line
				// (if this happens, this means that first line of description was empty and we're already on the second one)
				boolean firstLineEmpty = this.scanner.linePtr > this.linePtr;

				// Loop on lines for tag description
				loopText: while (this.index < this.scanner.eofPosition) {
					this.linePtr = this.scanner.linePtr;
					if (!firstLineEmpty) {
						// stop right now if end of the comment is encountered
						if (readLine(false/*keep '*' after line*/)) {
							setJavadocTagText(javadocTag, tagStart, textStart);
							skipWhiteChars(false);
							valid = this.index == this.scanner.eofPosition;
							break loopTag;
						}

						// add embedded tags if necessary
						if (this.scanner.embeddedPtr >= 0) {
							for (int i=0; i<=this.scanner.embeddedPtr; i++) {
								JavadocEmbeddedTag embeddedTag = parseEmbeddedTag(this.scanner.embeddedTagStarts[i], this.scanner.embeddedTagStops[i]);
								javadocTag.embedded().add(embeddedTag);
							}
						}
						
					}
					
					// after reading a line, we should have a new line starting with a '*' or a new tag
					// (since JDK 1.4 '*' is not mandatory at the beginning of the line...)
					switch (this.source[this.index]) {
						case '*' :
							readChar();
							if (this.source[this.index] == '/') {
								// sounds like end of comment, prepare to leave
								readChar();
								skipWhiteChars(false);
								valid = this.index == this.scanner.eofPosition;
							} else {
								skipWhiteChars(false);
								if (this.source[this.index] != '@') {
									// we're not on a new tag declaration, then read following line of description
									break;
								}
							}
							// fall through following case as we got a new tag or end of comment
						case '@':
							if (firstLineEmpty && (javadocTag.getReference() != null)) { // we're on an empty first line, end of text is on previous line...
								int textEnd = javadocTag.getReference().getEndPosition();
								javadocTag.setSourceRange(tagStart, textEnd-tagStart+1);
								//javadocTag.setDescription(new String(this.source, textStart, textEnd-textStart+1));
								this.linePtr = this.scanner.linePtr;
								//this.linesPtr = -1;
							} else {
								setJavadocTagText(javadocTag, tagStart, textStart);
							}
							this.comment.tags().add(javadocTag);
							break loopText;
						default :
							break loopTag;
					}
					firstLineEmpty = false; // we only want to skip first line read
				}
			}
		} catch (Exception e) {
			valid = false;
		} finally {
			this.source = null; // release source as soon as finished
		}
		return valid;
	}

	private void consumeToken() {
		this.currentTokenType = -1; // flush token cache
	}
	
	private SimpleType getEnclosingType() {
		ASTNode parent = this.comment.getParent();
		while (parent != null) {
			if (parent instanceof SimpleType) {
				return (SimpleType) parent;
			}
			parent = parent.getParent();
		}
		return null;
	}

	/*
	 * Parse argument in @see tag method reference
	 */
	private Expression parseArguments(SimpleType receiver) throws InvalidInputException {

		// Init
		int modulo = 0; // should be 2 for (Type,Type,...) or 3 for (Type arg,Type arg,...)
		int iToken = 0;
		String argName = null;
		int ptr = this.astPtr;
		//int lptr = this.astLengthPtr;
		int start = this.scanner.getCurrentTokenStartPosition();
		
		// Decide whether we have a constructor or not
		SimpleName simpleName = null;
		Name receiverName = receiver.getName();
		if (receiverName.isQualifiedName()) {
			simpleName = ((QualifiedName) receiverName).getName();
		} else {
			simpleName = (SimpleName) receiverName;
		}
		boolean isConstructor = simpleName.getIdentifier().equals(this.identifierStack[0]);

		// Parse arguments declaration if method reference
		nextArg : while (this.index < this.scanner.eofPosition) {

			// Read argument type reference
			Type type;
			try {
				type = parseQualifiedName(false);
			} catch (InvalidInputException e) {
				break nextArg;
			}
			boolean firstArg = modulo == 0;
			if (firstArg) { // verify position
				if (iToken != 0)
					break nextArg;
			} else if ((iToken % modulo) != 0) {
					break nextArg;
			}
			if (type == null) {
				if (firstArg && this.currentTokenType == TerminalTokens.TokenNameRPAREN) {
					int idStart = (int) (this.identifierPositionStack[0] >>> 32);
					int idLength = ((int) this.identifierPositionStack[0]) - idStart + 1;
					if (isConstructor) {
						ClassInstanceCreation invocation = this.ast.newClassInstanceCreation();
						invocation.setSourceRange(idStart, idLength);
						invocation.setName(receiver.getName());
						return invocation;
					} else {
						SimpleName methodName = this.ast.newSimpleName(this.identifierStack[0]);
						methodName.setSourceRange(idStart, idLength);
						MethodInvocation invocation = this.ast.newMethodInvocation();
						invocation.setName(methodName);
						invocation.setSourceRange(start, this.scanner.getCurrentTokenEndPosition()-start+1);
						return invocation;
					}
				}
				break nextArg;
			}
			int argStart = type.getStartPosition();
			int argLength = type.getLength();
			iToken++;

			// Read possible array declaration
			if (readToken() == TerminalTokens.TokenNameLBRACKET) {
				while (readToken() == TerminalTokens.TokenNameLBRACKET) {
					consumeToken();
					if (readToken() != TerminalTokens.TokenNameRBRACKET) {
						break nextArg;
					}
					consumeToken();
					type = this.ast.newArrayType(type);
				}
				type.setSourceRange(argStart, this.scanner.getCurrentTokenEndPosition()-argStart+1);
			}

			// Read argument name
			if (readToken() == TerminalTokens.TokenNameIdentifier) {
				consumeToken();
				if (firstArg) { // verify position
					if (iToken != 1)
						break nextArg;
				} else if ((iToken % modulo) != 1) {
						break nextArg;
				}
				if (argName == null) { // verify that all arguments name are declared
					if (!firstArg) {
						break nextArg;
					}
				}
				argName = this.scanner.getCurrentIdentifierSourceAsString();
				argLength = this.scanner.getCurrentTokenEndPosition()-argStart+1;
				iToken++;
			} else if (argName != null) { // verify that no argument name is declared
				break nextArg;
			}
			
			// Verify token position
			if (firstArg) {
				modulo = iToken + 1;
			} else {
				if ((iToken % modulo) != (modulo - 1)) {
					break nextArg;
				}
			}

			// Read separator or end arguments declaration
			int token = readToken();
			String name = argName == null ? new String() : argName;
			if (token == TerminalTokens.TokenNameCOMMA) {
				// Create new argument
				SingleVariableDeclaration variable = this.ast.newSingleVariableDeclaration();
				variable.setSourceRange(argStart, argLength);
				variable.setName(this.ast.newSimpleName(name));
				variable.setType(type);
				JavadocArgument argument = this.ast.newJavadocArgument();
				argument.setSourceRange(argStart, argLength);
				argument.setArgument(variable);
				pushOnAstStack(argument);
				consumeToken();
				iToken++;
			} else if (token == TerminalTokens.TokenNameRPAREN) {
				// Create new argument
				SingleVariableDeclaration variable = this.ast.newSingleVariableDeclaration();
				variable.setSourceRange(argStart, argLength);
				variable.setName(this.ast.newSimpleName(name));
				variable.setType(type);
				JavadocArgument argument = this.ast.newJavadocArgument();
				argument.setSourceRange(argStart, argLength);
				argument.setArgument(variable);
				pushOnAstStack(argument);
				// Build arguments array
				//int size = this.astLengthStack[this.astLengthPtr--];
				ArrayList arguments = new ArrayList(this.astPtr);
				while (this.astPtr >=0) {
					arguments.add(this.astStack[this.astPtr--]);
				}
				// Create message send
				if (isConstructor) {
					ClassInstanceCreation invocation = this.ast.newClassInstanceCreation();
					invocation.setSourceRange(start, this.scanner.getCurrentTokenEndPosition()-start+1);
					invocation.setName(receiver.getName());
					invocation.arguments().addAll(arguments);
					return invocation;
				} else {
					int idStart = (int) (this.identifierPositionStack[0] >>> 32);
					int idLength = ((int) this.identifierPositionStack[0]) - idStart + 1;
					SimpleName methodName = this.ast.newSimpleName(this.identifierStack[0]);
					methodName.setSourceRange(idStart, idLength);
					MethodInvocation invocation = this.ast.newMethodInvocation();
					invocation.setSourceRange(start, this.scanner.getCurrentTokenEndPosition()-start+1);
					invocation.setName(methodName);
					invocation.arguments().addAll(arguments);
					return invocation;
				}
			} else {
				break nextArg;
			}
		}

		// Invalid input: reset ast stacks pointers
		consumeToken();
		if (iToken > 0) {
			this.astPtr = ptr;
			//this.astLengthPtr = lptr;
		}
		throw new InvalidInputException();
	}
	
	private JavadocEmbeddedTag parseEmbeddedTag(int start, int end) throws InvalidInputException {
		// Init specific scanner with text wihtout braces
		int sourceLength = end - (start+1);
		char[] tagSource = new char[sourceLength];
		System.arraycopy(this.source, start+1, tagSource, 0, sourceLength);
		DOMCommentParser parser = new DOMCommentParser(this.ast);
		parser.scanner.setSource(tagSource);
		parser.reset();

		// Read embedded tag identifier
		if (parser.readChar() != '@') {
			throw new InvalidInputException();
		}
		parser.scanner.restartFrom(parser.index);
		if (parser.readTokenAndConsume() != TerminalTokens.TokenNameIdentifier) {
			throw new InvalidInputException();
		}
		
		// Read embedded tag declaration
		JavadocTag tag = null;
		char[] tagName = parser.scanner.getCurrentIdentifierSource();
		parser.skipWhiteChars(false);
		if (CharOperation.equals(tagName, EMBEDDED_TAG_INHERIT_DOC)) {
			if (!parser.scanner.atEnd()) {
				throw new InvalidInputException();
			}
		}
		else if (CharOperation.equals(tagName, EMBEDDED_TAG_LINK) ||
				(CharOperation.equals(tagName, EMBEDDED_TAG_LINKPLAIN)))
		{
			tag = parser.parseSee();
			if (tag == null) {
				throw new InvalidInputException();
			}
			tag.setIdentifier(JavadocTag.NO_IDENTIFIER);
			if (parser.index < parser.scanner.eofPosition) {
				int textStart = parser.index;
				if (parser.currentTokenType == -1) {
					parser.skipWhiteChars(false);
					textStart = parser.index;
				} else {
					if (parser.currentTokenType != TerminalTokens.TokenNameWHITESPACE) {
						textStart = parser.scanner.getCurrentTokenStartPosition();
					}
				}
				tag.setDescription(new String(parser.source, textStart, sourceLength-textStart));
			}
		}
		
		// Build embedded tag
		JavadocEmbeddedTag embeddedTag = this.ast.newJavadocEmbeddedTag();
		embeddedTag.setSourceRange(start, end-start+1);
		embeddedTag.setTag(tag);
		embeddedTag.setIdentifier(new String(tagName));
		return embeddedTag;
	}

	/*
	 * Parse a method reference in @see tag
	 */
	private Expression parseMember(SimpleType receiver) throws InvalidInputException {
		// Init
		this.identifierPtr = -1;
		this.identifierLengthPtr = -1;
		
		// Get type ref
		SimpleType type = receiver;
		if (type == null) {
			type = getEnclosingType();
			if (type == null) {
				return null;
			}
		}
		
		// Get member identifier
		if (readTokenAndConsume() == TerminalTokens.TokenNameIdentifier) {
			pushIdentifier(true);
			if (readTokenAndConsume() == TerminalTokens.TokenNameLPAREN) {
				try {
					return parseArguments(type);
				} catch (InvalidInputException e) {
					// ignore
				}
				return null;
			}
			FieldAccess fieldAccess = this.ast.newFieldAccess();
			fieldAccess.setName(this.ast.newSimpleName(this.identifierStack[0]));
			int idStart = (int) (this.identifierPositionStack[0] >>> 32);
			int idLength = ((int) this.identifierPositionStack[0]) - idStart + 1;
			fieldAccess.setSourceRange(idStart, idLength);
			return fieldAccess;
		}
		return null;
	}

	/*
	 * Parse @param tag declaration
	 */
	private JavadocTag parseParam() {
		try {
			int token = readTokenAndConsume();
			if (token == TerminalTokens.TokenNameIdentifier) {
				JavadocTag tag = this.ast.newJavadocTag();
				tag.setIdentifier(new String(TAG_PARAM));
				SimpleName name = this.ast.newSimpleName(new String(this.scanner.getCurrentIdentifierSource()));
				VariableDeclarationFragment variable = this.ast.newVariableDeclarationFragment();
				variable.setSourceRange(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition()-this.scanner.getCurrentTokenStartPosition()+1);
				variable.setName(name);
				tag.setReference(variable);
				return tag;
			}
		} catch (InvalidInputException e) {
			consumeToken();
		}
		return null;
	}

	/*
	 * Parse a qualified name and built a type reference if the syntax is valid.
	 */
	private Type parseQualifiedName(boolean reset) throws InvalidInputException {

		// Reset identifier stack if requested
		int start = this.scanner.getCurrentTokenStartPosition();
		if (reset) {
			this.identifierPtr = -1;
			this.identifierLengthPtr = -1;
		}

		// Scan tokens
		int typeTokenEnd = -1;
		nextToken : for (int iToken = 0; ; iToken++) {
			int lptr = this.scanner.linePtr;
			int token = readToken();
			switch (token) {
				case TerminalTokens.TokenNameIdentifier :
					if (((iToken % 2) > 0)) { // identifiers must be odd tokens
						break nextToken;
					}
					pushIdentifier(iToken == 0);
					consumeToken();
					typeTokenEnd = this.scanner.getCurrentTokenEndPosition();
					break;

				case TerminalTokens.TokenNameDOT :
					if ((iToken % 2) == 0) { // dots must be even tokens
						throw new InvalidInputException();
					}
					consumeToken();
					break;

				case TerminalTokens.TokenNamevoid :
					if (iToken > 0) throw new InvalidInputException();
					PrimitiveType type = this.ast.newPrimitiveType(PrimitiveType.VOID);
					consumeToken();
					return type;
				case TerminalTokens.TokenNameboolean :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.BOOLEAN);
					consumeToken();
					return type;
				case TerminalTokens.TokenNamebyte :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.BYTE);
					consumeToken();
					return type;
				case TerminalTokens.TokenNamechar :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.CHAR);
					consumeToken();
					return type;
				case TerminalTokens.TokenNamedouble :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.DOUBLE);
					consumeToken();
					return type;
				case TerminalTokens.TokenNamefloat :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.FLOAT);
					consumeToken();
					return type;
				case TerminalTokens.TokenNameint :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.INT);
					consumeToken();
					return type;
				case TerminalTokens.TokenNamelong :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.LONG);
					consumeToken();
					return type;
				case TerminalTokens.TokenNameshort :
					if (iToken > 0) throw new InvalidInputException();
					type = this.ast.newPrimitiveType(PrimitiveType.SHORT);
					consumeToken();
					return type;

				case TerminalTokens.TokenNameWHITESPACE:
					// Ignore white spaces
					if (this.scanner.linePtr > lptr) {
						// Leave if new line was encountered
						break nextToken;
					}
					iToken--;
					consumeToken();
					break;
				default :
					if (iToken == 0) {
						return null;
					}
					if ((iToken % 2) == 0) { // cannot leave on a dot
						throw new InvalidInputException();
					}
					break nextToken;
			}
		}
		
		// We should have stored a end position for the type
		if (typeTokenEnd == -1) {
			throw new InvalidInputException();
		}
		
		// Build type reference from read tokens
		int size = this.identifierLengthStack[this.identifierLengthPtr--];
		String[] identifiers = new String[size];
		int pos = this.identifierPtr - size + 1;
		System.arraycopy(this.identifierStack, pos, identifiers, 0, size);
		SimpleType type = this.ast.newSimpleType( this.ast.newName(identifiers));
		type.setSourceRange(start, typeTokenEnd-start+1);
		this.identifierPtr -= size;
		return type;
	}

	/*
	 * Parse a reference in @see tag
	 */
	private ASTNode parseReference() throws InvalidInputException {
		SimpleType type = null;
		nextToken : while (this.index < this.scanner.eofPosition) {
			int token = readToken();
			int start = this.scanner.getCurrentTokenStartPosition();
			switch (token) {
				case TerminalTokens.TokenNameStringLiteral :
					// @see "string"
					if (type == null) {
						consumeToken();
						try {
							if (readToken() == TerminalTokens.TokenNameEOF) {
								StringLiteral node = this.ast.newStringLiteral();
								node.setLiteralValue(this.scanner.getCurrentTokenSourceAsString());
								node.setSourceRange(start, this.scanner.getCurrentTokenEndPosition()-start+1);
							}
						} catch (InvalidInputException e) {// Do nothing as we want to underline from the beginning of the string
						}
					}
					return null;
				case TerminalTokens.TokenNameLESS :
					// @see <a href="URL#Value">label</a>
					consumeToken();
					return null;
				case TerminalTokens.TokenNameERROR :
					consumeToken();
					if (this.scanner.currentCharacter == '#') { // @see ...#member
						return parseMember(type);
					}
					break nextToken;
				case TerminalTokens.TokenNameIdentifier :
					if (type == null) {
						Type refType = parseQualifiedName(true);
						if (refType instanceof SimpleType) {
							type = (SimpleType) refType;
							break;
						}
					}
				default :
					break nextToken;
			}
		}
		return type;
	}
	
	/*
	 * Parse @return tag declaration
	 */
	private JavadocTag parseTag(String tagName) {
		JavadocTag tag = this.ast.newJavadocTag();
		tag.setIdentifier(tagName);
		return tag;
	}

	/*
	 * Parse @see tag declaration
	 */
	private JavadocTag parseSee() {
		int start = this.scanner.currentPosition;
		try {
			JavadocTag tag = this.ast.newJavadocTag();
			tag.setIdentifier(new String(TAG_SEE));
			ASTNode ref = parseReference();
			if (ref != null) {
				ref.setSourceRange(start, this.scanner.getCurrentTokenEndPosition()-start+1);
				tag.setReference(ref);
				return tag;
			}
		} catch (InvalidInputException ex) {
			// ignore
		}
		return null;
	}

	/*
	 * Parse @throws tag declaration
	 */
	private JavadocTag parseThrows() {
		try {
			JavadocTag tag = this.ast.newJavadocTag();
			tag.setIdentifier(new String(TAG_THROWS));
			Type type = parseQualifiedName(true);
			if (type != null && type instanceof SimpleType) {
				tag.setReference(type);
				return tag;
			}
		} catch (InvalidInputException ex) {
			// ignore
		}
		return null;
	}
	
	/*
	 * push the consumeToken on the identifier stack. Increase the total number of identifier in the stack.
	 */
	private void pushIdentifier(boolean newLength) {

		String identifier = new String(this.scanner.getCurrentTokenSource());
		try {
			this.identifierStack[++this.identifierPtr] = identifier;
			this.identifierPositionStack[this.identifierPtr] = (((long) this.scanner.startPosition) << 32)
					+ (this.scanner.currentPosition - 1);
		} catch (IndexOutOfBoundsException e) {
			//---stack reallaocation (identifierPtr is correct)---
			int oldStackLength = this.identifierStack.length;
			String[] oldStack = this.identifierStack;
			this.identifierStack = new String[oldStackLength + 10];
			System.arraycopy(oldStack, 0, this.identifierStack, 0, oldStackLength);
			this.identifierStack[this.identifierPtr] = identifier;
			// identifier position stack
			long[] oldPos = this.identifierPositionStack;
			this.identifierPositionStack = new long[oldStackLength + 10];
			System.arraycopy(oldPos, 0, this.identifierPositionStack, 0, oldStackLength);
			this.identifierPositionStack[this.identifierPtr] = (((long) this.scanner.startPosition) << 32)
					+ (this.scanner.currentPosition - 1);
		}

		if (newLength) {
			try {
				this.identifierLengthStack[++this.identifierLengthPtr] = 1;
			} catch (IndexOutOfBoundsException e) {
				/* ---stack reallocation (identifierLengthPtr is correct)--- */
				int oldStackLength = this.identifierLengthStack.length;
				int oldStack[] = this.identifierLengthStack;
				this.identifierLengthStack = new int[oldStackLength + 10];
				System.arraycopy(oldStack, 0, this.identifierLengthStack, 0, oldStackLength);
				this.identifierLengthStack[this.identifierLengthPtr] = 1;
			}
		} else {
			this.identifierLengthStack[this.identifierLengthPtr]++;
		}
	}
	
	/*
	 * Add a new obj on top of the ast stack.
	 * If new length is required, then add also a new length in length stack.
	 */
	private void pushOnAstStack(ASTNode node) {

		try {
			this.astStack[++this.astPtr] = node;
		} catch (IndexOutOfBoundsException e) {
			int oldStackLength = this.astStack.length;
			ASTNode[] oldStack = this.astStack;
			this.astStack = new ASTNode[oldStackLength + AstStackIncrement];
			System.arraycopy(oldStack, 0, this.astStack, 0, oldStackLength);
			this.astPtr = oldStackLength;
			this.astStack[this.astPtr] = node;
		}
	}

	/*
	 * Read next char using parser source. Do NOT change scanner current position.
	 */
	private char readChar() {
		char c = this.source[this.index++];
		if (c == '\\') {
			int c1, c2, c3, c4;
			this.index++;
			while (this.source[this.index] == 'u')
				this.index++;
			if (!(((c1 = Character.getNumericValue(this.source[this.index++])) > 15 || c1 < 0)
					|| ((c2 = Character.getNumericValue(this.source[this.index++])) > 15 || c2 < 0)
					|| ((c3 = Character.getNumericValue(this.source[this.index++])) > 15 || c3 < 0) || ((c4 = Character.getNumericValue(this.source[this.index++])) > 15 || c4 < 0))) {
				c = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
			}
		}
		return c;
	}

	/*
	 * Read until the end of the line. If previous token was not consumed,
	 * then push it at the beginning of the line.
	 */
	private boolean readLine(boolean skipStar) throws InvalidInputException {
		//String line = (this.currentTokenType == -1) ? "" : this.scanner.getCurrentTokenSourceAsString(); //$NON-NLS-1$
		//line += this.scanner.getLineEndAsString();
		boolean endComment = this.scanner.skipCommentLine();
		this.index = this.scanner.currentPosition;
		skipWhiteChars(skipStar);
		return endComment;
	}
	
	/*
	 * Read token only if previous was consumed
	 */
	private int readToken() throws InvalidInputException {
		if (this.currentTokenType < 0) {
			this.currentTokenType = this.scanner.getNextToken();
			this.index = this.scanner.currentPosition;
		}
		return this.currentTokenType;
	}
	
	private int readTokenAndConsume() throws InvalidInputException {
		int token = readToken();
		consumeToken();
		return token;
	}
	
	private void reset() {
		this.scanner.embeddedPtr = -1;
		this.source = this.scanner.source;
		this.index = 0;
		this.source = this.scanner.source;
		//this.astLengthPtr = -1;
		this.astPtr = -1;
		this.identifierPtr = -1;
		this.linePtr = -1;
		this.currentTokenType = -1;
	}

	private void setJavadocTagText(JavadocTag javadocTag, int tagStart, int textStart) {
		int textEnd = this.scanner.getCurrentTokenEndPosition();
		if (this.scanner.linePtr > this.linePtr) {
			textEnd = this.scanner.getLineEnd(this.scanner.linePtr+1);
		}
		javadocTag.setSourceRange(tagStart, textEnd-tagStart+1);
		javadocTag.setDescription(new String(this.source, textStart, textEnd-textStart+1));
		this.linePtr = this.scanner.linePtr;
	}

	private void skipWhiteChars(boolean skipStar) {
		while (this.index<this.scanner.eofPosition && ((skipStar && this.source[this.index] == '*') || Character.isWhitespace(this.source[this.index]))) {
			this.scanner.currentCharacter = this.source[this.index];
			readChar();
		}
		this.scanner.currentPosition = this.index;
	}
	
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append(this.comment).append("\n");	//$NON-NLS-1$
		return buffer.toString();
	}
}




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;

/**
 * Specific parser to use while parsing source to create DOM AST nodes.
 */
public class DOMParser extends Parser {
	
	// support for comments
	public int[] commentStops = new int[10];
	public int[] commentStarts = new int[10];
	public int commentPtr = -1; // no comment test with commentPtr value -1
	protected final static int CommentIncrement = 100;
	
	/**
	 * @param problemReporter
	 * @param optimizeStringLiterals
	 */
	public DOMParser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
		super(problemReporter, optimizeStringLiterals);
		this.javadocParser.checkJavadoc = true;
	}

	// old javadoc style check which doesn't include all leading comments into declaration
	// for backward compatibility with 2.1 DOM 
	public void checkComment() {

		if (this.currentElement != null && this.scanner.commentPtr >= 0) {
			flushCommentsDefinedPriorTo(endStatementPosition); // discard obsolete comments
		}
		boolean deprecated = false;
		boolean checkDeprecated = false;
		int lastCommentIndex = -1;
		
		// 
		
		//since jdk1.2 look only in the last java doc comment...
		nextComment : for (lastCommentIndex = scanner.commentPtr; lastCommentIndex >= 0; lastCommentIndex--){
			//look for @deprecated into the first javadoc comment preceeding the declaration
			int commentSourceStart = scanner.commentStarts[lastCommentIndex];
			// javadoc only (non javadoc comment have negative end positions.)
			if ((commentSourceStart < 0) ||
				(modifiersSourceStart != -1 && modifiersSourceStart < commentSourceStart) ||
				(this.scanner.commentStops[lastCommentIndex] < 0))
			{
				continue nextComment;
			}
			checkDeprecated = true;
			int commentSourceEnd = scanner.commentStops[lastCommentIndex] - 1; //stop is one over
			
			deprecated =
			this.javadocParser.checkDeprecation(commentSourceStart, commentSourceEnd);
			this.javadoc = this.javadocParser.javadoc;
			break nextComment;
		}
		if (deprecated) {
			checkAndSetModifiers(AccDeprecated);
		}
		// modify the modifier source start to point at the first comment
		if (lastCommentIndex >= 0 && checkDeprecated) {
			modifiersSourceStart = scanner.commentStarts[lastCommentIndex]; 
			if (modifiersSourceStart < 0) {
				modifiersSourceStart = -modifiersSourceStart;
			}
		}

	}

	
	/* (non-Javadoc)
	 * Save all source comments currently stored before flushing them.
	 * @see org.eclipse.jdt.internal.compiler.parser.Parser#flushCommentsDefinedPriorTo(int)
	 */
	public int flushCommentsDefinedPriorTo(int position) {

		int lastCommentIndex = scanner.commentPtr;
		if (lastCommentIndex < 0) return position; // no comment
	
		// compute the index of the first obsolete comment
		int index = lastCommentIndex;
		int validCount = 0;
		while (index >= 0){
			int commentEnd = scanner.commentStops[index];
			if (commentEnd < 0) commentEnd = -commentEnd; // negative end position for non-javadoc comments
			if (commentEnd <= position){
				break;
			}
			index--;
			validCount++;
		}
		// if the source at <position> is immediately followed by a line comment, then
		// flush this comment and shift <position> to the comment end.
		if (validCount > 0){
			int immediateCommentEnd = -scanner.commentStops[index+1]; //non-javadoc comment end positions are negative
			if (immediateCommentEnd > 0){ // only tolerating non-javadoc comments
				// is there any line break until the end of the immediate comment ? (thus only tolerating line comment)
				immediateCommentEnd--; // comment end in one char too far
				if (scanner.getLineNumber(position) == scanner.getLineNumber(immediateCommentEnd)){
					position = immediateCommentEnd;
					validCount--; // flush this comment
					index++;
				}
			}
		}
	
		if (index < 0) return position; // no obsolete comment
		pushOnCommentsStack(0, index);

		if (validCount > 0){ // move valid comment infos, overriding obsolete comment infos
			System.arraycopy(scanner.commentStarts, index + 1, scanner.commentStarts, 0, validCount);
			System.arraycopy(scanner.commentStops, index + 1, scanner.commentStops, 0, validCount);		
		}
		scanner.commentPtr = validCount - 1;
		return position;
	}

	/*
	 * Push all stored comments in stack.
	 */
	protected void pushOnCommentsStack(int start, int end) {

		for (int i=start; i<=end; i++) {
			try {
				this.commentPtr++;
				this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
				this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
			} catch (IndexOutOfBoundsException e) {
				// this.commentPtr is still correct 
				int oldStackLength = this.commentStarts.length;
				int oldCommentStarts[] = this.commentStarts;
				this.commentStarts = new int[oldStackLength + CommentIncrement];
				System.arraycopy(oldCommentStarts, 0, this.commentStarts, 0, oldStackLength);
				this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
				int oldCommentStops[] = this.commentStops;
				this.commentStops = new int[oldStackLength + CommentIncrement];
				System.arraycopy(oldCommentStops, 0, this.commentStops, 0, oldStackLength);
				this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
			}
		}
	}
	/* (non-Javadoc)
	 * Save all source comments currently stored before flushing them.
	 * @see org.eclipse.jdt.internal.compiler.parser.Parser#resetModifiers()
	 */
	protected void resetModifiers() {
		pushOnCommentsStack(0, this.scanner.commentPtr);
		super.resetModifiers();
	}

	/* (non-Javadoc)
	 * Store comments positions saved in stack in compilation unit declaration.
	 * @see org.eclipse.jdt.internal.compiler.parser.Parser#dietParse(org.eclipse.jdt.internal.compiler.env.ICompilationUnit, org.eclipse.jdt.internal.compiler.CompilationResult)
	 */
	public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {
		CompilationUnitDeclaration unit = super.dietParse(sourceUnit, compilationResult);
		unit.comments = getCommentsPositions();
		return unit;
	}

	/* (non-Javadoc)
	 * Insure that start position is always positive.
	 * @see org.eclipse.jdt.internal.compiler.parser.Parser#containsComment(int, int)
	 */
	public boolean containsComment(int sourceStart, int sourceEnd) {
		int iComment = this.scanner.commentPtr;
		for (; iComment >= 0; iComment--) {
			int commentStart = this.scanner.commentStarts[iComment];
			if (commentStart < 0) {
				commentStart = -commentStart;
			}
			// ignore comments before start
			if (commentStart < sourceStart) continue;
			// ignore comments after end
			if (commentStart > sourceEnd) continue;
			return true;
		}
		return false;
	}

	/*
	 * Build a n*2 matrix of comments positions.
	 * For each position, 0 is for start position and 1 for end position of the comment.
	 */
	public int[][] getCommentsPositions() {
		int[][] positions = new int[this.commentPtr+1][2];
		for (int i = 0, max = this.commentPtr; i <= max; i++){
			positions[i][0] = this.commentStarts[i];
			positions[i][1] = this.commentStops[i];
		}
		return positions;
	}
	
	/* (non-Javadoc)
	 * Create and store a specific DOM scanner.
	 * @see org.eclipse.jdt.internal.compiler.parser.Parser#initializeScanner()
	 */
	public void initializeScanner() {
		this.scanner = new DOMScanner(
				false /*comment*/, 
				false /*whitespace*/, 
				this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /*nls*/, 
				this.options.sourceLevel /*sourceLevel*/, 
				this.options.taskTags/*taskTags*/,
				this.options.taskPriorites/*taskPriorities*/);
	}

}




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.parser.Scanner;

/**
 * Specialized scanner for DOM AST nodes.
 */
public class DOMScanner extends Scanner {

	// Tell whether an end of comment was reached
	public int embeddedPtr = -1;
	public int[] embeddedTagStarts = new int[10];
	public int[] embeddedTagStops = new int[10];
	
	public DOMScanner() {
		super();
	}

	public DOMScanner(
		boolean tokenizeComments,
		boolean tokenizeWhiteSpace,
		boolean checkNonExternalizedStringLiterals,
		long sourceLevel,
		char[][] taskTags,
		char[][] taskPriorities) {
		super(tokenizeComments, tokenizeWhiteSpace, checkNonExternalizedStringLiterals, sourceLevel, taskTags, taskPriorities);
	}
	
	/*(non-Javadoc)
	 * Return the current token source as a string. Do not call getCurrentTokenSourceString()
	 * method of superclass in order to avoid unnecessary array copy.
	 * @see org.eclipse.jdt.internal.compiler.parser.Scanner#getCurrentTokenSource()
	 */
	public final String getCurrentTokenSourceAsString() {
		//return the token REAL source (aka unicodes are precomputed).

		if (this.withoutUnicodePtr != 0) {
			//0 is used as a fast test flag so the real first char is in position 1
			return new String(this.withoutUnicodeBuffer, 0, this.withoutUnicodePtr);
		} else {
			if (this.currentPosition < this.startPosition) {
				return "";	//$NON-NLS-1$
			}
			return new String(this.source, this.startPosition, this.currentPosition - this.startPosition);
		}
	}
	
	/*(non-Javadoc)
	 * Return the current identifier source as a string. Do not call getCurrentTokenSourceString()
	 * method of superclass in order to avoid unnecessary array copy.
	 * @see org.eclipse.jdt.internal.compiler.parser.Scanner#getCurrentIdentifierSource()
	 */
	public String getCurrentIdentifierSourceAsString() {
		//return the token REAL source (aka unicodes are precomputed)
	
		if (this.withoutUnicodePtr != 0) {
			//0 is used as a fast test flag so the real first char is in position 1
			return new String(this.withoutUnicodeBuffer, 1, this.withoutUnicodePtr); 
		} else {
			int length = this.currentPosition - this.startPosition;
			//no optimization
			return new String(this.source, this.startPosition, length);
		}
	}

	/*
	 * Return the source until the end of current line.
	 *
	public String getLineEndAsString() {
		this.endComment = false;
		int start = this.currentPosition;
		int end = this.currentPosition;
		boolean star = false;
		while ((this.currentCharacter != '\r') && (this.currentCharacter != '\n')) {
			if (star && this.currentCharacter == '/') {
				this.endComment = true;
				break;
			}
			star = this.currentCharacter == '*';
			end = this.currentPosition;
			getNextChar();
		}
		int length = end - start;
		if ((this.currentCharacter == '\r') || (this.currentCharacter == '\n')) {
			pushLineSeparator();
			this.lineEnds[this.linePtr] = end - 1;
		}
		if (length > 0) {
			return new String(source, start, length);
		} else {
			return "";	//$NON-NLS-1$
		}
	}

	/*
	 * Skip a line in a comment. Returns an positions array of possible embedded tags.
	 * Also store whether the end of comment has been reached or not.
	 */
	public boolean skipCommentLine() throws InvalidInputException {
		boolean endComment = this.currentCharacter == '*';
		int endLine = this.currentPosition;
		if ((this.currentCharacter == '\r') || (this.currentCharacter == '\n')) {
			endLine--;
		}
		int startEmbedded = this.currentCharacter == '{' ? this.getCurrentTokenStartPosition() : this.currentPosition;
		while ((this.currentPosition < this.eofPosition) && (this.currentCharacter != '\r') && (this.currentCharacter != '\n')) {
			if (endComment && this.currentCharacter == '/') {
				break;
			}
			endComment = false;
			if (this.currentCharacter == '{') {
				int endEmbedded = this.currentPosition;
				getNextChar();
				if ((this.currentPosition >= this.eofPosition) ||
					(this.currentCharacter == '\r') ||
					(this.currentCharacter == '\n')) {
					// End of text of new line was found before end of embedded tag => break from loop
					break;
				}
				if (this.currentCharacter == '@') {
					while ((this.currentCharacter != '}')) {
						if (((endComment && this.currentCharacter == '/')) ||
							(this.currentPosition >= this.eofPosition) ||
							(this.currentCharacter == '\r') ||
							(this.currentCharacter == '\n')) {
							// End of text of new line was found before end of embedded tag => the text is not valid
							throw new InvalidInputException();
						}
						endEmbedded = this.currentPosition;
						endComment = this.currentCharacter == '*';
						getNextChar();
					}
					recordEmbeddedTag(startEmbedded, endEmbedded);
				}
			}
			endComment = this.currentCharacter == '*';
			endLine = this.currentPosition;
			startEmbedded = this.currentPosition;
			getNextChar();
		}
		if ((this.currentCharacter == '\r') || (this.currentCharacter == '\n')) {
			pushLineSeparator();
			this.lineEnds[this.linePtr] = endLine - 1;
		}
		return endComment;
	}
	
	/* (non-Javadoc)
	 * Set start position negative for line comments.
	 * @see org.eclipse.jdt.internal.compiler.parser.Scanner#recordComment(boolean)
	 */
	public void recordComment(int token) {
		super.recordComment(token);
		if (token == TokenNameCOMMENT_LINE) {
			// for comment line both positions are negative
			this.commentStarts[this.commentPtr] = -this.commentStarts[this.commentPtr];
		}
	}

	public void recordEmbeddedTag(int start, int end) {

		// a new comment is recorded
		try {
			this.embeddedTagStops[++this.embeddedPtr] = end;
		} catch (IndexOutOfBoundsException e) {
			int oldStackLength = this.embeddedTagStops.length;
			int[] oldStack = this.embeddedTagStops;
			this.embeddedTagStops = new int[oldStackLength + 10];
			System.arraycopy(oldStack, 0, this.embeddedTagStops, 0, oldStackLength);
			this.embeddedTagStops[this.embeddedPtr] = end;
			//grows the positions buffers too
			int[] old = this.embeddedTagStarts;
			this.embeddedTagStarts = new int[oldStackLength + 10];
			System.arraycopy(old, 0, this.embeddedTagStarts, 0, oldStackLength);
		}

		//the buffer is of a correct size here
		this.embeddedTagStarts[this.embeddedPtr] = start;
	}
	
	/*(non-Javadoc)
	 * Reset initial, start and current positions.
	 * @see org.eclipse.jdt.internal.compiler.parser.Scanner#resetTo(int, int)
	 */
	public void restartFrom(int begin) {
		this.initialPosition = this.startPosition = this.currentPosition = begin;
		this.embeddedPtr = -1;
	}

}




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

/**
 */
public class JavadocArgument extends Expression {
	public SingleVariableDeclaration argument;
	
	/**
	 * @param ast
	 */
	public JavadocArgument(AST ast) {
		super(ast);
		}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#getNodeType()
	 */
	public int getNodeType() {
		return JAVADOC_ARGUMENT;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
	 */
	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
		return matcher.match(this, other);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
	 */
	ASTNode clone(AST target) {
		JavadocArgument result = new JavadocArgument(target);
		result.setSourceRange(this.getStartPosition(), this.getLength());
		result.setArgument(getArgument());
		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#accept0(org.eclipse.jdt.core.dom.ASTVisitor)
	 */
	void accept0(ASTVisitor visitor) {
		visitor.visit(this);
		visitor.endVisit(this);
		
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
	 */
	int treeSize() {
		return this.argument==null?0:this.argument.treeSize();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#memSize()
	 */
	int memSize() {
		return BASE_NODE_SIZE + 4;
	}

	/**
	 * @return Returns the argument.
	 */
	public SingleVariableDeclaration getArgument() {
		return this.argument;
	}

	/**
	 * @param argument The argument to set.
	 */
	public void setArgument(SingleVariableDeclaration argument) {
		this.argument = argument;
	}

}




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

/**
 */
public class JavadocEmbeddedTag extends ASTNode {

	/**
	 * An unspecified (but externally observable) legal Javadoc tag identifier.
	 */
	private static final String MISSING_IDENTIFIER = "";//$NON-NLS-1$

	/**
	 * The identifier; defaults to a unspecified, legal Java identifier.
	 */
	String identifier = MISSING_IDENTIFIER;
	
	/**
	 * An other Javadoc tag the embedded tag refers to; defaults is null
	 */
	JavadocTag tag;
	
	/**
	 * @param ast
	 */
	public JavadocEmbeddedTag(AST ast) {
		super(ast);
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	void accept0(ASTVisitor visitor) {
		visitor.visit(this);
		visitor.endVisit(this);
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	public int getNodeType() {
		return JAVADOC_EMBEDDED_TAG;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
	 */
	ASTNode clone(AST target) {
		JavadocEmbeddedTag result = new JavadocEmbeddedTag(target);
		result.setSourceRange(this.getStartPosition(), this.getLength());
		result.setIdentifier(this.identifier);
		result.setTag(this.tag);
		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#memSize()
	 */
	int memSize() {
		int size = BASE_NODE_SIZE;
		if (this.identifier!= null) {
			// Strings usually have 4 instance fields, one of which is a char[]
			size += HEADERS + 4 * 4;
			// char[] has 2 bytes per character
			size += HEADERS + 2 * this.identifier.length();
		}
		size += 4;	// tag
		return size;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
	 */
	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
		return matcher.match(this, other);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
	 */
	int treeSize() {
		return memSize() + this.tag.treeSize();
	}
	
	/**
	 * @return Returns the name.
	 */
	public String getIdentifier() {
		return this.identifier;
	}

	/**
	 * @param id The name to set.
	 */
	public void setIdentifier(String id) {
		if (id == null) {
			throw new IllegalArgumentException();
		}
		modifying();
		this.identifier = id;
	}
	
	/**
	 * @return Returns the tag.
	 */
	public JavadocTag getTag() {
		return this.tag;
	}

	/**
	 * @param tag The tag to set.
	 */
	public void setTag(JavadocTag tag) {
		if (tag == null) {
			throw new IllegalArgumentException();
		}
		replaceChild(this.tag, tag, false);
		this.tag = tag;
	}

}




/*******************************************************************************
 * 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 org.eclipse.jdt.core.dom;

import java.util.List;


/**
 * AST node for a Javadoc tag of a comment.
 * 
 * @since 3.0
 */
public class JavadocTag extends ASTNode {

	/**
	 * An unspecified (but externally observable) legal Javadoc tag identifier.
	 */
	static final String NO_IDENTIFIER = "";//$NON-NLS-1$

	/**
	 * The identifier; defaults to a unspecified, legal Java identifier.
	 */
	String identifier = NO_IDENTIFIER;

	/**
	 * An other AST node the tag refers to; defaults is null
	 */
	ASTNode reference;
	
	String description = ""; //$NON-NLS-1$

	/**
	 * The embedded tags included in the tag description (element type: <code>JavadocTag</code>).
	 * Defaults to none.
	 */
	ASTNode.NodeList embedded = new ASTNode.NodeList(true, JavadocEmbeddedTag.class);
	

	/**
	 * Creates a new AST node for a Javadoc tag owned by the given Javadoc comment.
	 * The new node has an unspecified, but legal, Javadoc comment.
	 * <p>
	 * N.B. This constructor is package-private; all subclasses must be 
	 * declared in the same package; clients are unable to declare 
	 * additional subclasses.
	 * </p>
	 * 
	 * @param ast the AST that is to own this node
	 */
	JavadocTag(AST ast) {
		super(ast);
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	void accept0(ASTVisitor visitor) {
		visitor.visit(this);
		visitor.endVisit(this);
	}

	/* (omit javadoc for this method)
	 * Method declared on ASTNode.
	 */
	public int getNodeType() {
		return JAVADOC_TAG;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
	 */
	ASTNode clone(AST target) {
		JavadocTag result = new JavadocTag(target);
		result.setSourceRange(this.getStartPosition(), this.getLength());
		result.setIdentifier(this.identifier);
		result.setDescription(getDescription());
		result.setReference(getReference());
		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#memSize()
	 */
	int memSize() {
		int size = BASE_NODE_SIZE;
		if (this.identifier!= null) {
			// Strings usually have 4 instance fields, one of which is a char[]
			size += HEADERS + 4 * 4;
			// char[] has 2 bytes per character
			size += HEADERS + 2 * this.identifier.length();
		}
		size += 4;	// reference
		if (this.description!= null) {
			// Strings usually have 4 instance fields, one of which is a char[]
			size += HEADERS + 4 * 4;
			// char[] has 2 bytes per character
			size += HEADERS + 2 * this.description.length();
		}
		size += 4;	// embedded
		return size;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
	 */
	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
		return matcher.match(this, other);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
	 */
	int treeSize() {
		return memSize()
			+ (this.reference == null ? 0 : this.reference.treeSize())
			+ (this.embedded == null ? 0 : this.embedded.listSize());
	}

	/**
	 * @return Returns the reference.
	 */
	public ASTNode getReference() {
		return this.reference;
	}

	/**
	 * @param reference The reference to set.
	 */
	public void setReference(ASTNode reference) {
		if (reference == null) {
			throw new IllegalArgumentException();
		}
		replaceChild(this.reference, reference, false);
		this.reference = reference;
	}
	
	/**
	 * @return Returns the name.
	 */
	public String getIdentifier() {
		return this.identifier;
	}

	/**
	 * @param id The name to set.
	 */
	public void setIdentifier(String id) {
		if (id == null) {
			throw new IllegalArgumentException();
		}
		modifying();
		this.identifier = id;
	}

	/**
	 * @return Returns the text.
	 */
	public String getDescription() {
		return this.description;
	}

	/**
	 * @param text The text to set.
	 */
	public void setDescription(String text) {
		if (text == null) {
			throw new IllegalArgumentException();
		}
		modifying();
		this.description = text;
	}

	/**
	 * @return Returns the tagDeclarations.
	 */
	public List embedded() {
		return this.embedded;
	}
}

Return to bug 27134

Lines 544-550 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionScanner.java (-3 / +7 lines)
544	currentPosition++;	544	currentPosition++;
545	} //jump over the \\	545	} //jump over the \\
546	}	546	}
547	recordComment(false);	547	recordComment(TokenNameCOMMENT_LINE);
548	if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){	548	if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){
549	throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);	549	throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);
550	}	550	}
Lines 556-562 Link Here
556	return TokenNameCOMMENT_LINE;	556	return TokenNameCOMMENT_LINE;
557	}	557	}
558	} catch (IndexOutOfBoundsException e) {	558	} catch (IndexOutOfBoundsException e) {
559	recordComment(false);	559	recordComment(TokenNameCOMMENT_LINE);
560	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition-1);	560	if (this.taskTags != null) checkTaskTag(this.startPosition, this.currentPosition-1);
561	if (tokenizeComments) {	561	if (tokenizeComments) {
562	this.currentPosition--; // reset one character behind	562	this.currentPosition--; // reset one character behind
Lines 650-663 Link Here
650	currentPosition++;	650	currentPosition++;
651	} //jump over the \\	651	} //jump over the \\
652	}	652	}
653	recordComment(isJavadoc);	653	int token = isJavadoc ? TokenNameCOMMENT_JAVADOC : TokenNameCOMMENT_BLOCK;
		654	recordComment(token);
654	if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){	655	if (startPosition <= cursorLocation && cursorLocation < currentPosition-1){
655	throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);	656	throw new InvalidCursorLocation(InvalidCursorLocation.NO_COMPLETION_INSIDE_COMMENT);
656	}	657	}
657	if (tokenizeComments) {	658	if (tokenizeComments) {
		659	/*
658	if (isJavadoc)	660	if (isJavadoc)
659	return TokenNameCOMMENT_JAVADOC;	661	return TokenNameCOMMENT_JAVADOC;
660	return TokenNameCOMMENT_BLOCK;	662	return TokenNameCOMMENT_BLOCK;
		663	*/
		664	return token;
661	}	665	}
662	} catch (IndexOutOfBoundsException e) {	666	} catch (IndexOutOfBoundsException e) {
663	throw new InvalidInputException(UNTERMINATED_COMMENT);	667	throw new InvalidInputException(UNTERMINATED_COMMENT);

Lines 108-114 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTNode.java (-17 / +78 lines)
108	* problem (support for this is planned for a future release).	108	* problem (support for this is planned for a future release).
109	* </p>	109	* </p>
110	*	110	*
111	* @see AST#parseCompilationUnit	111	* @see AST#parseCompilationUnit(char[]) and other similar methods
112	* @see ASTVisitor	112	* @see ASTVisitor
113	* @since 2.0	113	* @since 2.0
114	*/	114	*/
Lines 549-554 Link Here
549	public static final int INSTANCEOF_EXPRESSION = 62;	549	public static final int INSTANCEOF_EXPRESSION = 62;
550		550
551	/**	551	/**
		552	* Node type constant indicating a node of type
		553	* <code>Comment</code>.
		554	* @see Comment
		555	*/
		556	public static final int COMMENT = 63;
		557
		558	/**
		559	* Node type constant indicating a node of type
		560	* <code>JavadocTag</code>.
		561	* @see JavadocTag
		562	*/
		563	public static final int JAVADOC_TAG = 64;
		564
		565	/**
		566	* Node type constant indicating a node of type
		567	* <code>JavadocTag</code>.
		568	* @see JavadocTag
		569	*/
		570	public static final int JAVADOC_EMBEDDED_TAG = 65;
		571
		572	/**
		573	* Node type constant indicating a node of type
		574	* <code>JavadocTag</code>.
		575	* @see JavadocTag
		576	*/
		577	public static final int JAVADOC_ARGUMENT = 66;
		578
		579	/**
552	* Owning AST.	580	* Owning AST.
553	*/	581	*/
554	private final AST owner;	582	private final AST owner;
Lines 562-568 Link Here
562	/**	590	/**
563	* An unmodifiable empty map (used to implement <code>properties()</code>).	591	* An unmodifiable empty map (used to implement <code>properties()</code>).
564	*	592	*
565	* @see #properties	593	* @see #properties()
566	*/	594	*/
567	private static Map UNMODIFIABLE_EMPTY_MAP	595	private static Map UNMODIFIABLE_EMPTY_MAP
568	= Collections.unmodifiableMap(new HashMap(1));	596	= Collections.unmodifiableMap(new HashMap(1));
Lines 927-933 Link Here
927	public ASTNode getParent() {	955	public ASTNode getParent() {
928	return parent;	956	return parent;
929	}	957	}
930		958
931	/**	959	/**
932	* Returns the root node at or above this node; returns this node if	960	* Returns the root node at or above this node; returns this node if
933	* it is a root.	961	* it is a root.
Lines 947-952 Link Here
947	}	975	}
948		976
949	/**	977	/**
		978	* Returns the compilation unit which owns this node; returns this node if
		979	* it is a compilation unit or null if none was found.
		980	*
		981	* @return the compilation unit node founds in node hierarchy or null if none was found
		982	*/
		983	public CompilationUnit getCompilationUnit() {
		984	ASTNode candidate = this;
		985	while (candidate != null) {
		986	if (candidate instanceof CompilationUnit) {
		987	return (CompilationUnit) candidate;
		988	}
		989	candidate = candidate.getParent();
		990	}
		991	return null;
		992	}
		993
		994	/**
950	* Internal callback indicating that a field of this node is about to	995	* Internal callback indicating that a field of this node is about to
951	* be modified.	996	* be modified.
952	*/	997	*/
Lines 1062-1068 Link Here
1062	*	1107	*
1063	* @param propertyName the property name	1108	* @param propertyName the property name
1064	* @return the property value, or <code>null</code> if none	1109	* @return the property value, or <code>null</code> if none
1065	* @see #setProperty	1110	* @see #setProperty(String, Object)
1066	*/	1111	*/
1067	public Object getProperty(String propertyName) {	1112	public Object getProperty(String propertyName) {
1068	if (propertyName == null) {	1113	if (propertyName == null) {
Lines 1102-1108 Link Here
1102	*	1147	*
1103	* @param propertyName the property name	1148	* @param propertyName the property name
1104	* @param data the new property value, or <code>null</code> if none	1149	* @param data the new property value, or <code>null</code> if none
1105	* @see #getProperty	1150	* @see #getProperty(String)
1106	*/	1151	*/
1107	public void setProperty(String propertyName, Object data) {	1152	public void setProperty(String propertyName, Object data) {
1108	if (propertyName == null) {	1153	if (propertyName == null) {
Lines 1208-1214 Link Here
1208	* </p>	1253	* </p>
1209	*	1254	*
1210	* @return the bitwise-or of individual flags	1255	* @return the bitwise-or of individual flags
1211	* @see #setFlags	1256	* @see #setFlags(int)
1212	* @see #MALFORMED	1257	* @see #MALFORMED
1213	*/	1258	*/
1214	public int getFlags() {	1259	public int getFlags() {
Lines 1228-1234 Link Here
1228	* </p>	1273	* </p>
1229	*	1274	*
1230	* @param flags the bitwise-or of individual flags	1275	* @param flags the bitwise-or of individual flags
1231	* @see #getFlags	1276	* @see #getFlags()
1232	* @see #MALFORMED	1277	* @see #MALFORMED
1233	*/	1278	*/
1234	public void setFlags(int flags) {	1279	public void setFlags(int flags) {
Lines 1438-1448 Link Here
1438	*	1483	*
1439	* @return the 0-based character index, or <code>-1</code>	1484	* @return the 0-based character index, or <code>-1</code>
1440	* if no source position information is recorded for this node	1485	* if no source position information is recorded for this node
1441	* @see #getLength	1486	* @see #getLength()
1442	* @see AST#parseCompilationUnit	1487	* @see AST#parseCompilationUnit
1443	*/	1488	*/
1444	public int getStartPosition() {	1489	public int getStartPosition() {
1445	return startPosition;	1490	return this.startPosition;
		1491	}
		1492
		1493	/**
		1494	* Returns the character index into the original source file indicating
		1495	* where the source fragment corresponding to this node ends.
		1496	*
		1497	* @return the 0-based character index, or <code>-1</code>
		1498	* if no source position information is recorded for this node
		1499	* @see #getLength()
		1500	*/
		1501	public int getEndPosition() {
		1502	if (this.length==0) {
		1503	return -1;
		1504	}else {
		1505	return this.startPosition+this.length-1;
		1506	}
1446	}	1507	}
1447		1508
1448	/**	1509	/**
Lines 1460-1466 Link Here
1460	* @see AST#parseCompilationUnit	1521	* @see AST#parseCompilationUnit
1461	*/	1522	*/
1462	public int getLength() {	1523	public int getLength() {
1463	return length;	1524	return this.length;
1464	}	1525	}
1465		1526
1466	/**	1527	/**
Lines 1477-1484 Link Here
1477	* @param length a (possibly 0) length,	1538	* @param length a (possibly 0) length,
1478	* or <code>0</code> if no source position information is recorded	1539	* or <code>0</code> if no source position information is recorded
1479	* for this node	1540	* for this node
1480	* @see #getStartPosition	1541	* @see #getStartPosition()
1481	* @see #getLength	1542	* @see #getLength()
1482	* @see AST#parseCompilationUnit	1543	* @see AST#parseCompilationUnit
1483	*/	1544	*/
1484	public void setSourceRange(int startPosition, int length) {	1545	public void setSourceRange(int startPosition, int length) {
Lines 1537-1543 Link Here
1537	// print the subtree by default	1598	// print the subtree by default
1538	appendPrintString(buffer);	1599	appendPrintString(buffer);
1539	}	1600	}
1540		1601
1541	/**	1602	/**
1542	* Appends a standard Java source code representation of this subtree to the given	1603	* Appends a standard Java source code representation of this subtree to the given
1543	* string buffer.	1604	* string buffer.
Lines 1549-1567 Link Here
1549	this.accept(printer);	1610	this.accept(printer);
1550	buffer.append(printer.getResult());	1611	buffer.append(printer.getResult());
1551	}	1612	}
1552		1613
1553	/**	1614	/**
1554	* Estimate of size of an object header in bytes.	1615	* Estimate of size of an object header in bytes.
1555	*/	1616	*/
1556	static final int HEADERS = 12;	1617	static final int HEADERS = 12;
1557		1618
1558	/**	1619	/**
1559	* Approximate base size of an AST node instance in bytes,	1620	* Approximate base size of an AST node instance in bytes,
1560	* including object header and instance fields.	1621	* including object header and instance fields.
1561	* That is, HEADERS + (# instance vars in ASTNode)*4.	1622	* That is, HEADERS + (# instance vars in ASTNode)*4.
1562	*/	1623	*/
1563	static final int BASE_NODE_SIZE = HEADERS + 7 * 4;	1624	static final int BASE_NODE_SIZE = HEADERS + 7 * 4;
1564		1625
1565	/**	1626	/**
1566	* Returns an estimate of the memory footprint in bytes of the entire	1627	* Returns an estimate of the memory footprint in bytes of the entire
1567	* subtree rooted at this node.	1628	* subtree rooted at this node.
Lines 1571-1577 Link Here
1571	public final int subtreeBytes() {	1632	public final int subtreeBytes() {
1572	return treeSize();	1633	return treeSize();
1573	}	1634	}
1574		1635
1575	/**	1636	/**
1576	* Returns an estimate of the memory footprint in bytes of the entire	1637	* Returns an estimate of the memory footprint in bytes of the entire
1577	* subtree rooted at this node.	1638	* subtree rooted at this node.

Lines 40-46 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTMatcher.java (-3 / +34 lines)
40	* matchers.	40	* matchers.
41	* </p>	41	* </p>
42	*	42	*
43	* @see ASTNode#subtreeMatch	43	* @see ASTNode#subtreeMatch(ASTMatcher, Object)
44	* @since 2.0	44	* @since 2.0
45	*/	45	*/
46	public class ASTMatcher {	46	public class ASTMatcher {
Lines 838-851 Link Here
838	* <code>false</code> if they do not match or the other object has a	838	* <code>false</code> if they do not match or the other object has a
839	* different node type or is <code>null</code>	839	* different node type or is <code>null</code>
840	*/	840	*/
		841	public boolean match(Comment node, Object other) {
		842	if (!(other instanceof Comment)) {
		843	return false;
		844	}
		845	Comment o = (Comment) other;
		846	return safeSubtreeListMatch(node.tags(), o.tags());
		847	}
841	public boolean match(Javadoc node, Object other) {	848	public boolean match(Javadoc node, Object other) {
842	if (!(other instanceof Javadoc)) {	849	if (!(other instanceof Javadoc)) {
843	return false;	850	return false;
844	}	851	}
845	Javadoc o = (Javadoc) other;	852	Javadoc o = (Javadoc) other;
846	return safeEquals(node.getComment(), o.getComment());	853	return safeSubtreeListMatch(node.tags(), o.tags());
847	}	854	}
848		855	public boolean match(JavadocTag node, Object other) {
		856	if (!(other instanceof JavadocTag)) {
		857	return false;
		858	}
		859	JavadocTag o = (JavadocTag) other;
		860	return (node.getIdentifier().equals(o.getIdentifier()) &&
		861	safeEquals(node.getDescription(), o.getDescription()) &&
		862	safeSubtreeMatch(node.getReference(), o.getReference()));
		863	}
		864	public boolean match(JavadocEmbeddedTag node, Object other) {
		865	if (!(other instanceof JavadocEmbeddedTag)) {
		866	return false;
		867	}
		868	JavadocEmbeddedTag o = (JavadocEmbeddedTag) other;
		869	return (node.getIdentifier().equals(o.getIdentifier()) &&
		870	safeSubtreeMatch(node.getTag(), o.getTag()));
		871	}
		872	public boolean match(JavadocArgument node, Object other) {
		873	if (!(other instanceof JavadocArgument)) {
		874	return false;
		875	}
		876	JavadocArgument o = (JavadocArgument) other;
		877	return (node.getArgument().equals(o.getArgument()));
		878	}
		879
849	/**	880	/**
850	* Returns whether the given node and the other object match.	881	* Returns whether the given node and the other object match.
851	* <p>	882	* <p>

Lines 72-80 Link Here

(-)dom/org/eclipse/jdt/core/dom/BodyDeclaration.java (-1 / +9 lines)
72	* Returns the Javadoc comment node.	72	* Returns the Javadoc comment node.
73	*	73	*
74	* @return the javadoc comment node, or <code>null</code> if none	74	* @return the javadoc comment node, or <code>null</code> if none
		75	* TODO (frederic) See if it could be interesting to store the javadoc comment instead of looking for it systematically...
75	*/	76	*/
76	public Javadoc getJavadoc() {	77	public Javadoc getJavadoc() {
77	return optionalJavadoc;	78	CompilationUnit unit = getCompilationUnit();
		79	if (unit != null) {
		80	Comment comment = unit.getComment(getStartPosition());
		81	if (comment != null && comment.isJavadoc()) {
		82	return (Javadoc) comment;
		83	}
		84	}
		85	return this.optionalJavadoc;
78	}	86	}
79		87
80	/**	88	/**

Lines 11-32 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java (-61 / +19 lines)
11		11
12	package org.eclipse.jdt.core.dom;	12	package org.eclipse.jdt.core.dom;
13		13
14	import org.eclipse.jdt.internal.compiler.Compiler;	14	import java.util.Map;
15	import org.eclipse.jdt.internal.compiler.*;	15
16	import org.eclipse.jdt.internal.compiler.env.*;
17	import org.eclipse.jdt.core.ICompilationUnit;
18	import org.eclipse.jdt.core.*;	16	import org.eclipse.jdt.core.*;
19	import org.eclipse.jdt.core.compiler.*;	17	import org.eclipse.jdt.core.compiler.CharOperation;
20	import org.eclipse.jdt.internal.core.*;	18	import org.eclipse.jdt.internal.compiler.*;
21	import org.eclipse.jdt.internal.compiler.impl.*;	19	import org.eclipse.jdt.internal.compiler.Compiler;
22	import org.eclipse.jdt.internal.compiler.ast.*;	20	import org.eclipse.jdt.internal.compiler.ast.*;
		21	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
		22	import org.eclipse.jdt.internal.compiler.env.ISourceType;
		23	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
23	import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;	24	import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;
24	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;	25	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
25	import org.eclipse.jdt.internal.compiler.parser.Parser;
26	import org.eclipse.jdt.internal.compiler.parser.SourceTypeConverter;	26	import org.eclipse.jdt.internal.compiler.parser.SourceTypeConverter;
27	import org.eclipse.jdt.internal.compiler.problem.*;	27	import org.eclipse.jdt.internal.compiler.problem.*;
28		28	import org.eclipse.jdt.internal.core.*;
29	import java.util.*;
30		29
31	class CompilationUnitResolver extends Compiler {	30	class CompilationUnitResolver extends Compiler {
32		31
Lines 77-82 Link Here
77		76
78	/**	77	/**
79	* Add additional source types	78	* Add additional source types
		79	* @param sourceTypes
		80	* @param packageBinding
80	*/	81	*/
81	public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {	82	public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
82	CompilationResult result =	83	CompilationResult result =
Lines 97-146 Link Here
97	}	98	}
98	}	99	}
99		100
100	private static Parser createDomParser(ProblemReporter problemReporter) {
101
102	return new Parser(problemReporter, false) {
103	// old annotation style check which doesn't include all leading comments into declaration
104	// for backward compatibility with 2.1 DOM
105	public void checkComment() {
106
107	if (this.currentElement != null && this.scanner.commentPtr >= 0) {
108	flushCommentsDefinedPriorTo(endStatementPosition); // discard obsolete comments
109	}
110	boolean deprecated = false;
111	boolean checkDeprecated = false;
112	int lastCommentIndex = -1;
113
114	//since jdk1.2 look only in the last java doc comment...
115	//look for @deprecated into the first javadoc comment preceeding the declaration
116	int commentSourceStart = scanner.commentStarts[lastCommentIndex];
117	// javadoc only (non javadoc comment have negative end positions.)
118	if (modifiersSourceStart != -1 && modifiersSourceStart < commentSourceStart) {
119	continue nextComment;
120	}
121	if (scanner.commentStops[lastCommentIndex] < 0) {
122	continue nextComment;
123	}
124	checkDeprecated = true;
125	int commentSourceEnd = scanner.commentStops[lastCommentIndex] - 1; //stop is one over
126
127	deprecated =
128	this.javadocParser.checkDeprecation(commentSourceStart, commentSourceEnd);
129	this.javadoc = this.javadocParser.javadoc;
130	break nextComment;
131	}
132	if (deprecated) {
133	checkAndSetModifiers(AccDeprecated);
134	}
135	// modify the modifier source start to point at the first comment
136	if (lastCommentIndex >= 0 && checkDeprecated) {
137	modifiersSourceStart = scanner.commentStarts[lastCommentIndex];
138	}
139
140	}
141	};
142	}
143		101
144	/*	102	/*
145	* Low-level API performing the actual compilation	103	* Low-level API performing the actual compilation
Lines 185-191 Link Here
185	* @see org.eclipse.jdt.internal.compiler.Compiler#initializeParser()	142	* @see org.eclipse.jdt.internal.compiler.Compiler#initializeParser()
186	*/	143	*/
187	public void initializeParser() {	144	public void initializeParser() {
188	this.parser = createDomParser(this.problemReporter);	145	this.parser = new DOMParser(this.problemReporter, false);
189	}	146	}
190	/*	147	/*
191	* Compiler crash recovery in case of unexpected runtime exceptions	148	* Compiler crash recovery in case of unexpected runtime exceptions
Lines 260-270 Link Here
260	throw new IllegalArgumentException();	217	throw new IllegalArgumentException();
261	}	218	}
262	CompilerOptions compilerOptions = new CompilerOptions(settings);	219	CompilerOptions compilerOptions = new CompilerOptions(settings);
263	Parser parser = createDomParser(	220	DOMParser parser = new DOMParser(
264	new ProblemReporter(	221	new ProblemReporter(
265	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	222	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
266	compilerOptions,	223	compilerOptions,
267	new DefaultProblemFactory()));	224	new DefaultProblemFactory()), false);
268	org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit =	225	org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit =
269	new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(	226	new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(
270	source,	227	source,
Lines 294-304 Link Here
294	throw new IllegalArgumentException();	251	throw new IllegalArgumentException();
295	}	252	}
296	CompilerOptions compilerOptions = new CompilerOptions(settings);	253	CompilerOptions compilerOptions = new CompilerOptions(settings);
297	Parser parser = createDomParser(	254	DOMParser parser = new DOMParser(
298	new ProblemReporter(	255	new ProblemReporter(
299	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	256	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
300	compilerOptions,	257	compilerOptions,
301	new DefaultProblemFactory()));	258	new DefaultProblemFactory()), false);
302	org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit =	259	org.eclipse.jdt.internal.compiler.env.ICompilationUnit sourceUnit =
303	new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(	260	new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(
304	source,	261	source,
Lines 500-506 Link Here
500	}	457	}
501	}	458	}
502		459
503	/**	460	/*
504	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process	461	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
505	*/	462	*/
506	public CompilationUnitDeclaration resolve(	463	public CompilationUnitDeclaration resolve(
Lines 576-582 Link Here
576	// this.reset();	533	// this.reset();
577	}	534	}
578	}	535	}
579	/**	536	/*
580	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process	537	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
581	*/	538	*/
582	public CompilationUnitDeclaration resolve(	539	public CompilationUnitDeclaration resolve(
Lines 593-599 Link Here
593	generateCode);	550	generateCode);
594	}	551	}
595		552
596	/**	553	/*
597	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process	554	* Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
598	*/	555	*/
599	public CompilationUnitDeclaration resolve(	556	public CompilationUnitDeclaration resolve(

Lines 33-39 Link Here

(-)dom/org/eclipse/jdt/core/dom/IBinding.java (-5 / +8 lines)
33	* Kind constant (value 1) indicating a package binding.	33	* Kind constant (value 1) indicating a package binding.
34	* Bindings of this kind can be safely cast to <code>IPackageBinding</code>.	34	* Bindings of this kind can be safely cast to <code>IPackageBinding</code>.
35	*	35	*
36	* @see #getKind	36	* @see #getKind()
37	* @see IPackageBinding	37	* @see IPackageBinding
38	*/	38	*/
39	public static final int PACKAGE = 1;	39	public static final int PACKAGE = 1;
Lines 42-48 Link Here
42	* Kind constant (value 2) indicating a type binding.	42	* Kind constant (value 2) indicating a type binding.
43	* Bindings of this kind can be safely cast to <code>ITypeBinding</code>.	43	* Bindings of this kind can be safely cast to <code>ITypeBinding</code>.
44	*	44	*
45	* @see #getKind	45	* @see #getKind()
46	* @see ITypeBinding	46	* @see ITypeBinding
47	*/	47	*/
48	public static final int TYPE = 2;	48	public static final int TYPE = 2;
Lines 51-57 Link Here
51	* Kind constant (value 3) indicating a field or local variable binding.	51	* Kind constant (value 3) indicating a field or local variable binding.
52	* Bindings of this kind can be safely cast to <code>IVariableBinding</code>.	52	* Bindings of this kind can be safely cast to <code>IVariableBinding</code>.
53	*	53	*
54	* @see #getKind	54	* @see #getKind()
55	* @see IVariableBinding	55	* @see IVariableBinding
56	*/	56	*/
57	public static final int VARIABLE = 3;	57	public static final int VARIABLE = 3;
Lines 60-66 Link Here
60	* Kind constant (value 4) indicating a method or constructor binding.	60	* Kind constant (value 4) indicating a method or constructor binding.
61	* Bindings of this kind can be safely cast to <code>IMethodBinding</code>.	61	* Bindings of this kind can be safely cast to <code>IMethodBinding</code>.
62	*	62	*
63	* @see #getKind	63	* @see #getKind()
64	* @see IMethodBinding	64	* @see IMethodBinding
65	*/	65	*/
66	public static final int METHOD = 4;	66	public static final int METHOD = 4;
Lines 172-178 Link Here
172	* not be different; in these cases, the client should compare bindings	172	* not be different; in these cases, the client should compare bindings
173	* via their binding keys (<code>getKey</code>) if available.	173	* via their binding keys (<code>getKey</code>) if available.
174	*	174	*
175	* @see #getKey	175	* @see #getKey()
		176	*
		177	* @param obj
		178	* @return
176	*/	179	*/
177	public boolean equals(Object obj);	180	public boolean equals(Object obj);
178		181

Lines 8-33 Link Here

(-)dom/org/eclipse/jdt/core/dom/Javadoc.java (-58 / +60 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11
12	package org.eclipse.jdt.core.dom;	11	package org.eclipse.jdt.core.dom;
13		12
14	import org.eclipse.jdt.core.compiler.InvalidInputException;
15	import org.eclipse.jdt.internal.compiler.parser.Scanner;
16	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
17		13
18	/**	14	/**
19	* AST node for a Javadoc comment.	15	* AST node for a Javadoc comment.
20	*	16	*
21	* @since 2.0	17	* @since 2.0
22	*/	18	*/
23	public class Javadoc extends ASTNode {	19	public class Javadoc extends Comment {
24		20
25	/**	21	/**
26	* The javadoc comment string, including opening and closing comment	22	* First non-empty line of comment text before the first Javadoc tag;
27	* delimiters; defaults to an unspecified, but legal, Javadoc comment.	23	* default is empty string.
28	*/	24	*/
29	private String comment = "/** */";//$NON-NLS-1$	25	//String title = "";//$NON-NLS-1$
30		26
		27	/**
		28	* Non-empty lines of comment text after the title and before the first
		29	* Javadoc tag; default is empty string.
		30	*/
		31	//String[] description = { "" }; //$NON-NLS-1$
		32	//String description = ""; //$NON-NLS-1$
		33
31	/**	34	/**
32	* Creates a new AST node for a Javadoc comment owned by the given AST.	35	* Creates a new AST node for a Javadoc comment owned by the given AST.
33	* The new node has an unspecified, but legal, Javadoc comment.	36	* The new node has an unspecified, but legal, Javadoc comment.
Lines 41-46 Link Here
41	*/	44	*/
42	Javadoc(AST ast) {	45	Javadoc(AST ast) {
43	super(ast);	46	super(ast);
		47	this.block = true;
		48	this.text = "/** */"; //$NON-NLS-1$
44	}	49	}
45		50
46	/* (omit javadoc for this method)	51	/* (omit javadoc for this method)
Lines 56-62 Link Here
56	ASTNode clone(AST target) {	61	ASTNode clone(AST target) {
57	Javadoc result = new Javadoc(target);	62	Javadoc result = new Javadoc(target);
58	result.setSourceRange(this.getStartPosition(), this.getLength());	63	result.setSourceRange(this.getStartPosition(), this.getLength());
59	result.setComment(getComment());	64	result.setText(this.text);
		65	//result.setTitle(this.title);
		66	//result.setDescription(this.description);
60	return result;	67	return result;
61	}	68	}
62		69
Lines 81-146 Link Here
81	* and ending comment delimiters, and any embedded line breaks.	88	* and ending comment delimiters, and any embedded line breaks.
82	*	89	*
83	* @return the javadoc comment string	90	* @return the javadoc comment string
		91	* @deprecated Use #getText() instead
84	*/	92	*/
85	public String getComment() {	93	public String getComment() {
86	return comment;	94	return getText();
87	}	95	}
88		96
89	/**	97	/**
90	* Sets or clears the Javadoc comment string. The documentation	98	* Returns whether the comment is a javadoc comment or not.
91	* string must include the starting and ending comment delimiters,	99	* @return true if the comment is a Javadoc one, false otherwise.
92	* and any embedded line breaks.	100	*/
93	*	101	public boolean isJavadoc() {
94	* @param javadocComment the javadoc comment string	102	return true;
95	* @exception IllegalArgumentException if the Java comment string is invalid	103	}
		104
		105	/**
		106	* @return Returns the description as string.
96	*/	107	*/
97	public void setComment(String javadocComment) {	108	public String getDescription() {
98	if (javadocComment == null) {	109	JavadocTag tag = getFirstSentence(false);
99	throw new IllegalArgumentException();	110	if (tag != null) {
		111	return tag.getDescription();
100	}	112	}
101	char[] source = javadocComment.toCharArray();	113	return ""; //$NON-NLS-1$
102	Scanner scanner = this.getAST().scanner;	114	}
103	scanner.resetTo(0, source.length);	115
104	scanner.setSource(source);	116	/**
105	try {	117	* Return the first sengtence of Javadoc comment.
106	int token;	118	* This is the first tag of the list which has no identifier.
107	boolean onlyOneComment = false;	119	* @param setIfNull Tells whether the first sentence should be created if none was found
108	while ((token = scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {	120	* @return The first sentence of the Javadoc as a JavadocTag
109	switch(token) {	121	* @see JavadocTag
110	case TerminalTokens.TokenNameCOMMENT_JAVADOC :	122	*/
111	if (onlyOneComment) {	123	public JavadocTag getFirstSentence(boolean setIfNull) {
112	throw new IllegalArgumentException();	124	if (this.tags.size() > 0) {
113	}	125	JavadocTag tag = (JavadocTag) tags().get(0);
114	onlyOneComment = true;	126	if (tag.getIdentifier().length() == 0) {
115	break;	127	return tag;
116	default:
117	onlyOneComment = false;
118	}
119	}
120	if (!onlyOneComment) {
121	throw new IllegalArgumentException();
122	}	128	}
123	} catch (InvalidInputException e) {
124	throw new IllegalArgumentException();
125	}	129	}
126	modifying();	130	if (setIfNull) {
127	this.comment = javadocComment;	131	JavadocTag tag = getAST().newJavadocTag();
128	}	132	this.tags.add(0, tag);
129		133	return tag;
130	/* (omit javadoc for this method)	134	} else {
131	* Method declared on ASTNode.	135	return null;
132	*/	136	}
133	int memSize() {
134	int size = BASE_NODE_SIZE + 1 * 4;
135	size += HEADERS + 2 * 4 + HEADERS + 2 * comment.length();
136	return size;
137	}	137	}
138		138
139	/* (omit javadoc for this method)	139	/* (non-Javadoc)
140	* Method declared on ASTNode.	140	* @see org.eclipse.jdt.core.dom.Comment#isBlock()
141	*/	141	*/
142	int treeSize() {	142	public boolean isBlock() {
143	return memSize();	143	// Javadoc comment is always considered as a block comment
		144	return true;
144	}	145	}
		146
145	}	147	}
146		148

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/Comment.java (+211 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	import java.util.Iterator;
14	import java.util.List;
15
16	/**
17	* AST node for a comment.
18	* This is a concrete class which represents line comments: <code>// comment</code>
19	* and block comments <code>/* comment \*\/</code>.
20	*
21	* Javadoc comment are still representated with Javadoc class which is now a sub-class
22	* of this class.
23	* @see Javadoc
24	*
25	* @since 3.0
26	*/
27	public class Comment extends ASTNode {
28
29	/**
30	* The comment text, including opening and closing comment
31	* delimiters; defaults to an empty, but legal, line comment.
32	*/
33	String text = "//";//$NON-NLS-1$
34
35	/**
36	* Indicates whether the comment is a block or a line comment;
37	* defaults to an unspecified, but legal, comment.
38	* Note that Javadoc comment are considered as block comments
39	* @see Javadoc
40	*/
41	boolean block = false;
42
43	/**
44	* The tags included in the comment (element type: <code>JavadocTag</code>).
45	* Defaults to none.
46	*/
47	ASTNode.NodeList tags = new ASTNode.NodeList(true, JavadocTag.class);
48
49	/**
50	* Creates a new AST node for a Javadoc comment owned by the given AST.
51	* The new node has an unspecified, but legal, Javadoc comment.
52	* <p>
53	* N.B. This constructor is package-private; all subclasses must be
54	* declared in the same package; clients are unable to declare
55	* additional subclasses.
56	* </p>
57	*
58	* @param ast the AST that is to own this node
59	*/
60	Comment(AST ast) {
61	super(ast);
62	}
63
64	/* (omit javadoc for this method)
65	* Method declared on ASTNode.
66	*/
67	public int getNodeType() {
68	return COMMENT;
69	}
70
71	/* (omit javadoc for this method)
72	* Method declared on ASTNode.
73	*/
74	ASTNode clone(AST target) {
75	Comment result = new Comment(target);
76	result.setSourceRange(this.getStartPosition(), this.getLength());
77	result.setText(this.text);
78	result.setBlock(this.block);
79	return result;
80	}
81
82	/* (omit javadoc for this method)
83	* Method declared on ASTNode.
84	*/
85	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
86	// dispatch to correct overloaded match method
87	return matcher.match(this, other);
88	}
89
90	/* (omit javadoc for this method)
91	* Method declared on ASTNode.
92	*/
93	void accept0(ASTVisitor visitor) {
94	visitor.visit(this);
95	visitor.endVisit(this);
96	}
97
98	/**
99	* Returns the Javadoc comment string, including the starting
100	* and ending comment delimiters, and any embedded line breaks.
101	*
102	* @return the javadoc comment string
103	*/
104	public String getText() {
105	return this.text;
106	}
107
108	/**
109	* Sets or clears the Javadoc comment string. The documentation
110	* string must include the starting and ending comment delimiters,
111	* and any embedded line breaks.
112	*
113	* @param textComment the javadoc comment string
114	* @exception IllegalArgumentException if the Java comment string is invalid
115	*/
116	public void setText(String textComment) {
117	if (textComment == null) {
118	throw new IllegalArgumentException();
119	}
120	modifying();
121	this.text = textComment;
122	}
123
124	/**
125	* Sets or clears the Javadoc comment string. The documentation
126	* string must include the starting and ending comment delimiters,
127	* and any embedded line breaks.
128	*
129	* @param comment the javadoc comment string
130	* @exception IllegalArgumentException if the Java comment string is invalid
131	*/
132	public void setComment(String comment) {
133	setText(comment);
134	//this.block = (comment.indexOf('\r') >= 0 \|\| comment.indexOf('\n') >= 0);
135	if (this.block) {
136	DOMCommentParser parser = new DOMCommentParser(this.getAST());
137	if (parser.parse(this)) {
138	if ((getStartPosition() > 0) && (this.tags != null)) {
139	for(Iterator it = this.tags.iterator(); it.hasNext(); ) {
140	JavadocTag tag = (JavadocTag) it.next();
141	tag.setSourceRange(tag.getStartPosition()+getStartPosition(), tag.getLength());
142	}
143	}
144	} else {
145	throw new IllegalArgumentException();
146	}
147	}
148	}
149
150	/* (omit javadoc for this method)
151	* Method declared on ASTNode.
152	*/
153	int memSize() {
154	int size = BASE_NODE_SIZE;
155	if (this.text != null) {
156	// Strings usually have 4 instance fields, one of which is a char[]
157	size += HEADERS + 4 * 4;
158	// char[] has 2 bytes per character
159	size += HEADERS + 2 * this.text.length();
160	}
161	size += 4; // size for block
162	size += 4; // size for tags
163	return size;
164	}
165
166	/* (omit javadoc for this method)
167	* Method declared on ASTNode.
168	*/
169	int treeSize() {
170	return memSize() + tags.listSize();
171	}
172
173	/**
174	* @return Returns the tagDeclarations.
175	*/
176	public List tags() {
177	return tags;
178	}
179
180	/**
181	* @return Returns the isBlock.
182	*/
183	public boolean isBlock() {
184	return block;
185	}
186
187	/**
188	* @param isBlock The isBlock to set.
189	*/
190	public void setBlock(boolean isBlock) {
191	modifying();
192	this.block = isBlock;
193	}
194
195	/**
196	* Returns whether the comment is a javadoc comment or not.
197	* @return true if the comment is a Javadoc one, false otherwise.
198	*/
199	public boolean isJavadoc() {
200	return false;
201	}
202
203	/**
204	* Returns whether the comment has tags or not.
205	* @return true if some tags are written in the comment, false otherwise.
206	*/
207	public boolean hasTags() {
208	return (this.tags != null) && (this.tags.size() > 0);
209	}
210	}
211

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/DOMParser.java (+224 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	import org.eclipse.jdt.internal.compiler.CompilationResult;
14	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
15	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
16	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
17	import org.eclipse.jdt.internal.compiler.parser.Parser;
18	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
19	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
20
21	/**
22	* Specific parser to use while parsing source to create DOM AST nodes.
23	*/
24	public class DOMParser extends Parser {
25
26	// support for comments
27	public int[] commentStops = new int[10];
28	public int[] commentStarts = new int[10];
29	public int commentPtr = -1; // no comment test with commentPtr value -1
30	protected final static int CommentIncrement = 100;
31
32	/**
33	* @param problemReporter
34	* @param optimizeStringLiterals
35	*/
36	public DOMParser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
37	super(problemReporter, optimizeStringLiterals);
38	this.javadocParser.checkJavadoc = true;
39	}
40
41	// old javadoc style check which doesn't include all leading comments into declaration
42	// for backward compatibility with 2.1 DOM
43	public void checkComment() {
44
45	if (this.currentElement != null && this.scanner.commentPtr >= 0) {
46	flushCommentsDefinedPriorTo(endStatementPosition); // discard obsolete comments
47	}
48	boolean deprecated = false;
49	boolean checkDeprecated = false;
50	int lastCommentIndex = -1;
51
52	//
53
54	//since jdk1.2 look only in the last java doc comment...
55	nextComment : for (lastCommentIndex = scanner.commentPtr; lastCommentIndex >= 0; lastCommentIndex--){
56	//look for @deprecated into the first javadoc comment preceeding the declaration
57	int commentSourceStart = scanner.commentStarts[lastCommentIndex];
58	// javadoc only (non javadoc comment have negative end positions.)
59	if ((commentSourceStart < 0) \|\|
60	(modifiersSourceStart != -1 && modifiersSourceStart < commentSourceStart) \|\|
61	(this.scanner.commentStops[lastCommentIndex] < 0))
62	{
63	continue nextComment;
64	}
65	checkDeprecated = true;
66	int commentSourceEnd = scanner.commentStops[lastCommentIndex] - 1; //stop is one over
67
68	deprecated =
69	this.javadocParser.checkDeprecation(commentSourceStart, commentSourceEnd);
70	this.javadoc = this.javadocParser.javadoc;
71	break nextComment;
72	}
73	if (deprecated) {
74	checkAndSetModifiers(AccDeprecated);
75	}
76	// modify the modifier source start to point at the first comment
77	if (lastCommentIndex >= 0 && checkDeprecated) {
78	modifiersSourceStart = scanner.commentStarts[lastCommentIndex];
79	if (modifiersSourceStart < 0) {
80	modifiersSourceStart = -modifiersSourceStart;
81	}
82	}
83
84	}
85
86
87	/* (non-Javadoc)
88	* Save all source comments currently stored before flushing them.
89	* @see org.eclipse.jdt.internal.compiler.parser.Parser#flushCommentsDefinedPriorTo(int)
90	*/
91	public int flushCommentsDefinedPriorTo(int position) {
92
93	int lastCommentIndex = scanner.commentPtr;
94	if (lastCommentIndex < 0) return position; // no comment
95
96	// compute the index of the first obsolete comment
97	int index = lastCommentIndex;
98	int validCount = 0;
99	while (index >= 0){
100	int commentEnd = scanner.commentStops[index];
101	if (commentEnd < 0) commentEnd = -commentEnd; // negative end position for non-javadoc comments
102	if (commentEnd <= position){
103	break;
104	}
105	index--;
106	validCount++;
107	}
108	// if the source at <position> is immediately followed by a line comment, then
109	// flush this comment and shift <position> to the comment end.
110	if (validCount > 0){
111	int immediateCommentEnd = -scanner.commentStops[index+1]; //non-javadoc comment end positions are negative
112	if (immediateCommentEnd > 0){ // only tolerating non-javadoc comments
113	// is there any line break until the end of the immediate comment ? (thus only tolerating line comment)
114	immediateCommentEnd--; // comment end in one char too far
115	if (scanner.getLineNumber(position) == scanner.getLineNumber(immediateCommentEnd)){
116	position = immediateCommentEnd;
117	validCount--; // flush this comment
118	index++;
119	}
120	}
121	}
122
123	if (index < 0) return position; // no obsolete comment
124	pushOnCommentsStack(0, index);
125
126	if (validCount > 0){ // move valid comment infos, overriding obsolete comment infos
127	System.arraycopy(scanner.commentStarts, index + 1, scanner.commentStarts, 0, validCount);
128	System.arraycopy(scanner.commentStops, index + 1, scanner.commentStops, 0, validCount);
129	}
130	scanner.commentPtr = validCount - 1;
131	return position;
132	}
133
134	/*
135	* Push all stored comments in stack.
136	*/
137	protected void pushOnCommentsStack(int start, int end) {
138
139	for (int i=start; i<=end; i++) {
140	try {
141	this.commentPtr++;
142	this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
143	this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
144	} catch (IndexOutOfBoundsException e) {
145	// this.commentPtr is still correct
146	int oldStackLength = this.commentStarts.length;
147	int oldCommentStarts[] = this.commentStarts;
148	this.commentStarts = new int[oldStackLength + CommentIncrement];
149	System.arraycopy(oldCommentStarts, 0, this.commentStarts, 0, oldStackLength);
150	this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
151	int oldCommentStops[] = this.commentStops;
152	this.commentStops = new int[oldStackLength + CommentIncrement];
153	System.arraycopy(oldCommentStops, 0, this.commentStops, 0, oldStackLength);
154	this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
155	}
156	}
157	}
158	/* (non-Javadoc)
159	* Save all source comments currently stored before flushing them.
160	* @see org.eclipse.jdt.internal.compiler.parser.Parser#resetModifiers()
161	*/
162	protected void resetModifiers() {
163	pushOnCommentsStack(0, this.scanner.commentPtr);
164	super.resetModifiers();
165	}
166
167	/* (non-Javadoc)
168	* Store comments positions saved in stack in compilation unit declaration.
169	* @see org.eclipse.jdt.internal.compiler.parser.Parser#dietParse(org.eclipse.jdt.internal.compiler.env.ICompilationUnit, org.eclipse.jdt.internal.compiler.CompilationResult)
170	*/
171	public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {
172	CompilationUnitDeclaration unit = super.dietParse(sourceUnit, compilationResult);
173	unit.comments = getCommentsPositions();
174	return unit;
175	}
176
177	/* (non-Javadoc)
178	* Insure that start position is always positive.
179	* @see org.eclipse.jdt.internal.compiler.parser.Parser#containsComment(int, int)
180	*/
181	public boolean containsComment(int sourceStart, int sourceEnd) {
182	int iComment = this.scanner.commentPtr;
183	for (; iComment >= 0; iComment--) {
184	int commentStart = this.scanner.commentStarts[iComment];
185	if (commentStart < 0) {
186	commentStart = -commentStart;
187	}
188	// ignore comments before start
189	if (commentStart < sourceStart) continue;
190	// ignore comments after end
191	if (commentStart > sourceEnd) continue;
192	return true;
193	}
194	return false;
195	}
196
197	/*
198	* Build a n*2 matrix of comments positions.
199	* For each position, 0 is for start position and 1 for end position of the comment.
200	*/
201	public int[][] getCommentsPositions() {
202	int[][] positions = new int[this.commentPtr+1][2];
203	for (int i = 0, max = this.commentPtr; i <= max; i++){
204	positions[i][0] = this.commentStarts[i];
205	positions[i][1] = this.commentStops[i];
206	}
207	return positions;
208	}
209
210	/* (non-Javadoc)
211	* Create and store a specific DOM scanner.
212	* @see org.eclipse.jdt.internal.compiler.parser.Parser#initializeScanner()
213	*/
214	public void initializeScanner() {
215	this.scanner = new DOMScanner(
216	false /comment/,
217	false /whitespace/,
218	this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /nls/,
219	this.options.sourceLevel /sourceLevel/,
220	this.options.taskTags/taskTags/,
221	this.options.taskPriorites/taskPriorities/);
222	}
223
224	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/DOMScanner.java (+201 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	import org.eclipse.jdt.core.compiler.InvalidInputException;
14	import org.eclipse.jdt.internal.compiler.parser.Scanner;
15
16	/**
17	* Specialized scanner for DOM AST nodes.
18	*/
19	public class DOMScanner extends Scanner {
20
21	// Tell whether an end of comment was reached
22	public int embeddedPtr = -1;
23	public int[] embeddedTagStarts = new int[10];
24	public int[] embeddedTagStops = new int[10];
25
26	public DOMScanner() {
27	super();
28	}
29
30	public DOMScanner(
31	boolean tokenizeComments,
32	boolean tokenizeWhiteSpace,
33	boolean checkNonExternalizedStringLiterals,
34	long sourceLevel,
35	char[][] taskTags,
36	char[][] taskPriorities) {
37	super(tokenizeComments, tokenizeWhiteSpace, checkNonExternalizedStringLiterals, sourceLevel, taskTags, taskPriorities);
38	}
39
40	/*(non-Javadoc)
41	* Return the current token source as a string. Do not call getCurrentTokenSourceString()
42	* method of superclass in order to avoid unnecessary array copy.
43	* @see org.eclipse.jdt.internal.compiler.parser.Scanner#getCurrentTokenSource()
44	*/
45	public final String getCurrentTokenSourceAsString() {
46	//return the token REAL source (aka unicodes are precomputed).
47
48	if (this.withoutUnicodePtr != 0) {
49	//0 is used as a fast test flag so the real first char is in position 1
50	return new String(this.withoutUnicodeBuffer, 0, this.withoutUnicodePtr);
51	} else {
52	if (this.currentPosition < this.startPosition) {
53	return ""; //$NON-NLS-1$
54	}
55	return new String(this.source, this.startPosition, this.currentPosition - this.startPosition);
56	}
57	}
58
59	/*(non-Javadoc)
60	* Return the current identifier source as a string. Do not call getCurrentTokenSourceString()
61	* method of superclass in order to avoid unnecessary array copy.
62	* @see org.eclipse.jdt.internal.compiler.parser.Scanner#getCurrentIdentifierSource()
63	*/
64	public String getCurrentIdentifierSourceAsString() {
65	//return the token REAL source (aka unicodes are precomputed)
66
67	if (this.withoutUnicodePtr != 0) {
68	//0 is used as a fast test flag so the real first char is in position 1
69	return new String(this.withoutUnicodeBuffer, 1, this.withoutUnicodePtr);
70	} else {
71	int length = this.currentPosition - this.startPosition;
72	//no optimization
73	return new String(this.source, this.startPosition, length);
74	}
75	}
76
77	/*
78	* Return the source until the end of current line.
79	*
80	public String getLineEndAsString() {
81	this.endComment = false;
82	int start = this.currentPosition;
83	int end = this.currentPosition;
84	boolean star = false;
85	while ((this.currentCharacter != '\r') && (this.currentCharacter != '\n')) {
86	if (star && this.currentCharacter == '/') {
87	this.endComment = true;
88	break;
89	}
90	star = this.currentCharacter == '*';
91	end = this.currentPosition;
92	getNextChar();
93	}
94	int length = end - start;
95	if ((this.currentCharacter == '\r') \|\| (this.currentCharacter == '\n')) {
96	pushLineSeparator();
97	this.lineEnds[this.linePtr] = end - 1;
98	}
99	if (length > 0) {
100	return new String(source, start, length);
101	} else {
102	return ""; //$NON-NLS-1$
103	}
104	}
105
106	/*
107	* Skip a line in a comment. Returns an positions array of possible embedded tags.
108	* Also store whether the end of comment has been reached or not.
109	*/
110	public boolean skipCommentLine() throws InvalidInputException {
111	boolean endComment = this.currentCharacter == '*';
112	int endLine = this.currentPosition;
113	if ((this.currentCharacter == '\r') \|\| (this.currentCharacter == '\n')) {
114	endLine--;
115	}
116	int startEmbedded = this.currentCharacter == '{' ? this.getCurrentTokenStartPosition() : this.currentPosition;
117	while ((this.currentPosition < this.eofPosition) && (this.currentCharacter != '\r') && (this.currentCharacter != '\n')) {
118	if (endComment && this.currentCharacter == '/') {
119	break;
120	}
121	endComment = false;
122	if (this.currentCharacter == '{') {
123	int endEmbedded = this.currentPosition;
124	getNextChar();
125	if ((this.currentPosition >= this.eofPosition) \|\|
126	(this.currentCharacter == '\r') \|\|
127	(this.currentCharacter == '\n')) {
128	// End of text of new line was found before end of embedded tag => break from loop
129	break;
130	}
131	if (this.currentCharacter == '@') {
132	while ((this.currentCharacter != '}')) {
133	if (((endComment && this.currentCharacter == '/')) \|\|
134	(this.currentPosition >= this.eofPosition) \|\|
135	(this.currentCharacter == '\r') \|\|
136	(this.currentCharacter == '\n')) {
137	// End of text of new line was found before end of embedded tag => the text is not valid
138	throw new InvalidInputException();
139	}
140	endEmbedded = this.currentPosition;
141	endComment = this.currentCharacter == '*';
142	getNextChar();
143	}
144	recordEmbeddedTag(startEmbedded, endEmbedded);
145	}
146	}
147	endComment = this.currentCharacter == '*';
148	endLine = this.currentPosition;
149	startEmbedded = this.currentPosition;
150	getNextChar();
151	}
152	if ((this.currentCharacter == '\r') \|\| (this.currentCharacter == '\n')) {
153	pushLineSeparator();
154	this.lineEnds[this.linePtr] = endLine - 1;
155	}
156	return endComment;
157	}
158
159	/* (non-Javadoc)
160	* Set start position negative for line comments.
161	* @see org.eclipse.jdt.internal.compiler.parser.Scanner#recordComment(boolean)
162	*/
163	public void recordComment(int token) {
164	super.recordComment(token);
165	if (token == TokenNameCOMMENT_LINE) {
166	// for comment line both positions are negative
167	this.commentStarts[this.commentPtr] = -this.commentStarts[this.commentPtr];
168	}
169	}
170
171	public void recordEmbeddedTag(int start, int end) {
172
173	// a new comment is recorded
174	try {
175	this.embeddedTagStops[++this.embeddedPtr] = end;
176	} catch (IndexOutOfBoundsException e) {
177	int oldStackLength = this.embeddedTagStops.length;
178	int[] oldStack = this.embeddedTagStops;
179	this.embeddedTagStops = new int[oldStackLength + 10];
180	System.arraycopy(oldStack, 0, this.embeddedTagStops, 0, oldStackLength);
181	this.embeddedTagStops[this.embeddedPtr] = end;
182	//grows the positions buffers too
183	int[] old = this.embeddedTagStarts;
184	this.embeddedTagStarts = new int[oldStackLength + 10];
185	System.arraycopy(old, 0, this.embeddedTagStarts, 0, oldStackLength);
186	}
187
188	//the buffer is of a correct size here
189	this.embeddedTagStarts[this.embeddedPtr] = start;
190	}
191
192	/*(non-Javadoc)
193	* Reset initial, start and current positions.
194	* @see org.eclipse.jdt.internal.compiler.parser.Scanner#resetTo(int, int)
195	*/
196	public void restartFrom(int begin) {
197	this.initialPosition = this.startPosition = this.currentPosition = begin;
198	this.embeddedPtr = -1;
199	}
200
201	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/JavadocArgument.java (+86 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	/**
14	*/
15	public class JavadocArgument extends Expression {
16	public SingleVariableDeclaration argument;
17
18	/**
19	* @param ast
20	*/
21	public JavadocArgument(AST ast) {
22	super(ast);
23	}
24
25	/* (non-Javadoc)
26	* @see org.eclipse.jdt.core.dom.ASTNode#getNodeType()
27	*/
28	public int getNodeType() {
29	return JAVADOC_ARGUMENT;
30	}
31
32	/* (non-Javadoc)
33	* @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
34	*/
35	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
36	return matcher.match(this, other);
37	}
38
39	/* (non-Javadoc)
40	* @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
41	*/
42	ASTNode clone(AST target) {
43	JavadocArgument result = new JavadocArgument(target);
44	result.setSourceRange(this.getStartPosition(), this.getLength());
45	result.setArgument(getArgument());
46	return result;
47	}
48
49	/* (non-Javadoc)
50	* @see org.eclipse.jdt.core.dom.ASTNode#accept0(org.eclipse.jdt.core.dom.ASTVisitor)
51	*/
52	void accept0(ASTVisitor visitor) {
53	visitor.visit(this);
54	visitor.endVisit(this);
55
56	}
57
58	/* (non-Javadoc)
59	* @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
60	*/
61	int treeSize() {
62	return this.argument==null?0:this.argument.treeSize();
63	}
64
65	/* (non-Javadoc)
66	* @see org.eclipse.jdt.core.dom.ASTNode#memSize()
67	*/
68	int memSize() {
69	return BASE_NODE_SIZE + 4;
70	}
71
72	/**
73	* @return Returns the argument.
74	*/
75	public SingleVariableDeclaration getArgument() {
76	return this.argument;
77	}
78
79	/**
80	* @param argument The argument to set.
81	*/
82	public void setArgument(SingleVariableDeclaration argument) {
83	this.argument = argument;
84	}
85
86	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/JavadocEmbeddedTag.java (+130 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	/**
14	*/
15	public class JavadocEmbeddedTag extends ASTNode {
16
17	/**
18	* An unspecified (but externally observable) legal Javadoc tag identifier.
19	*/
20	private static final String MISSING_IDENTIFIER = "";//$NON-NLS-1$
21
22	/**
23	* The identifier; defaults to a unspecified, legal Java identifier.
24	*/
25	String identifier = MISSING_IDENTIFIER;
26
27	/**
28	* An other Javadoc tag the embedded tag refers to; defaults is null
29	*/
30	JavadocTag tag;
31
32	/**
33	* @param ast
34	*/
35	public JavadocEmbeddedTag(AST ast) {
36	super(ast);
37	}
38
39	/* (omit javadoc for this method)
40	* Method declared on ASTNode.
41	*/
42	void accept0(ASTVisitor visitor) {
43	visitor.visit(this);
44	visitor.endVisit(this);
45	}
46
47	/* (omit javadoc for this method)
48	* Method declared on ASTNode.
49	*/
50	public int getNodeType() {
51	return JAVADOC_EMBEDDED_TAG;
52	}
53
54	/* (non-Javadoc)
55	* @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
56	*/
57	ASTNode clone(AST target) {
58	JavadocEmbeddedTag result = new JavadocEmbeddedTag(target);
59	result.setSourceRange(this.getStartPosition(), this.getLength());
60	result.setIdentifier(this.identifier);
61	result.setTag(this.tag);
62	return result;
63	}
64
65	/* (non-Javadoc)
66	* @see org.eclipse.jdt.core.dom.ASTNode#memSize()
67	*/
68	int memSize() {
69	int size = BASE_NODE_SIZE;
70	if (this.identifier!= null) {
71	// Strings usually have 4 instance fields, one of which is a char[]
72	size += HEADERS + 4 * 4;
73	// char[] has 2 bytes per character
74	size += HEADERS + 2 * this.identifier.length();
75	}
76	size += 4; // tag
77	return size;
78	}
79
80	/* (non-Javadoc)
81	* @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
82	*/
83	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
84	return matcher.match(this, other);
85	}
86
87	/* (non-Javadoc)
88	* @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
89	*/
90	int treeSize() {
91	return memSize() + this.tag.treeSize();
92	}
93
94	/**
95	* @return Returns the name.
96	*/
97	public String getIdentifier() {
98	return this.identifier;
99	}
100
101	/**
102	* @param id The name to set.
103	*/
104	public void setIdentifier(String id) {
105	if (id == null) {
106	throw new IllegalArgumentException();
107	}
108	modifying();
109	this.identifier = id;
110	}
111
112	/**
113	* @return Returns the tag.
114	*/
115	public JavadocTag getTag() {
116	return this.tag;
117	}
118
119	/**
120	* @param tag The tag to set.
121	*/
122	public void setTag(JavadocTag tag) {
123	if (tag == null) {
124	throw new IllegalArgumentException();
125	}
126	replaceChild(this.tag, tag, false);
127	this.tag = tag;
128	}
129
130	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/JavadocTag.java (+187 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	import java.util.List;
14
15
16	/**
17	* AST node for a Javadoc tag of a comment.
18	*
19	* @since 3.0
20	*/
21	public class JavadocTag extends ASTNode {
22
23	/**
24	* An unspecified (but externally observable) legal Javadoc tag identifier.
25	*/
26	static final String NO_IDENTIFIER = "";//$NON-NLS-1$
27
28	/**
29	* The identifier; defaults to a unspecified, legal Java identifier.
30	*/
31	String identifier = NO_IDENTIFIER;
32
33	/**
34	* An other AST node the tag refers to; defaults is null
35	*/
36	ASTNode reference;
37
38	String description = ""; //$NON-NLS-1$
39
40	/**
41	* The embedded tags included in the tag description (element type: <code>JavadocTag</code>).
42	* Defaults to none.
43	*/
44	ASTNode.NodeList embedded = new ASTNode.NodeList(true, JavadocEmbeddedTag.class);
45
46
47	/**
48	* Creates a new AST node for a Javadoc tag owned by the given Javadoc comment.
49	* The new node has an unspecified, but legal, Javadoc comment.
50	* <p>
51	* N.B. This constructor is package-private; all subclasses must be
52	* declared in the same package; clients are unable to declare
53	* additional subclasses.
54	* </p>
55	*
56	* @param ast the AST that is to own this node
57	*/
58	JavadocTag(AST ast) {
59	super(ast);
60	}
61
62	/* (omit javadoc for this method)
63	* Method declared on ASTNode.
64	*/
65	void accept0(ASTVisitor visitor) {
66	visitor.visit(this);
67	visitor.endVisit(this);
68	}
69
70	/* (omit javadoc for this method)
71	* Method declared on ASTNode.
72	*/
73	public int getNodeType() {
74	return JAVADOC_TAG;
75	}
76
77	/* (non-Javadoc)
78	* @see org.eclipse.jdt.core.dom.ASTNode#clone(org.eclipse.jdt.core.dom.AST)
79	*/
80	ASTNode clone(AST target) {
81	JavadocTag result = new JavadocTag(target);
82	result.setSourceRange(this.getStartPosition(), this.getLength());
83	result.setIdentifier(this.identifier);
84	result.setDescription(getDescription());
85	result.setReference(getReference());
86	return result;
87	}
88
89	/* (non-Javadoc)
90	* @see org.eclipse.jdt.core.dom.ASTNode#memSize()
91	*/
92	int memSize() {
93	int size = BASE_NODE_SIZE;
94	if (this.identifier!= null) {
95	// Strings usually have 4 instance fields, one of which is a char[]
96	size += HEADERS + 4 * 4;
97	// char[] has 2 bytes per character
98	size += HEADERS + 2 * this.identifier.length();
99	}
100	size += 4; // reference
101	if (this.description!= null) {
102	// Strings usually have 4 instance fields, one of which is a char[]
103	size += HEADERS + 4 * 4;
104	// char[] has 2 bytes per character
105	size += HEADERS + 2 * this.description.length();
106	}
107	size += 4; // embedded
108	return size;
109	}
110
111	/* (non-Javadoc)
112	* @see org.eclipse.jdt.core.dom.ASTNode#subtreeMatch(org.eclipse.jdt.core.dom.ASTMatcher, java.lang.Object)
113	*/
114	public boolean subtreeMatch(ASTMatcher matcher, Object other) {
115	return matcher.match(this, other);
116	}
117
118	/* (non-Javadoc)
119	* @see org.eclipse.jdt.core.dom.ASTNode#treeSize()
120	*/
121	int treeSize() {
122	return memSize()
123	+ (this.reference == null ? 0 : this.reference.treeSize())
124	+ (this.embedded == null ? 0 : this.embedded.listSize());
125	}
126
127	/**
128	* @return Returns the reference.
129	*/
130	public ASTNode getReference() {
131	return this.reference;
132	}
133
134	/**
135	* @param reference The reference to set.
136	*/
137	public void setReference(ASTNode reference) {
138	if (reference == null) {
139	throw new IllegalArgumentException();
140	}
141	replaceChild(this.reference, reference, false);
142	this.reference = reference;
143	}
144
145	/**
146	* @return Returns the name.
147	*/
148	public String getIdentifier() {
149	return this.identifier;
150	}
151
152	/**
153	* @param id The name to set.
154	*/
155	public void setIdentifier(String id) {
156	if (id == null) {
157	throw new IllegalArgumentException();
158	}
159	modifying();
160	this.identifier = id;
161	}
162
163	/**
164	* @return Returns the text.
165	*/
166	public String getDescription() {
167	return this.description;
168	}
169
170	/**
171	* @param text The text to set.
172	*/
173	public void setDescription(String text) {
174	if (text == null) {
175	throw new IllegalArgumentException();
176	}
177	modifying();
178	this.description = text;
179	}
180
181	/**
182	* @return Returns the tagDeclarations.
183	*/
184	public List embedded() {
185	return this.embedded;
186	}
187	}