Attachment #159416 for bug #236406





	/**
	 * Unknown kind
	 *<p>
	 * <b>Since 3.6</b>, if the corresponding comment options are set to
	 * <code>true</code> then it is also possible to format the comments on the fly
	 * by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
	 * </p>
	 */
	public static final int K_UNKNOWN = 0x00;

	/**
	 * Kind used to format an expression
	 * <p>
	 * Note that using this constant, the comments encountered while formatting
	 * the expression may be shifted to match the correct indentation but are not
	 * formatted.
	 * </p><p>
	 * <b>Since 3.6</b>, if the corresponding comment options are set to
	 * <code>true</code> then it is also possible to format the comments on the fly
	 * by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
	 * </p>
	 */
	public static final int K_EXPRESSION = 0x01;

	/**
	 * Kind used to format a set of statements
	 * <p>
	 * Note that using this constant, the comments encountered while formatting
	 * the statements may be shifted to match the correct indentation but are not
	 * formatted.
	 * </p><p>
	 * <b>Since 3.6</b>, if the corresponding comment options are set to
	 * <code>true</code> then it is also possible to format the comments on the fly
	 * by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
	 * </p>
	 */
	public static final int K_STATEMENTS = 0x02;

	/**
	 * Kind used to format a set of class body declarations
	 * <p>
	 * Note that using this constant, the comments encountered while formatting
	 * the body declarations may be shifted to match the correct indentation but
	 * are not formatted.
	 * </p><p>
	 * <b>Since 3.6</b>, if the corresponding comment options are set to
	 * <code>true</code> then it is also possible to format the comments on the fly
	 * by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
	 * </p>
	 */
	public static final int K_CLASS_BODY_DECLARATIONS = 0x04;


	 * Kind used to format a compilation unit
	 * <p>
	 * Note that using this constant, the comments are only indented while
	 * formatting the compilation unit.
	 * </p><p>
	 * <b>Since 3.4</b>, if the corresponding comment option is set to
	 * <code>true</code> then it is also possible to format the comments on the fly
	 * by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
	 * </p>
	 */
	public static final int K_COMPILATION_UNIT = 0x08;


	 * Flag used to include the comments during the formatting of the code
	 * snippet.
	 * <p>
	 * This flag can be combined with the following kinds:
	 * <ul>
	 * 		<li>{@link #K_COMPILATION_UNIT}</li>
	 * 		<li>{@link #K_UNKNOWN}</li>
	 * 		<li>{@link #K_CLASS_BODY_DECLARATIONS} <i>(since 3.6)</i></li>
	 * 		<li>{@link #K_EXPRESSION} <i>(since 3.6)</i></li>
	 * 		<li>{@link #K_STATEMENTS} <i>(since 3.6)</i></li>
	 * </ul>
	 * </p><p>
	 * Note also that it has an effect only when one or several format comments
	 * options for




import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import org.eclipse.jdt.internal.formatter.align.Alignment;
import org.eclipse.jdt.internal.formatter.align.AlignmentException;
import org.eclipse.jdt.internal.formatter.comment.CommentRegion;
import org.eclipse.jface.text.IRegion;
import org.eclipse.text.edits.TextEdit;


	}

	/**
	 * @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
	 */
	public TextEdit format(String string, CommentRegion region) {
		// reset the scribe
		this.scribe.reset();

		if (region == null) {
			return failedToFormat();
		}

		long startTime = 0;
		if (DEBUG){
			startTime = System.currentTimeMillis();
		}

		final char[] compilationUnitSource = string.toCharArray();

		this.scribe.initializeScanner(compilationUnitSource);

		TextEdit result = null;
		try {
			result = region.format(this.preferences.initial_indentation_level, true);
		} catch(AbortFormatting e){
			return failedToFormat();
		}
		if (DEBUG){
			System.out.println("Formatting time: " + (System.currentTimeMillis() - startTime));  //$NON-NLS-1$
		}
		return result;
	}

	/**
	 * @param source the source of the comment to format
	 */
	public void formatComment(int kind, String source, int start, int end, int indentationLevel) {




import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import org.eclipse.jdt.internal.formatter.comment.CommentRegion;
import org.eclipse.jdt.internal.formatter.comment.JavaDocRegion;
import org.eclipse.jdt.internal.formatter.comment.MultiCommentRegion;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.Region;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.TextEdit;

public class DefaultCodeFormatter extends CodeFormatter {

		| K_MULTI_LINE_COMMENT
		| K_JAVA_DOC;

	/*
	 * Temporary internal statics to enable new comments formatter
	 * see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
	 * see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=227043
	 * TODO (frederic) remove in 3.5
	 */
	private final static String NEW_COMMENTS_FORMAT = System.getProperty("org.eclipse.jdt.core.formatter.comments.new"); //$NON-NLS-1$
	public static boolean ENABLE_NEW_COMMENTS_FORMAT = !JavaCore.DISABLED.equals(NEW_COMMENTS_FORMAT);

	// Scanner use to probe the kind of the source given to the formatter
	private static Scanner PROBING_SCANNER;

	/**
	 * Creates a comment region for a specific document partition type.
	 *
	 * @param kind the comment snippet kind
	 * @param document the document which contains the comment region
	 * @param range range of the comment region in the document
	 * @return a new comment region for the comment region range in the
	 *         document
	 * @since 3.1
	 */
	public static CommentRegion createRegion(int kind, IDocument document, Position range, CodeFormatterVisitor formatter) {
		switch (kind & K_MASK) {
			case K_SINGLE_LINE_COMMENT:
				return new CommentRegion(document, range, formatter);
			case K_MULTI_LINE_COMMENT:
				return new MultiCommentRegion(document, range, formatter);
			case K_JAVA_DOC:
				return new JavaDocRegion(document, range, formatter);
		}
		return null;
	}

	private CodeSnippetParsingUtil codeSnippetParsingUtil;
	private Map defaultCompilerOptions;


			case K_JAVA_DOC :
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
				// use the integrated comment formatter to format comment
                return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
	                return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
				}
				// $FALL-THROUGH$ - fall through next case when old comment formatter is activated
			case K_MULTI_LINE_COMMENT :
			case K_SINGLE_LINE_COMMENT :
                return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
	                return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
				}
				this.codeSnippetParsingUtil = new CodeSnippetParsingUtil();
				return formatComment(kind, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)}, false);
		}

		return format(kind, source, new IRegion[] {new Region(offset, length)}, indentationLevel, lineSeparator);

		}

		this.codeSnippetParsingUtil = new CodeSnippetParsingUtil();
		boolean includeComments =  (kind & F_INCLUDE_COMMENTS) != 0;
		switch(kind & K_MASK) {
			case K_CLASS_BODY_DECLARATIONS :
				return formatClassBodyDeclarations(source, indentationLevel, lineSeparator, regions, includeComments);
			case K_COMPILATION_UNIT :
				boolean includeComments =  (kind & F_INCLUDE_COMMENTS) != 0; // || FORCE_NEW_COMMENTS_FORMAT;
				return formatCompilationUnit(source, indentationLevel, lineSeparator, regions, includeComments);
			case K_EXPRESSION :
				return formatExpression(source, indentationLevel, lineSeparator, regions, includeComments);
			case K_STATEMENTS :
				return formatStatements(source, indentationLevel, lineSeparator, regions, includeComments);
			case K_UNKNOWN :
				includeComments =  (kind & F_INCLUDE_COMMENTS) != 0; // || FORCE_NEW_COMMENTS_FORMAT;
				return probeFormatting(source, indentationLevel, lineSeparator, regions, includeComments);
			case K_JAVA_DOC :
			case K_MULTI_LINE_COMMENT :

		return null;
	}

	private TextEdit formatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);

		if (bodyDeclarations == null) {
			// a problem occurred while parsing the source
			return null;
		}
		return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions, includeComments);
	}

	/*

		return null;
	}

	/**
	 * Returns the resulting text edit after formatting the given comment.
	 *
	 * @param kind the given kind
	 * @param source the given source
	 * @param indentationLevel the given indentation level
	 * @param lineSeparator the given line separator
	 * @param regions the given regions
	 * @param includeComments TODO
	 * @return the resulting text edit
	 */
	private TextEdit formatComment(int kind, String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		Object oldOption = oldCommentFormatOption();
		boolean isFormattingComments = false;
		if (oldOption == null) {
			switch (kind & K_MASK) {
				case K_SINGLE_LINE_COMMENT:
					isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_LINE_COMMENT));
					break;
				case K_MULTI_LINE_COMMENT:
					isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT));
					break;
				case K_JAVA_DOC:
					isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT));
			}
		} else {
			isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(oldOption);
		}
		if (isFormattingComments) {
			if (lineSeparator != null) {
				this.preferences.line_separator = lineSeparator;
			} else {
				this.preferences.line_separator = Util.LINE_SEPARATOR;
			}
			this.preferences.initial_indentation_level = indentationLevel;
			this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, null, includeComments);

			IRegion coveredRegion = getCoveredRegion(regions);
			int offset = coveredRegion.getOffset();
			int length = coveredRegion.getLength();

			final CommentRegion region = createRegion(kind, new Document(source), new Position(offset, length), this.newCodeFormatter);
			if (region != null) {
				return this.newCodeFormatter.format(source, region);
			}
		}
		return new MultiTextEdit();
	}

	private TextEdit formatCompilationUnit(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		CompilationUnitDeclaration compilationUnitDeclaration = this.codeSnippetParsingUtil.parseCompilationUnit(source.toCharArray(), getDefaultCompilerOptions(), true);


		return this.newCodeFormatter.format(source, compilationUnitDeclaration);
	}

	private TextEdit formatExpression(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);

		if (expression == null) {
			// a problem occurred while parsing the source
			return null;
		}
		return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions, includeComments);
	}

	private TextEdit formatStatements(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);

		if (constructorDeclaration.statements == null) {
			// a problem occured while parsing the source
			return null;
		}
		return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions, includeComments);
	}

	private IRegion getCoveredRegion(IRegion[] regions) {

		return this.defaultCompilerOptions;
	}

	private TextEdit internalFormatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, ASTNode[] bodyDeclarations, IRegion[] regions, boolean includeComments) {
		if (lineSeparator != null) {
			this.preferences.line_separator = lineSeparator;
		} else {

		}
		this.preferences.initial_indentation_level = indentationLevel;

		this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);
		return this.newCodeFormatter.format(source, bodyDeclarations);
	}

	private TextEdit internalFormatExpression(String source, int indentationLevel, String lineSeparator, Expression expression, IRegion[] regions, boolean includeComments) {
		if (lineSeparator != null) {
			this.preferences.line_separator = lineSeparator;
		} else {

		}
		this.preferences.initial_indentation_level = indentationLevel;

		this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);

		TextEdit textEdit = this.newCodeFormatter.format(source, expression);
		return textEdit;
	}

	private TextEdit internalFormatStatements(String source, int indentationLevel, String lineSeparator, ConstructorDeclaration constructorDeclaration, IRegion[] regions, boolean includeComments) {
		if (lineSeparator != null) {
			this.preferences.line_separator = lineSeparator;
		} else {

		}
		this.preferences.initial_indentation_level = indentationLevel;

		this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);

		return this.newCodeFormatter.format(source, constructorDeclaration);
	}

					break;
			}
			if (kind != -1) {
				return formatComment(kind, source, indentationLevel, lineSeparator, regions);
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
				// use the integrated comment formatter to format comment
				if (ENABLE_NEW_COMMENTS_FORMAT /*|| FORCE_NEW_COMMENTS_FORMAT*/) {
					return formatComment(kind, source, indentationLevel, lineSeparator, regions);
				}
				return formatComment(kind, source, indentationLevel, lineSeparator, regions, includeComments);
			}
		} catch (InvalidInputException e) {
			// ignore

		// probe for expression
		Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);
		if (expression != null) {
			return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions, includeComments);
		}

		// probe for body declarations (fields, methods, constructors)
		ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);
		if (bodyDeclarations != null) {
			return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions, includeComments);
		}

		// probe for statements
		ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);
		if (constructorDeclaration.statements != null) {
			return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions, includeComments);
		}

		// this has to be a compilation unit




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

import java.util.LinkedList;

import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

/**
 * General comment line in a comment region.
 *
 * @since 3.0
 */
public abstract class CommentLine implements IBorderAttributes {

	/** Prefix of non-formattable comment lines */
	protected static final String NON_FORMAT_START_PREFIX= "/*-"; //$NON-NLS-1$

	/** The attributes of this line */
	private int fAttributes= 0;

	/** The parent region of this line */
	private final CommentRegion fParent;

	/** The comment ranges in this line */
	private final LinkedList fRanges= new LinkedList();

	/**
	 * Creates a new comment line.
	 *
	 * @param parent comment region to create the comment line for
	 */
	protected CommentLine(final CommentRegion parent) {
		this.fParent= parent;
	}

	/**
	 * Adapts the line attributes from the previous line in the comment
	 * region.
	 *
	 * @param previous the previous comment line in the comment region
	 */
	protected abstract void adapt(final CommentLine previous);

	/**
	 * Appends the specified comment range to this comment line.
	 *
	 * @param range comment range to append to this line
	 */
	protected void append(final CommentRange range) {
		this.fRanges.add(range);
	}

	/**
	 * Formats this comment line as content line.
	 *
	 * @param predecessor the predecessor comment line in the comment region
	 * @param last the most recently processed comment range
	 * @param indentation the indentation of the comment region
	 * @param line the index of this comment line in the comment region
	 * @return the first comment range in this comment line
	 */
	protected CommentRange formatLine(final CommentLine predecessor, final CommentRange last, final String indentation, final int line) {

		int offset= 0;
		int length= 0;

		CommentRange next= last;
		CommentRange previous= null;

		final int stop= this.fRanges.size() - 1;
		final int end= this.fParent.getSize() - 1;

		for (int index= stop; index >= 0; index--) {

			previous= next;
			next= (CommentRange)this.fRanges.get(index);

			if (this.fParent.canFormat(previous, next)) {

				offset= next.getOffset() + next.getLength();
				length= previous.getOffset() - offset;

				if (index == stop && line != end)
					this.fParent.logEdit(this.fParent.getDelimiter(predecessor, this, previous, next, indentation), offset, length);
				else
					this.fParent.logEdit(this.fParent.getDelimiter(previous, next), offset, length);
			}
		}
		return next;
	}

	/**
	 * Formats this comment line as end line having a lower border
	 * consisting of content line prefixes.
	 *
	 * @param range last comment range of the last comment line in the
	 *                comment region
	 * @param indentation the indentation of the comment region
	 * @param length the maximal length of text in this comment region
	 *                measured in average character widths
	 */
	protected void formatLowerBorder(final CommentRange range, final String indentation, final int length) {

		final int offset= range.getOffset() + range.getLength();

		final StringBuffer buffer= new StringBuffer(length);
		final String end= getEndingPrefix();
		final String delimiter= this.fParent.getDelimiter();

		if (this.fParent.isSingleLine() && this.fParent.getSize() == 1)
			buffer.append(end);
		else {

			final String filler= getContentPrefix().trim();

			buffer.append(delimiter);
			buffer.append(indentation);

			if (this.fParent.hasBorder(BORDER_LOWER)) {

				buffer.append(' ');
				for (int character= 0; character < length; character++)
					buffer.append(filler);

				buffer.append(end.trim());

			} else
				buffer.append(end);
		}
		this.fParent.logEdit(buffer.toString(), offset, this.fParent.getLength() - offset);
	}

	/**
	 * Formats this comment line as start line having an upper border
	 * consisting of content line prefixes.
	 *
	 * @param range the first comment range in the comment region
	 * @param indentation the indentation of the comment region
	 * @param length the maximal length of text in this comment region
	 *                measured in average character widths
	 */
	protected void formatUpperBorder(final CommentRange range, final String indentation, final int length) {

		final StringBuffer buffer= new StringBuffer(length);
		final String start= getStartingPrefix();
		final String content= getContentPrefix();

		if (this.fParent.isSingleLine() && this.fParent.getSize() == 1)
			buffer.append(start);
		else {

			final String trimmed= start.trim();
			final String filler= content.trim();

			buffer.append(trimmed);

			if (this.fParent.hasBorder(BORDER_UPPER)) {

				for (int character= 0; character < length - trimmed.length() + start.length(); character++)
					buffer.append(filler);
			}

			buffer.append(this.fParent.getDelimiter());
			buffer.append(indentation);
			buffer.append(content);
		}
		this.fParent.logEdit(buffer.toString(), 0, range.getOffset());
	}

	/**
	 * Returns the line prefix of content lines.
	 *
	 * @return line prefix of content lines
	 */
	protected abstract String getContentPrefix();

	/**
	 * Returns the line prefix of end lines.
	 *
	 * @return line prefix of end lines
	 */
	protected abstract String getEndingPrefix();

	/**
	 * Returns the first comment range in this comment line.
	 *
	 * @return the first comment range
	 */
	protected final CommentRange getFirst() {
		return (CommentRange)this.fRanges.getFirst();
	}

	/**
	 * Returns the indentation reference string for this line.
	 *
	 * @return the indentation reference string for this line
	 */
	protected String getIndentationReference() {
		return ""; //$NON-NLS-1$
	}

	/**
	 * Returns the last comment range in this comment line.
	 *
	 * @return the last comment range
	 */
	protected final CommentRange getLast() {
		return (CommentRange)this.fRanges.getLast();
	}

	/**
	 * Returns the parent comment region of this comment line.
	 *
	 * @return the parent comment region
	 */
	protected final CommentRegion getParent() {
		return this.fParent;
	}

	/**
	 * Returns the number of comment ranges in this comment line.
	 *
	 * @return the number of ranges in this line
	 */
	protected final int getSize() {
		return this.fRanges.size();
	}

	/**
	 * Returns the line prefix of start lines.
	 *
	 * @return line prefix of start lines
	 */
	protected abstract String getStartingPrefix();

	/**
	 * Is the attribute <code>attribute</code> true?
	 *
	 * @param attribute the attribute to get.
	 * @return <code>true</code> iff this attribute is <code>true</code>,
	 *         <code>false</code> otherwise.
	 */
	protected final boolean hasAttribute(final int attribute) {
		return (this.fAttributes & attribute) == attribute;
	}

	/**
	 * Scans this comment line for comment range boundaries.
	 *
	 * @param line the index of this line in the comment region
	 */
	protected abstract void scanLine(final int line);

	/**
	 * Set the attribute <code>attribute</code> to true.
	 *
	 * @param attribute the attribute to set.
	 */
	protected final void setAttribute(final int attribute) {
		this.fAttributes |= attribute;
	}

	/**
	 * Tokenizes this comment line into comment ranges
	 *
	 * @param line the index of this line in the comment region
	 */
	protected void tokenizeLine(final int line) {

		int offset= 0;
		int index= offset;

		final CommentRange range= (CommentRange)this.fRanges.get(0);
		final int begin= range.getOffset();

		final String content= this.fParent.getText(begin, range.getLength());
		final int length= content.length();

		while (offset < length) {

			while (offset < length && ScannerHelper.isWhitespace(content.charAt(offset)))
				offset++;

			index= offset;

			while (index < length && !ScannerHelper.isWhitespace(content.charAt(index)))
				index++;

			if (index - offset > 0) {
				this.fParent.append(new CommentRange(begin + offset, index - offset));

				offset= index;
			}
		}
	}

	public String toString() {
		final StringBuffer buffer = new StringBuffer();
		final int size = this.fRanges.size();
		for (int i = 0; i < size; i++) {
			buffer.append(this.fRanges.get(i)).append("\n"); //$NON-NLS-1$
		}
		return String.valueOf(buffer);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

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

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jface.text.Position;

/**
 * Range in a comment region in comment region coordinates.
 *
 * @since 3.0
 */
public class CommentRange extends Position implements ICommentAttributes, IHtmlTagDelimiters {

	/** The attributes of this range */
	private int fAttributes= 0;

	/**
	 * Creates a new comment range.
	 *
	 * @param position offset of the range
	 * @param count length of the range
	 */
	public CommentRange(final int position, final int count) {
		super(position, count);
	}

	/**
	 * Is the attribute <code>attribute</code> true?
	 *
	 * @param attribute the attribute to get
	 * @return <code>true</code> iff this attribute is <code>true</code>,
	 *         <code>false</code> otherwise
	 */
	protected final boolean hasAttribute(final int attribute) {
		return (this.fAttributes & attribute) == attribute;
	}

	/**
	 * Does this comment range contain a closing HTML tag?
	 *
	 * @param token token belonging to the comment range
	 * @param tag the HTML tag to check
	 * @return <code>true</code> iff this comment range contains a closing
	 *         html tag, <code>false</code> otherwise
	 */
	protected final boolean isClosingTag(final char[] token, final char[] tag) {

		boolean result= (CharOperation.indexOf(HTML_CLOSE_PREFIX, token, false) == 0)
				&& token[token.length - 1] == HTML_TAG_POSTFIX;
		if (result) {

			setAttribute(COMMENT_CLOSE);
			result= CharOperation.equals(tag, token, HTML_CLOSE_PREFIX.length, token.length - 1, false);
		}
		return result;
	}

	/**
	 * Does this comment range contain an opening HTML tag?
	 *
	 * @param token token belonging to the comment range
	 * @param tag the HTML tag to check
	 * @return <code>true</code> iff this comment range contains an
	 *         opening html tag, <code>false</code> otherwise
	 */
	protected final boolean isOpeningTag(final char[] token, final char[] tag) {

		boolean result= token.length > 0
				&& token[0] == HTML_TAG_PREFIX
				&& (CharOperation.indexOf(HTML_CLOSE_PREFIX, token, false) != 0)
				&& token[token.length - 1] == HTML_TAG_POSTFIX;
		if (result) {

			setAttribute(COMMENT_OPEN);
			result= CharOperation.indexOf(tag, token, false) == 1;
		}
		return result;
	}

	/**
	 * Mark the comment range with the occurred HTML tags.
	 *
	 * @param tags the HTML tags to test for their occurrence
	 * @param token token belonging to the comment range
	 * @param attribute attribute to set if a HTML tag is present
	 * @param open <code>true</code> iff opening tags should be marked,
	 *                <code>false</code> otherwise
	 * @param close <code>true</code> iff closing tags should be marked,
	 *                <code>false</code> otherwise
	 */
	protected final void markHtmlTag(final char[][] tags, final char[] token, final int attribute, final boolean open, final boolean close) {
		if (token[0] == HTML_TAG_PREFIX && token[token.length - 1] == HTML_TAG_POSTFIX) {

			char[] tag= null;
			boolean isOpen= false;
			boolean isClose= false;

			for (int index= 0; index < tags.length; index++) {

				tag= tags[index];

				isOpen= isOpeningTag(token, tag);
				isClose= isClosingTag(token, tag);

				if ((open && isOpen) || (close && isClose)) {

					setAttribute(attribute);
					break;
				}
			}
		}
	}

	/**
	 * Mark the comment range with the occurred tags.
	 *
	 * @param tags the tags to test for their occurrence
	 * @param prefix the prefix which is common to all the tags to test
	 * @param token the token belonging to the comment range
	 * @param attribute attribute to set if a tag is present
	 */
	protected final void markPrefixTag(final char[][] tags, final char prefix, final char[] token, final int attribute) {

		if (token[0] == prefix) {

			char[] tag= null;
			for (int index= 0; index < tags.length; index++) {

				tag= tags[index];
				if (CharOperation.equals(token, tag)) {

					setAttribute(attribute);
					break;
				}
			}
		}
	}

	/**
	 * Marks the comment range with the HTML range tag.
	 *
	 * @param token the token belonging to the comment range
	 * @param tag the HTML tag which confines the HTML range
	 * @param level the nesting level of the current HTML range
	 * @param key the key of the attribute to set if the comment range is in
	 *                the HTML range
	 * @param html <code>true</code> iff the HTML tags in this HTML range
	 *                should be marked too, <code>false</code> otherwise
	 * @return the new nesting level of the HTML range
	 */
	protected final int markTagRange(final char[] token, final char[] tag, int level, final int key, final boolean html) {

		if (isOpeningTag(token, tag)) {
			if (level++ > 0)
				setAttribute(key);
		} else if (isClosingTag(token, tag)) {
			if (--level > 0)
				setAttribute(key);
		} else if (level > 0) {
			if (html || !hasAttribute(COMMENT_HTML))
				setAttribute(key);
		}
		return level;
	}

	/**
	 * Moves this comment range.
	 *
	 * @param delta the delta to move the range
	 */
	public final void move(final int delta) {
		this.offset += delta;
	}

	/**
	 * Set the attribute <code>attribute</code> to true.
	 *
	 * @param attribute the attribute to set.
	 */
	protected final void setAttribute(final int attribute) {
		this.fAttributes |= attribute;
	}

	/**
	 * Trims this comment range at the beginning.
	 *
	 * @param delta amount to trim the range
	 */
	public final void trimBegin(final int delta) {
		this.offset += delta;
		this.length -= delta;
	}

	/**
	 * Trims this comment range at the end.
	 *
	 * @param delta amount to trim the range
	 */
	public final void trimEnd(final int delta) {
		this.length += delta;
	}

	/*
	 * @see java.lang.Object#toString()
	 * @since 3.1
	 */
	public String toString() {
		List attributes= new ArrayList();
		if (hasAttribute(COMMENT_BLANKLINE))
			attributes.add("COMMENT_BLANKLINE"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_BREAK))
			attributes.add("COMMENT_BREAK"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_CLOSE))
			attributes.add("COMMENT_CLOSE"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_CODE))
			attributes.add("COMMENT_CODE"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_HTML))
			attributes.add("COMMENT_HTML"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_IMMUTABLE))
			attributes.add("COMMENT_IMMUTABLE"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_NEWLINE))
			attributes.add("COMMENT_NEWLINE"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_OPEN))
			attributes.add("COMMENT_OPEN"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_PARAGRAPH))
			attributes.add("COMMENT_PARAGRAPH"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_PARAMETER))
			attributes.add("COMMENT_PARAMETER"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_ROOT))
			attributes.add("COMMENT_ROOT"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_SEPARATOR))
			attributes.add("COMMENT_SEPARATOR"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_FIRST_TOKEN))
			attributes.add("COMMENT_FIRST_TOKEN"); //$NON-NLS-1$
		if (hasAttribute(COMMENT_STARTS_WITH_RANGE_DELIMITER))
			attributes.add("COMMENT_STARTS_WITH_RANGE_DELIMITER"); //$NON-NLS-1$

		StringBuffer buf= new StringBuffer("CommentRange [" + this.offset + "+" + this.length + "] {"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		for (Iterator it= attributes.iterator(); it.hasNext();) {
			String string= (String) it.next();
			buf.append(string);
			if (it.hasNext())
				buf.append(", "); //$NON-NLS-1$
		}

		return buf.toString() + "}"; //$NON-NLS-1$
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

import java.util.Iterator;
import java.util.LinkedList;

import org.eclipse.core.runtime.Assert;

import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.TextEdit;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultLineTracker;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ILineTracker;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;

import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.formatter.CodeFormatterVisitor;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.jdt.internal.formatter.Scribe;

/**
 * Comment region in a source code document.
 *
 * @since 3.0
 */
public class CommentRegion extends Position implements IHtmlTagDelimiters, IBorderAttributes, ICommentAttributes {

	/** Default comment range delimiter */
	protected static final String COMMENT_RANGE_DELIMITER= " "; //$NON-NLS-1$

	/** Default line prefix length */
	private static final int COMMENT_PREFIX_LENGTH= 3;

	/** The borders of this region */
	private int fBorders= 0;

	/** Should all blank lines be cleared during formatting? */
	protected boolean fClear;

	/** The line delimiter used in this comment region */
	private final String fDelimiter;

	/** The document to format */
	private final IDocument fDocument;

	/** The lines in this comment region */
	private final LinkedList fLines= new LinkedList();

	/** The formatting preferences */
	protected final DefaultCodeFormatterOptions preferences;

	/** The comment ranges in this comment region */
	private final LinkedList fRanges= new LinkedList();

	/** Is this comment region a single line region? */
	private final boolean fSingleLine;

	/** Number of spaces representing tabulator */
	private int fTabSize;

	/** the scribe used to create edits */
	protected Scribe scribe;

	/**
	 * Creates a new comment region.
	 *
	 * @param document the document which contains the comment region
	 * @param position the position of this comment region in the document
	 * @param formatter the given code formatter
	 */
	public CommentRegion(final IDocument document, final Position position, final CodeFormatterVisitor formatter) {
		super(position.getOffset(), position.getLength());

		this.preferences = formatter.preferences;
		this.fDelimiter = this.preferences.line_separator;
		this.fDocument= document;

		this.fTabSize= DefaultCodeFormatterOptions.SPACE == this.preferences.tab_char ? this.preferences.indentation_size : this.preferences.tab_size;

		this.scribe = formatter.scribe;

		final ILineTracker tracker= new DefaultLineTracker();

		IRegion range= null;
		CommentLine line= null;

		tracker.set(getText(0, getLength()));
		final int lines= tracker.getNumberOfLines();

		this.fSingleLine= lines == 1;

		try {

			for (int index= 0; index < lines; index++) {

				range= tracker.getLineInformation(index);
				line= createLine();
				line.append(new CommentRange(range.getOffset(), range.getLength()));

				this.fLines.add(line);
			}

		} catch (BadLocationException exception) {
			// Should not happen
		}
	}

	/**
	 * Appends the comment range to this comment region.
	 *
	 * @param range comment range to append to this comment region
	 */
	protected final void append(final CommentRange range) {
		this.fRanges.addLast(range);
	}

	/**
	 * Can the comment range be appended to the comment line?
	 *
	 * @param line comment line where to append the comment range
	 * @param previous comment range which is the predecessor of the current
	 *                comment range
	 * @param next comment range to test whether it can be appended to the
	 *                comment line
	 * @param index amount of space in the comment line used by already
	 *                inserted comment ranges
	 * @param width the maximal width of text in this comment region
	 *                measured in average character widths
	 * @return <code>true</code> iff the comment range can be added to the
	 *         line, <code>false</code> otherwise
	 */
	protected boolean canAppend(final CommentLine line, final CommentRange previous, final CommentRange next, final int index, final int width) {
		return index == 0 || index + next.getLength() <= width;
	}

	/**
	 * Can the whitespace between the two comment ranges be formatted?
	 *
	 * @param previous previous comment range which was already formatted,
	 *                can be <code>null</code>
	 * @param next next comment range to be formatted
	 * @return <code>true</code> iff the next comment range can be
	 *         formatted, <code>false</code> otherwise.
	 */
	protected boolean canFormat(final CommentRange previous, final CommentRange next) {
		return previous != null;
	}

	/**
	 * Formats the comment region with the given indentation level.
	 *
	 * @param indentationLevel the indentation level
	 * @return the resulting text edit of the formatting process
	 * @since 3.1
	 */
	public final TextEdit format(int indentationLevel, boolean returnEdit) {
		final String probe= getText(0, CommentLine.NON_FORMAT_START_PREFIX.length());
		if (!probe.startsWith(CommentLine.NON_FORMAT_START_PREFIX)) {

			int margin= this.preferences.comment_line_length;
			String indentation= computeIndentation(indentationLevel);
			margin= Math.max(COMMENT_PREFIX_LENGTH + 1, margin - stringToLength(indentation) - COMMENT_PREFIX_LENGTH);

			tokenizeRegion();
			markRegion();
			wrapRegion(margin);
			formatRegion(indentation, margin);

		}
		if (returnEdit) {
			return this.scribe.getRootEdit();
		}
		return null;
	}

	/**
	 * Formats this comment region.
	 *
	 * @param indentation the indentation of this comment region
	 * @param width the maximal width of text in this comment region
	 *                measured in average character widths
	 */
	protected void formatRegion(final String indentation, final int width) {

		final int last= this.fLines.size() - 1;
		if (last >= 0) {

			CommentLine lastLine= (CommentLine)this.fLines.get(last);
			CommentRange lastRange= lastLine.getLast();
			lastLine.formatLowerBorder(lastRange, indentation, width);

			CommentLine previous;
			CommentLine next= null;
			CommentRange range= null;
			for (int line= last; line >= 0; line--) {

				previous= next;
				next= (CommentLine)this.fLines.get(line);

				range= next.formatLine(previous, range, indentation, line);
			}
			next.formatUpperBorder(range, indentation, width);
		}
	}

	/**
	 * Returns the line delimiter used in this comment region.
	 *
	 * @return the line delimiter for this comment region
	 */
	protected final String getDelimiter() {
		return this.fDelimiter;
	}

	/**
	 * Returns the line delimiter used in this comment line break.
	 *
	 * @param predecessor the predecessor comment line after the line break
	 * @param successor the successor comment line before the line break
	 * @param previous the comment range after the line break
	 * @param next the comment range before the line break
	 * @param indentation indentation of the formatted line break
	 * @return the line delimiter for this comment line break
	 */
	protected String getDelimiter(final CommentLine predecessor, final CommentLine successor, final CommentRange previous, final CommentRange next, final String indentation) {
		return this.fDelimiter + indentation + successor.getContentPrefix();
	}

	/**
	 * Returns the range delimiter for this comment range break.
	 *
	 * @param previous the previous comment range to the right of the range
	 *                delimiter
	 * @param next the next comment range to the left of the range delimiter
	 * @return the delimiter for this comment range break
	 */
	protected String getDelimiter(final CommentRange previous, final CommentRange next) {
		return COMMENT_RANGE_DELIMITER;
	}

	/**
	 * Returns the document of this comment region.
	 *
	 * @return the document of this region
	 */
	protected final IDocument getDocument() {
		return this.fDocument;
	}

	/**
	 * Returns the comment ranges in this comment region
	 *
	 * @return the comment ranges in this region
	 */
	protected final LinkedList getRanges() {
		return this.fRanges;
	}

	/**
	 * Returns the number of comment lines in this comment region.
	 *
	 * @return the number of lines in this comment region
	 */
	protected final int getSize() {
		return this.fLines.size();
	}

	/**
	 * Returns the text of this comment region in the indicated range.
	 *
	 * @param position the offset of the comment range to retrieve in
	 *                comment region coordinates
	 * @param count the length of the comment range to retrieve
	 * @return the content of this comment region in the indicated range
	 */
	protected final String getText(final int position, final int count) {

		String content= ""; //$NON-NLS-1$
		try {
			content= this.fDocument.get(getOffset() + position, count);
		} catch (BadLocationException exception) {
			// Should not happen
		}
		return content;
	}

	/**
	 * Does the border <code>border</code> exist?
	 *
	 * @param border the type of the border, must be a border attribute of
	 *                <code>CommentRegion</code>
	 * @return <code>true</code> iff this border exists,
	 *         <code>false</code> otherwise
	 */
	protected final boolean hasBorder(final int border) {
		return (this.fBorders & border) == border;
	}

	/**
	 * Does the comment range consist of letters and digits only?
	 *
	 * @param range the comment range to text
	 * @return <code>true</code> iff the comment range consists of letters
	 *         and digits only, <code>false</code> otherwise
	 */
	protected final boolean isAlphaNumeric(final CommentRange range) {

		final String token= getText(range.getOffset(), range.getLength());

		for (int index= 0; index < token.length(); index++) {
			if (!ScannerHelper.isLetterOrDigit(token.charAt(index)))
				return false;
		}
		return true;
	}

	/**
	 * Does the comment range contain no letters and digits?
	 *
	 * @param range the comment range to text
	 * @return <code>true</code> iff the comment range contains no letters
	 *         and digits, <code>false</code> otherwise
	 */
	protected final boolean isNonAlphaNumeric(final CommentRange range) {

		final String token= getText(range.getOffset(), range.getLength());

		for (int index= 0; index < token.length(); index++) {
			if (ScannerHelper.isLetterOrDigit(token.charAt(index)))
				return false;
		}
		return true;
	}

	/**
	 * Should blank lines be cleared during formatting?
	 *
	 * @return <code>true</code> iff blank lines should be cleared,
	 *         <code>false</code> otherwise
	 */
	protected final boolean isClearLines() {
		return this.fClear;
	}

	/**
	 * Is this comment region a single line region?
	 *
	 * @return <code>true</code> iff this region is single line,
	 *         <code>false</code> otherwise
	 */
	protected final boolean isSingleLine() {
		return this.fSingleLine;
	}

	/**
	 * Logs a text edit operation occurred during the formatting process
	 *
	 * @param change the changed text
	 * @param position offset measured in comment region coordinates where
	 *                to apply the changed text
	 * @param count length of the range where to apply the changed text
	 */
	protected final void logEdit(final String change, final int position, final int count) {
		try {
			final int base= getOffset() + position;
			final String content= this.fDocument.get(base, count);

			if (!change.equals(content)) {
				if (count > 0) {
					this.scribe.addReplaceEdit(base, base + count - 1, change);
				} else {
					this.scribe.addInsertEdit(base, change);
				}
			}
		} catch (BadLocationException exception) {
			// Should not happen
			CommentFormatterUtil.log(exception);
		} catch (MalformedTreeException exception) {
			// Do nothing
			CommentFormatterUtil.log(exception);
		}
	}

	/**
	 * Marks the comment ranges in this comment region.
	 */
	protected void markRegion() {
		// Do nothing
	}

	/**
	 * Set the border type <code>border</code> to true.
	 *
	 * @param border the type of the border. Must be a border attribute of
	 *                <code>CommentRegion</code>
	 */
	protected final void setBorder(final int border) {
		this.fBorders |= border;
	}

	/**
	 * Returns the indentation of the given indentation level.
	 *
	 * @param indentationLevel the indentation level
	 * @return the indentation of the given indentation level
	 * @since 3.1
	 */
	private String computeIndentation(int indentationLevel) {
		if (DefaultCodeFormatterOptions.TAB == this.preferences.tab_char)
			return replicate("\t", indentationLevel); //$NON-NLS-1$

		if (DefaultCodeFormatterOptions.SPACE == this.preferences.tab_char)
			return replicate(" ", indentationLevel * this.preferences.tab_size); //$NON-NLS-1$

		if (DefaultCodeFormatterOptions.MIXED == this.preferences.tab_char) {
			int tabSize= this.preferences.tab_size;
			int indentSize= this.preferences.indentation_size;
			int spaceEquivalents= indentationLevel * indentSize;
			return replicate("\t", spaceEquivalents / tabSize) + replicate(" ", spaceEquivalents % tabSize); //$NON-NLS-1$ //$NON-NLS-2$
		}

		Assert.isTrue(false);
		return null;
	}

	/**
	 * Returns the given string n-times replicated.
	 *
	 * @param string the string
	 * @param n n
	 * @return the given string n-times replicated
	 * @since 3.1
	 */
	private String replicate(String string, int n) {
		StringBuffer buffer= new StringBuffer(n*string.length());
		for (int i= 0; i < n; i++)
			buffer.append(string);
		return buffer.toString();
	}

	/**
	 * Computes the equivalent indentation for a string
	 *
	 * @param reference the string to compute the indentation for
	 * @return the indentation string
	 */
	protected final String stringToIndent(final String reference) {
		return replicate(" ", stringToLength(reference)); //$NON-NLS-1$
	}

	/**
	 * Returns the length of the string in expanded characters.
	 *
	 * @param reference the string to get the length for
	 * @return the length of the string in expanded characters
	 */
	protected final int stringToLength(final String reference) {
		return expandTabs(reference).length();
	}

	/**
	 * Expands the given string's tabs according to the given tab size.
	 *
	 * @param string the string
	 * @return the expanded string
	 * @since 3.1
	 */
	private String expandTabs(String string) {
		StringBuffer expanded= new StringBuffer();
		for (int i= 0, n= string.length(), chars= 0; i < n; i++) {
			char ch= string.charAt(i);
			if (ch == '\t') {
				for (; chars < this.fTabSize; chars++)
					expanded.append(' ');
				chars= 0;
			} else {
				expanded.append(ch);
				chars++;
				if (chars >= this.fTabSize)
					chars= 0;
			}

		}
		return expanded.toString();
	}

	/**
	 * Tokenizes the comment region.
	 */
	protected void tokenizeRegion() {

		int index= 0;
		CommentLine line= null;

		for (final Iterator iterator= this.fLines.iterator(); iterator.hasNext(); index++) {

			line= (CommentLine)iterator.next();

			line.scanLine(index);
			line.tokenizeLine(index);
		}
	}

	/**
	 * Wraps the comment ranges in this comment region into comment lines.
	 *
	 * @param width the maximal width of text in this comment region
	 *                measured in average character widths
	 */
	protected void wrapRegion(final int width) {

		this.fLines.clear();

		int index= 0;
		boolean adapted= false;

		CommentLine successor= null;
		CommentLine predecessor= null;

		CommentRange previous= null;
		CommentRange next= null;

		while (!this.fRanges.isEmpty()) {

			index= 0;
			adapted= false;

			predecessor= successor;
			successor= createLine();
			this.fLines.add(successor);

			while (!this.fRanges.isEmpty()) {
				next= (CommentRange)this.fRanges.getFirst();

				if (canAppend(successor, previous, next, index, width)) {

					if (!adapted && predecessor != null) {

						successor.adapt(predecessor);
						adapted= true;
					}

					this.fRanges.removeFirst();
					successor.append(next);

					index += (next.getLength() + 1);
					previous= next;
				} else
					break;
			}
		}
	}

	/**
	 * Creates a new line for this region.
	 *
	 * @return a new line for this region
	 * @since 3.1
	 */
	protected CommentLine createLine() {
		return new SingleCommentLine(this);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

/**
 * Comment region border attributes.
 *
 * @since 3.0
 */
public interface IBorderAttributes {

	/** Region has lower border attribute */
	public static final int BORDER_LOWER= 1 << 0;

	/** Region has upper border attribute */
	public static final int BORDER_UPPER= 1 << 1;
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

/**
 * General comment range attributes.
 *
 * @since 3.0
 */
public interface ICommentAttributes {

	/** Range has blank line attribute */
	public static final int COMMENT_BLANKLINE= 1 << 1;

	/** Range has line break attribute */
	public static final int COMMENT_BREAK= 1 << 2;

	/** Range has close tag attribute */
	public static final int COMMENT_CLOSE= 1 << 3;

	/** Range has source code attribute */
	public static final int COMMENT_CODE= 1 << 4;

	/** Range has html tag attribute */
	public static final int COMMENT_HTML= 1 << 5;

	/** Range has the immutable region attribute */
	public static final int COMMENT_IMMUTABLE= 1 << 6;

	/** Range has new line attribute */
	public static final int COMMENT_NEWLINE= 1 << 7;

	/** Range has open tag attribute */
	public static final int COMMENT_OPEN= 1 << 8;

	/** Range has paragraph attribute */
	public static final int COMMENT_PARAGRAPH= 1 << 9;

	/** Range has parameter tag attribute */
	public static final int COMMENT_PARAMETER= 1 << 10;

	/** Range has root tag attribute */
	public static final int COMMENT_ROOT= 1 << 11;

	/** Range has paragraph separator attribute */
	public static final int COMMENT_SEPARATOR= 1 << 12;

	/** Range is the first token on the line in the original source */
	public static final int COMMENT_FIRST_TOKEN= 1 << 13;

	/**
	 * Range was preceded by whitespace / line delimiters
	 * @since 3.1
	 */
	public static final int COMMENT_STARTS_WITH_RANGE_DELIMITER= 1 << 14;
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

/**
 * Html tag constants.
 *
 * @since 3.0
 */
public interface IHtmlTagDelimiters {

	/** Html tag close prefix */
	public static final char[] HTML_CLOSE_PREFIX= "</".toCharArray(); //$NON-NLS-1$

	/** Html tag postfix */
	public static final char HTML_TAG_POSTFIX= '>';

	/** Html tag prefix */
	public static final char HTML_TAG_PREFIX= '<';
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

/**
 * Javadoc comment line in a comment region.
 *
 * @since 3.0
 */
public class JavaDocLine extends MultiCommentLine {

	/** Line prefix of javadoc start lines */
	public static final String JAVADOC_START_PREFIX= "/**"; //$NON-NLS-1$

	/**
	 * Creates a new javadoc line.
	 *
	 * @param region comment region to create the line for
	 */
	protected JavaDocLine(final CommentRegion region) {
		super(region);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#formatUpperBorder(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String, int)
	 */
	protected void formatUpperBorder(final CommentRange range, final String indentation, final int length) {

		final CommentRegion parent= getParent();

		if (parent.isSingleLine() && parent.getSize() == 1) {
			parent.logEdit(getStartingPrefix() + CommentRegion.COMMENT_RANGE_DELIMITER, 0, range.getOffset());
		} else
			super.formatUpperBorder(range, indentation, length);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getStartingPrefix()
	 */
	protected String getStartingPrefix() {
		return JAVADOC_START_PREFIX;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.text.edits.TextEdit;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultLineTracker;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ILineTracker;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.formatter.CodeFormatterVisitor;


/**
 * Javadoc region in a source code document.
 *
 * @since 3.0
 */
public class JavaDocRegion extends MultiCommentRegion {

	/** The positions of code ranges */
	private final ArrayList fCodePositions= new ArrayList();

	/** Should HTML tags be formatted? */
	private final boolean fFormatHtml;

	/** Should source code regions be formatted? */
	private final boolean fFormatSource;

 	/**
	 * Creates a new Javadoc region.
	 *
	 * @param document the document which contains the comment region
	 * @param position the position of this comment region in the document
	 * @param formatter the given formatter
	 */
	public JavaDocRegion(final IDocument document, final Position position, final CodeFormatterVisitor formatter) {
		super(document, position, formatter);

		this.fFormatSource = this.preferences.comment_format_source;
		this.fFormatHtml = this.preferences.comment_format_html;
		this.fClear = this.preferences.comment_clear_blank_lines_in_javadoc_comment;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#canFormat(org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange)
	 */
	protected boolean canFormat(final CommentRange previous, final CommentRange next) {

		if (previous != null) {

			final boolean isCurrentCode= next.hasAttribute(COMMENT_CODE);
			final boolean isLastCode= previous.hasAttribute(COMMENT_CODE);

			final int base= getOffset();

			if (!isLastCode && isCurrentCode)
				this.fCodePositions.add(new Position(base + previous.getOffset()));
			else if (isLastCode && !isCurrentCode)
				this.fCodePositions.add(new Position(base + next.getOffset() + next.getLength()));

			if (previous.hasAttribute(COMMENT_IMMUTABLE) && next.hasAttribute(COMMENT_IMMUTABLE))
				return false;

			return true;
		}
		return false;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#formatRegion(java.lang.String, int)
	 */
	protected final void formatRegion(final String indentation, final int width) {

		super.formatRegion(indentation, width);

		if (this.fFormatSource) {

			try {

				if (this.fCodePositions.size() > 0) {

					int begin= 0;
					int end= 0;

					Position position= null;

					final IDocument document= getDocument();

					for (int index= this.fCodePositions.size() - 1; index >= 0;) {

						position= (Position)this.fCodePositions.get(index--);
						begin= position.getOffset();

						if (index >= 0) {
							position= (Position)this.fCodePositions.get(index--);
							end= position.getOffset();
						} else {
							/*
							 * Handle missing closing tag
							 * see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=57011
							 */
							position= null;
							end= getOffset() + getLength() - MultiCommentLine.MULTI_COMMENT_END_PREFIX.trim().length();
							while (end > begin && ScannerHelper.isWhitespace(document.getChar(end - 1)))
								end--;
						}

						String snippet= document.get(begin, end - begin);
						snippet= preprocessCodeSnippet(snippet);
						snippet= formatCodeSnippet(snippet);
						snippet= postprocessCodeSnippet(snippet, indentation);

						logEdit(snippet, begin - getOffset(), end - begin);
					}
				}
			} catch (BadLocationException e) {
				// Can not happen
				CommentFormatterUtil.log(e);
			}
		}
	}

	/**
	 * Preprocess a given code snippet.
	 *
	 * @param snippet the code snippet
	 * @return the preprocessed code snippet
	 */
	private String preprocessCodeSnippet(String snippet) {
		// strip content prefix
		StringBuffer buffer= new StringBuffer();
		ILineTracker tracker= new DefaultLineTracker();
		String contentPrefix= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX.trim();

		buffer.setLength(0);
		buffer.append(snippet);
		tracker.set(snippet);
		for (int line= tracker.getNumberOfLines() - 1; line > 0; line--) {
			int lineOffset;
			try {
				lineOffset= tracker.getLineOffset(line);
			} catch (BadLocationException e) {
				// Can not happen
				CommentFormatterUtil.log(e);
				return snippet;
			}
			int prefixOffset= buffer.indexOf(contentPrefix, lineOffset);
			if (prefixOffset >= 0 && buffer.substring(lineOffset, prefixOffset).trim().length() == 0)
				buffer.delete(lineOffset, prefixOffset + contentPrefix.length() + 1);
		}

		return convertHtml2Java(buffer.toString());
	}

	/**
	 * Format the given code snippet
	 *
	 * @param snippet the code snippet
	 * @return the formatted code snippet
	 */
	private String formatCodeSnippet(String snippet) {
		String lineDelimiter= TextUtilities.getDefaultLineDelimiter(getDocument());
		TextEdit edit= CommentFormatterUtil.format2(CodeFormatter.K_UNKNOWN, snippet, 0, lineDelimiter, this.preferences.getMap());
		if (edit != null)
			snippet= CommentFormatterUtil.evaluateFormatterEdit(snippet, edit, null);
		return snippet;
	}

	/**
	 * Postprocesses the given code snippet with the given indentation.
	 *
	 * @param snippet the code snippet
	 * @param indentation the indentation
	 * @return the postprocessed code snippet
	 */
	private String postprocessCodeSnippet(String snippet, String indentation) {
		// patch content prefix
		StringBuffer buffer= new StringBuffer();
		ILineTracker tracker= new DefaultLineTracker();
		String patch= indentation + MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;

		// remove trailing spaces
		int i= snippet.length();
		while (i > 0 && ' ' == snippet.charAt(i-1))
			i--;
		snippet= snippet.substring(0, i);

		buffer.setLength(0);
		String lineDelimiter= getDelimiter();
		if (lineDelimiter != null && snippet.indexOf(lineDelimiter) != 0)
			buffer.append(lineDelimiter);
		buffer.append(convertJava2Html(snippet));
		if (lineDelimiter != null && snippet.lastIndexOf(lineDelimiter) != snippet.length() - lineDelimiter.length())
			buffer.append(lineDelimiter);
		tracker.set(buffer.toString());

		for (int line= tracker.getNumberOfLines() - 1; line > 0; line--)
			try {
				buffer.insert(tracker.getLineOffset(line), patch);
			} catch (BadLocationException e) {
				// Can not happen
				CommentFormatterUtil.log(e);
				return snippet;
			}

		return buffer.toString();
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markHtmlRanges()
	 */
	protected final void markHtmlRanges() {

		markTagRanges(JAVADOC_IMMUTABLE_TAGS, COMMENT_IMMUTABLE, true);

		if (this.fFormatSource)
			markTagRanges(JAVADOC_CODE_TAGS, COMMENT_CODE, false);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markHtmlTag(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String)
	 */
	protected final void markHtmlTag(final CommentRange range, final char[] token) {

		if (range.hasAttribute(COMMENT_HTML)) {

			range.markHtmlTag(JAVADOC_IMMUTABLE_TAGS, token, COMMENT_IMMUTABLE, true, true);
			if (this.fFormatHtml) {

				range.markHtmlTag(JAVADOC_SEPARATOR_TAGS, token, COMMENT_SEPARATOR, true, true);
				range.markHtmlTag(JAVADOC_BREAK_TAGS, token, COMMENT_BREAK, false, true);
				range.markHtmlTag(JAVADOC_SINGLE_BREAK_TAG, token, COMMENT_BREAK, true, false);
				range.markHtmlTag(JAVADOC_NEWLINE_TAGS, token, COMMENT_NEWLINE, true, false);

			} else
				range.markHtmlTag(JAVADOC_CODE_TAGS, token, COMMENT_SEPARATOR, true, true);
		}
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markJavadocTag(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String)
	 */
	protected final void markJavadocTag(final CommentRange range, final char[] token) {

		range.markPrefixTag(JAVADOC_PARAM_TAGS, COMMENT_TAG_PREFIX, token, COMMENT_PARAMETER);

		if (token[0] == JAVADOC_TAG_PREFIX && !range.hasAttribute(COMMENT_PARAMETER))
			range.setAttribute(COMMENT_ROOT);
	}

	/**
	 * Marks the comment region with the HTML range tag.
	 *
	 * @param tags the HTML tag which confines the HTML range
	 * @param attribute the attribute to set if the comment range is in the
	 *                HTML range
	 * @param html <code>true</code> iff the HTML tags in this HTML range
	 *                should be marked too, <code>false</code> otherwise
	 */
	protected final void markTagRanges(final char[][] tags, final int attribute, final boolean html) {

		int level= 0;
		int count= 0;
		char[] token= null;
		CommentRange current= null;

		for (int index= 0; index < tags.length; index++) {

			level= 0;
			for (final Iterator iterator= getRanges().iterator(); iterator.hasNext();) {

				current= (CommentRange)iterator.next();
				count= current.getLength();

				if (count > 0 || level > 0) { // PR44035: when inside a tag, mark blank lines as well to get proper snippet formatting

					token= getText(current.getOffset(), current.getLength()).toCharArray();
					level= current.markTagRange(token, tags[index], level, attribute, html);
				}
			}
		}
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#canAppend(org.eclipse.jdt.internal.corext.text.comment.CommentLine, org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange, int, int)
	 */
	protected boolean canAppend(CommentLine line, CommentRange previous, CommentRange next, int index, int count) {
		// don't append code sections
		if (next.hasAttribute(COMMENT_CODE | COMMENT_FIRST_TOKEN) && line.getSize() != 0)
			return false;
		return super.canAppend(line, previous, next, index, count);
	}

	/**
	 * Converts <code>formatted</code> into valid html code suitable to be
	 * put inside &lt;pre&gt;&lt;/pre&gt; tags by replacing any html symbols
	 * by the relevant entities.
	 *
	 * @param formatted the formatted java code
	 * @return html version of the formatted code
	 */
	private String convertJava2Html(String formatted) {
		Java2HTMLEntityReader reader= new Java2HTMLEntityReader(new StringReader(formatted));
		char[] buf= new char[256];
		StringBuffer buffer= new StringBuffer();
		int l;
		try {
			do {
				l= reader.read(buf);
				if (l != -1)
					buffer.append(buf, 0, l);
			} while (l > 0);
			return buffer.toString();
		} catch (IOException e) {
			return formatted;
		}
	}

	/**
	 * Converts <code>html</code> into java code suitable for formatting
	 * by replacing any html entities by their plain text representation.
	 *
	 * @param html html code, may contain html entities
	 * @return plain textified version of <code>html</code>
	 */
	private String convertHtml2Java(String html) {
		HTMLEntity2JavaReader reader= new HTMLEntity2JavaReader(new StringReader(html));
		char[] buf= new char[html.length()]; // html2text never gets longer, only shorter!

		try {
			int read= reader.read(buf);
			return new String(buf, 0, read);
		} catch (IOException e) {
			return html;
		}
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#createLine()
	 * @since 3.1
	 */
	protected CommentLine createLine() {
		return new JavaDocLine(this);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;

/**
 * Multi-line comment line in a comment region.
 *
 * @since 3.0
 */
public class MultiCommentLine extends CommentLine implements ICommentAttributes, IHtmlTagDelimiters, IJavaDocTagConstants {

	/** Line prefix of multi-line comment content lines */
	public static final String MULTI_COMMENT_CONTENT_PREFIX= " * "; //$NON-NLS-1$

	/** Line prefix of multi-line comment end lines */
	public static final String MULTI_COMMENT_END_PREFIX= " */"; //$NON-NLS-1$

	/** Line prefix of multi-line comment content lines */
	public static final String MULTI_COMMENT_START_PREFIX= "/* "; //$NON-NLS-1$

	/** The indentation reference of this line */
	private String fReferenceIndentation= ""; //$NON-NLS-1$

	/** The javadoc tag lookup. */
	private static final Set fgTagLookup;

	static {
		fgTagLookup= new HashSet();
		for (int i= 0; i < JAVADOC_BREAK_TAGS.length; i++) {
			fgTagLookup.add(new String(JAVADOC_BREAK_TAGS[i]));
		}
		for (int i= 0; i < JAVADOC_SINGLE_BREAK_TAG.length; i++) {
			fgTagLookup.add(new String(JAVADOC_SINGLE_BREAK_TAG[i]));
		}
		for (int i= 0; i < JAVADOC_CODE_TAGS.length; i++) {
			fgTagLookup.add(new String(JAVADOC_CODE_TAGS[i]));
		}
		for (int i= 0; i < JAVADOC_IMMUTABLE_TAGS.length; i++) {
			fgTagLookup.add(new String(JAVADOC_IMMUTABLE_TAGS[i]));
		}
		for (int i= 0; i < JAVADOC_NEWLINE_TAGS.length; i++) {
			fgTagLookup.add(new String(JAVADOC_NEWLINE_TAGS[i]));
		}
		for (int i= 0; i < JAVADOC_SEPARATOR_TAGS.length; i++) {
			fgTagLookup.add(new String(JAVADOC_SEPARATOR_TAGS[i]));
		}
	}

	/**
	 * Creates a new multi-line comment line.
	 *
	 * @param region comment region to create the line for
	 */
	protected MultiCommentLine(final CommentRegion region) {
		super(region);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#adapt(org.eclipse.jdt.internal.corext.text.comment.CommentLine)
	 */
	protected void adapt(final CommentLine previous) {

		if (!hasAttribute(COMMENT_ROOT) && !hasAttribute(COMMENT_PARAMETER) && !previous.hasAttribute(COMMENT_BLANKLINE))
			this.fReferenceIndentation= previous.getIndentationReference();
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#append(org.eclipse.jdt.internal.corext.text.comment.CommentRange)
	 */
	protected void append(final CommentRange range) {

		final MultiCommentRegion parent= (MultiCommentRegion)getParent();

		if (range.hasAttribute(COMMENT_PARAMETER))
			setAttribute(COMMENT_PARAMETER);
		else if (range.hasAttribute(COMMENT_ROOT))
			setAttribute(COMMENT_ROOT);
		else if (range.hasAttribute(COMMENT_BLANKLINE))
			setAttribute(COMMENT_BLANKLINE);

		final int ranges= getSize();
		if (ranges == 1) {

			if (parent.isIndentRoots()) {

				final CommentRange first= getFirst();
				final String common= parent.getText(first.getOffset(), first.getLength()) + CommentRegion.COMMENT_RANGE_DELIMITER;

				if (hasAttribute(COMMENT_ROOT))
					this.fReferenceIndentation= common;
				else if (hasAttribute(COMMENT_PARAMETER)) {
					if (parent.isIndentDescriptions())
						this.fReferenceIndentation= "\t" + common; //$NON-NLS-1$
					else
						this.fReferenceIndentation= common;
				}
			}
		}
		super.append(range);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getContentLinePrefix()
	 */
	protected String getContentPrefix() {
		return MULTI_COMMENT_CONTENT_PREFIX;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getEndLinePrefix()
	 */
	protected String getEndingPrefix() {
		return MULTI_COMMENT_END_PREFIX;
	}

	/**
	 * Returns the reference indentation to use for this line.
	 *
	 * @return the reference indentation for this line
	 */
	protected final String getIndentationReference() {
		return this.fReferenceIndentation;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getStartLinePrefix()
	 */
	protected String getStartingPrefix() {
		return MULTI_COMMENT_START_PREFIX;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#scanLine(int)
	 */
	protected void scanLine(final int line) {

		final CommentRegion parent= getParent();
		final String start= getStartingPrefix().trim();
		final String end= getEndingPrefix().trim();
		final String content= getContentPrefix().trim();

		final int lines= parent.getSize();
		final CommentRange range= getFirst();

		int offset= 0;
		int postfix= 0;

		String text= parent.getText(range.getOffset(), range.getLength());
		if (line == 0) {

			offset= text.indexOf(start);
			if (offset >= 0 && text.substring(0, offset).trim().length() != 0)
				offset= -1;

			if (offset >= 0) {

				offset += start.length();
				range.trimBegin(offset);

				postfix= text.lastIndexOf(end);
				if (postfix >= 0 && text.substring(postfix + end.length()).trim().length() != 0)
					postfix= -1;

				if (postfix >= offset)
					// comment ends on same line
					range.setLength(postfix - offset);
				else {
					postfix= text.lastIndexOf(content);
					if (postfix >= 0 && text.substring(postfix + content.length()).trim().length() != 0)
						postfix= -1;

					if (postfix >= offset) {

						range.setLength(postfix - offset);
						parent.setBorder(BORDER_UPPER);

						if (postfix > offset) {

							text= parent.getText(range.getOffset(), range.getLength());
							final IRegion region= trimLine(text, content);

							range.move(region.getOffset());
							range.setLength(region.getLength());
						}
					}
				}
			}
		} else if (line == lines - 1) {

			offset= text.indexOf(content);
			if (offset >= 0 && text.substring(0, offset).trim().length() != 0)
				offset= -1;
			postfix= text.lastIndexOf(end);
			if (postfix >= 0 && text.substring(postfix + end.length()).trim().length() != 0)
				postfix= -1;

			if (offset >= 0 && offset == postfix)
				// no content on line, only the comment postfix
				range.setLength(0);
			else {
				if (offset >= 0)
					// omit the content prefix
					range.trimBegin(offset + content.length());

				if (postfix >= 0)
					// omit the comment postfix
					range.trimEnd(-end.length());

				text= parent.getText(range.getOffset(), range.getLength());
				final IRegion region= trimLine(text, content);
				if (region.getOffset() != 0 || region.getLength() != text.length()) {

					range.move(region.getOffset());
					range.setLength(region.getLength());

					parent.setBorder(BORDER_UPPER);
					parent.setBorder(BORDER_LOWER);
				}
			}
		} else {

			offset= text.indexOf(content);
			if (offset >= 0 && text.substring(0, offset).trim().length() != 0)
				offset= -1;

			if (offset >= 0) {

				offset += content.length();
				range.trimBegin(offset);
			}
		}
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#tokenizeLine(int)
	 */
	protected void tokenizeLine(int line) {

		int offset= 0;
		int index= offset;

		final CommentRegion parent= getParent();
		final CommentRange range= getFirst();
		final int begin= range.getOffset();

		final String content= parent.getText(begin, range.getLength());
		final int length= content.length();

		while (offset < length && ScannerHelper.isWhitespace(content.charAt(offset)))
			offset++;

		CommentRange result= null;
		if (offset >= length && !parent.isClearLines() && (line > 0 && line < parent.getSize() - 1)) {

			result= new CommentRange(begin, 0);
			result.setAttribute(COMMENT_BLANKLINE);
			result.setAttribute(COMMENT_FIRST_TOKEN);

			parent.append(result);
		}

		int attribute= COMMENT_FIRST_TOKEN | COMMENT_STARTS_WITH_RANGE_DELIMITER;
		while (offset < length) {

			while (offset < length && ScannerHelper.isWhitespace(content.charAt(offset))) {
				offset++;
				attribute |= COMMENT_STARTS_WITH_RANGE_DELIMITER;
			}

			index= offset;

			if (index < length) {

				if (content.charAt(index) == HTML_TAG_PREFIX) {

					// in order to avoid recognizing any < in a comment, even those which are part of e.g.
					// java source code, we validate the tag content to be one of the recognized
					// tags (structural, breaks, pre, code).
					int tag= ++index;
					while (index < length && content.charAt(index) != HTML_TAG_POSTFIX && content.charAt(index) != HTML_TAG_PREFIX)
						index++;

					if (index < length && content.charAt(index) == HTML_TAG_POSTFIX && isValidTag(content.substring(tag, index))) {
						index++;
						attribute |= COMMENT_HTML; // only set html attribute if postfix found
					} else {
						// no tag - do the usual thing from the original offset
						index= tag;
						while (index < length
								&& !ScannerHelper.isWhitespace(content.charAt(index))
								&& content.charAt(index) != HTML_TAG_PREFIX
								&& !content.startsWith(LINK_TAG_PREFIX_STRING, index))
							index++;
					}


				} else if (content.startsWith(LINK_TAG_PREFIX_STRING, index)) {

					while (index < length && content.charAt(index) != LINK_TAG_POSTFIX)
						index++;

					if (index < length && content.charAt(index) == LINK_TAG_POSTFIX)
						index++;

					attribute |= COMMENT_OPEN | COMMENT_CLOSE;

				} else {

					while (index < length
							&& !ScannerHelper.isWhitespace(content.charAt(index))
							&& content.charAt(index) != HTML_TAG_PREFIX
							&& !content.startsWith(LINK_TAG_PREFIX_STRING, index))
						index++;
				}
			}

			if (index - offset > 0) {

				result= new CommentRange(begin + offset, index - offset);
				result.setAttribute(attribute);

				parent.append(result);
				offset= index;
			}

			attribute= 0;
		}
	}

	/**
	 * Checks whether <code>tag</code> is a valid tag content (text inside
	 * the angular brackets &lt;, &gt;).
	 * <p>
	 * The algorithm is to see if the tag trimmed of whitespace and an
	 * optional slash starts with one of our recognized tags.
	 *
	 * @param tag the tag to check
	 * @return <code>true</code> if <code>tag</code> is a valid tag
	 *         content
	 */
	private boolean isValidTag(String tag) {
		// strip the slash
		if (tag.startsWith("/")) //$NON-NLS-1$
			tag= tag.substring(1, tag.length());

		// strip ws
		tag= tag.trim();

		// extract first token
		int i= 0;
		while (i < tag.length() && !ScannerHelper.isWhitespace(tag.charAt(i)))
			i++;
		tag= tag.substring(0, i);

		// see if it's a tag
		return isTagName(tag.toLowerCase());
	}

	/**
	 * Checks whether <code>tag</code> is one of the configured tags.
	 *
	 * @param tag the tag to check
	 * @return <code>true</code> if <code>tag</code> is a configured tag
	 *         name
	 */
	private boolean isTagName(String tag) {
		return fgTagLookup.contains(tag);
	}

	/**
	 * Removes all leading and trailing occurrences from <code>line</code>.
	 *
	 * @param line the string to remove the occurrences of
	 *                <code>trimmable</code>
	 * @param trimmable the string to remove from <code>line</code>
	 * @return the region of the trimmed substring within <code>line</code>
	 */
	protected final IRegion trimLine(final String line, final String trimmable) {

		final int trim= trimmable.length();

		int offset= 0;
		int length= line.length() - trim;

		while (line.startsWith(trimmable, offset))
			offset += trim;

		while (line.startsWith(trimmable, length))
			length -= trim;

		return new Region(offset, length + trim);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

import java.util.Iterator;
import java.util.ListIterator;

import org.eclipse.jdt.internal.formatter.CodeFormatterVisitor;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Position;

/**
 * Multi-comment region in a source code document.
 *
 * @since 3.0
 */
public class MultiCommentRegion extends CommentRegion implements IJavaDocTagConstants {

	/** Should root tag parameter descriptions be indented after the tag? */
	private final boolean fIndentDescriptions;

	/** Should root tag parameter descriptions be indented? */
	private final boolean fIndentRoots;

	/** Should description of parameters go to the next line? */
	private final boolean fParameterNewLine;

	/** Should root tags be separated from description? */
	private boolean fSeparateRoots;

 	/**
	 * Creates a new multi-comment region.
	 *
	 * @param document the document which contains the comment region
	 * @param position the position of this comment region in the document
	 * @param formatter the given formatter
	 */
	public MultiCommentRegion(final IDocument document, final Position position, final CodeFormatterVisitor formatter) {
		super(document, position, formatter);

		this.fIndentRoots= this.preferences.comment_indent_root_tags;
		this.fIndentDescriptions= this.preferences.comment_indent_parameter_description;
		this.fSeparateRoots= this.preferences.comment_insert_empty_line_before_root_tags;
		this.fParameterNewLine= this.preferences.comment_insert_new_line_for_parameter;
		this.fClear = this.preferences.comment_clear_blank_lines_in_block_comment;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#canAppend(org.eclipse.jdt.internal.corext.text.comment.CommentLine, org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange, int, int)
	 */
	protected boolean canAppend(final CommentLine line, final CommentRange previous, final CommentRange next, final int index, int count) {

		final boolean blank= next.hasAttribute(COMMENT_BLANKLINE);

		// Avoid wrapping punctuation
		if (next.getLength() <= 2 && !blank && isNonAlphaNumeric(next))
			return true;

		if (this.fParameterNewLine && line.hasAttribute(COMMENT_PARAMETER) && line.getSize() > 1)
			return false;

		if (previous != null) {

			if (index != 0 && (blank || previous.hasAttribute(COMMENT_BLANKLINE) || next.hasAttribute(COMMENT_PARAMETER) || next.hasAttribute(COMMENT_ROOT) || next.hasAttribute(COMMENT_SEPARATOR) || next.hasAttribute(COMMENT_NEWLINE) || previous.hasAttribute(COMMENT_BREAK) || previous.hasAttribute(COMMENT_SEPARATOR)))
				return false;

			if (previous.hasAttribute(COMMENT_ROOT))
				return true;

			if (next.hasAttribute(COMMENT_IMMUTABLE) && previous.hasAttribute(COMMENT_IMMUTABLE))
				return true;
		}

		// always append elements that did not have any range separators
		if (!next.hasAttribute(COMMENT_STARTS_WITH_RANGE_DELIMITER)) {
			return true;
		}

		if (this.fIndentRoots && !line.hasAttribute(COMMENT_ROOT) && !line.hasAttribute(COMMENT_PARAMETER))
			count -= stringToLength(line.getIndentationReference());

		// Avoid appending consecutive immutable ranges, which together exceed the line width
		if (next.hasAttribute(COMMENT_IMMUTABLE) && (previous == null || !previous.hasAttribute(COMMENT_IMMUTABLE))) {
			// Breaking the abstraction by directly accessing the list of ranges for looking ahead
			Iterator iter= getRanges().iterator();
			CommentRange current= null;
			while (iter.hasNext() && current != next)
				current= (CommentRange) iter.next();

			if (current != null && iter.hasNext()) {
				try {
					int lineNumber= getDocument().getLineOfOffset(getOffset() + current.getOffset());
					CommentRange last= current;
					while (iter.hasNext()) {
						current= (CommentRange) iter.next();
						if (current.hasAttribute(COMMENT_IMMUTABLE) && getDocument().getLineOfOffset(getOffset() + current.getOffset()) == lineNumber)
							last= current;
						else
							break;
					}
					count -= last.getOffset() + last.getLength() - (next.getOffset() + next.getLength());
				} catch (BadLocationException e) {
					// Should not happen
				}
			}
		}

		return super.canAppend(line, previous, next, index, count);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#getDelimiter(org.eclipse.jdt.internal.corext.text.comment.CommentLine, org.eclipse.jdt.internal.corext.text.comment.CommentLine, org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String)
	 */
	protected String getDelimiter(CommentLine predecessor, CommentLine successor, CommentRange previous, CommentRange next, String indentation) {

		final String delimiter= super.getDelimiter(predecessor, successor, previous, next, indentation);

		if (previous != null) {

			// Blank line before <pre> tag
			if (previous.hasAttribute(COMMENT_IMMUTABLE | COMMENT_SEPARATOR) && !next.hasAttribute(COMMENT_CODE) && !successor.hasAttribute(COMMENT_BLANKLINE))
				return delimiter + delimiter;

			// Blank line after </pre> tag
			else if (next.hasAttribute(COMMENT_IMMUTABLE | COMMENT_SEPARATOR) && !successor.hasAttribute(COMMENT_BLANKLINE) && !predecessor.hasAttribute(COMMENT_BLANKLINE))
				return delimiter + delimiter;

			// Add blank line before first root/parameter tag, if "Blank line before Javadoc tags"
			else if (this.fSeparateRoots && previous.hasAttribute(COMMENT_PARAGRAPH) && !successor.hasAttribute(COMMENT_BLANKLINE) && !predecessor.hasAttribute(COMMENT_BLANKLINE))
				return delimiter + delimiter;

			else if (this.fIndentRoots && !predecessor.hasAttribute(COMMENT_ROOT) && !predecessor.hasAttribute(COMMENT_PARAMETER) && !predecessor.hasAttribute(COMMENT_BLANKLINE))
				return delimiter + stringToIndent(predecessor.getIndentationReference());
		}
		return delimiter;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#getDelimiter(org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange)
	 */
	protected String getDelimiter(final CommentRange previous, final CommentRange next) {
		// simply preserve range (~ word) breaks
		if (previous != null && !previous.hasAttribute(COMMENT_STARTS_WITH_RANGE_DELIMITER)) {
			return ""; //$NON-NLS-1$
		} else {
			return super.getDelimiter(previous, next);
		}
	}

	/**
	 * Should root tag parameter descriptions be indented after the tag?
	 *
	 * @return <code>true</code> iff the descriptions should be indented
	 *         after, <code>false</code> otherwise.
	 */
	protected final boolean isIndentDescriptions() {
		return this.fIndentDescriptions;
	}

	/**
	 * Should root tag parameter descriptions be indented?
	 *
	 * @return <code>true</code> iff the root tags should be indented,
	 *         <code>false</code> otherwise.
	 */
	protected final boolean isIndentRoots() {
		return this.fIndentRoots;
	}

	/**
	 * Marks the comment ranges confined by HTML ranges.
	 */
	protected void markHtmlRanges() {
		// Do nothing
	}

	/**
	 * Marks the comment range with its HTML tag attributes.
	 *
	 * @param range the comment range to mark
	 * @param token token associated with the comment range
	 */
	protected void markHtmlTag(final CommentRange range, final char[] token) {
		// Do nothing
	}

	/**
	 * Marks the comment range with its javadoc tag attributes.
	 *
	 * @param range the comment range to mark
	 * @param token token associated with the comment range
	 */
	protected void markJavadocTag(final CommentRange range, final char[] token) {
		range.markPrefixTag(COMMENT_ROOT_TAGS, COMMENT_TAG_PREFIX, token, COMMENT_ROOT);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#markRegion()
	 */
	protected void markRegion() {

		int count= 0;
		boolean paragraph= false;

		char[] token= null;
		CommentRange range= null;

		for (final ListIterator iterator= getRanges().listIterator(); iterator.hasNext();) {

			range= (CommentRange)iterator.next();
			count= range.getLength();

			if (count > 0) {

				token= getText(range.getOffset(), count).toLowerCase().toCharArray();

				markJavadocTag(range, token);
				if (!paragraph && (range.hasAttribute(COMMENT_ROOT) || range.hasAttribute(COMMENT_PARAMETER))) {
					range.setAttribute(COMMENT_PARAGRAPH);
					paragraph= true;
				}
				markHtmlTag(range, token);
			}
		}
		markHtmlRanges();
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#createLine()
	 * @since 3.1
	 */
	protected CommentLine createLine() {
		return new MultiCommentLine(this);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.formatter.comment;

/**
 * Single-line comment line in a comment region.
 *
 * @since 3.0
 */
public class SingleCommentLine extends CommentLine {

	/** Line prefix for single line comments */
	public static final String SINGLE_COMMENT_PREFIX= "// "; //$NON-NLS-1$

	/** NLS tag prefix */
	private static final String NLS_TAG_PREFIX= "//$NON-NLS-"; //$NON-NLS-1$

	/** Is the comment a NLS locale tag sequence? */
	private boolean fLocaleSequence= false;

	/**
	 * Creates a new single-line comment line.
	 *
	 * @param region comment region to create the line for
	 */
	protected SingleCommentLine(final CommentRegion region) {
		super(region);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#adapt(org.eclipse.jdt.internal.corext.text.comment.CommentLine)
	 */
	protected void adapt(final CommentLine previous) {
		// Do nothing
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#formatLowerBorder(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String, int)
	 */
	protected void formatLowerBorder(final CommentRange range, final String indentation, final int length) {

		final int offset= range.getOffset() + range.getLength();
		final CommentRegion parent= getParent();

		parent.logEdit(parent.getDelimiter(), offset, parent.getLength() - offset);
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#formatUpperBorder(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String, int)
	 */
	protected void formatUpperBorder(final CommentRange range, final String indentation, final int length) {

		final CommentRegion parent= getParent();

		parent.logEdit(getContentPrefix(), 0, range.getOffset());
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getContentPrefix()
	 */
	protected String getContentPrefix() {
		return SINGLE_COMMENT_PREFIX;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getEndingPrefix()
	 */
	protected String getEndingPrefix() {
		return SINGLE_COMMENT_PREFIX;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#getStartingPrefix()
	 */
	protected String getStartingPrefix() {
		return SINGLE_COMMENT_PREFIX;
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#scanLine(int)
	 */
	protected void scanLine(final int line) {

		final CommentRange range= getFirst();
		final String content= getParent().getText(range.getOffset(), range.getLength());
		final String prefix= getContentPrefix().trim();

		final int offset= content.indexOf(prefix);
		if (offset >= 0) {

			if (content.startsWith(NLS_TAG_PREFIX))
				this.fLocaleSequence= true;

			range.trimBegin(offset + prefix.length());
		}
	}

	/*
	 * @see org.eclipse.jdt.internal.corext.text.comment.CommentLine#tokenizeLine(int)
	 */
	protected void tokenizeLine(final int line) {

		if (!this.fLocaleSequence)
			super.tokenizeLine(line);
	}
}




		"	  return null;\n" +
		"  }\n" +
		"}\n";
	// TODO (frederic) line comment should be formatted when F_INCLUDE_COMMENTS
	// flag will work for all snippet kinds
	formatSource(source,
		"/**\n" +
		" * Need a javadoc comment before to get the exception.\n" +

		"	 * If there is an authority, it is:\n" +
		"	 * \n" +
		"	 * <pre>\n" +
		"	 * // class body snippet\n" + 
		"	 * public class X {\n" +
		"	 * }\n" +
		"	 * </pre>\n" +

}

/**
 * @bug 236406: [formatter] Formatting qualified invocations can be broken when the Line Wrapping policy forces element to be on a new line
 * @test Verify that wrapping policies forcing the first element to be on a new line are working again...
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=236406"
 */
public void testBug236406_CDB1() {
	String source = 
		"/**        Javadoc		comment    	    */void foo1() {System.out.println();}\n" +
		"//        Line		comment    	    \n" +
		"void foo2() {System.out.println();}\n" +
		"/*        Block		comment    	    */\n" +
		"void foo3() {\n" +
		"/*        statement Block		comment    	    */\n" +
		"System.out.println();}\n";
	formatSource(source,
		"/**        Javadoc		comment    	    */\n" + 
		"void foo1() {\n" + 
		"	System.out.println();\n" + 
		"}\n" + 
		"\n" + 
		"//        Line		comment    	    \n" + 
		"void foo2() {\n" + 
		"	System.out.println();\n" + 
		"}\n" + 
		"\n" + 
		"/*        Block		comment    	    */\n" +
		"void foo3() {\n" +
		"	/*        statement Block		comment    	    */\n" + 
		"	System.out.println();\n" + 
		"}",
		CodeFormatter.K_CLASS_BODY_DECLARATIONS
	);
}
public void testBug236406_CDB2() {
	String source = 
		"/**        Javadoc		comment    	    */void foo1() {System.out.println();}\n" +
		"//        Line		comment    	    \n" +
		"void foo2() {System.out.println();}\n" +
		"/*        Block		comment    	    */\n" +
		"void foo3() {\n" +
		"/*        statement Block		comment    	    */\n" +
		"System.out.println();}\n";
	formatSource(source,
		"/** Javadoc comment */\n" + 
		"void foo1() {\n" + 
		"	System.out.println();\n" + 
		"}\n" + 
		"\n" + 
		"// Line comment\n" + 
		"void foo2() {\n" + 
		"	System.out.println();\n" + 
		"}\n" + 
		"\n" + 
		"/* Block comment */\n" +
		"void foo3() {\n" + 
		"	/* statement Block comment */\n" + 
		"	System.out.println();\n" + 
		"}",
		CodeFormatter.K_CLASS_BODY_DECLARATIONS | CodeFormatter.F_INCLUDE_COMMENTS
	);
}
public void testBug236406_EX1() {
	String source = 
		"//        Line		comment    	    \n" +
		"i = \n" +
		"/**        Javadoc		comment    	    */\n" +
		"1     +     (/*      Block		comment*/++a)\n";
	formatSource(source,
		"//        Line		comment    	    \n" + 
		"i =\n" + 
		"/**        Javadoc		comment    	    */\n" + 
		"1 + (/*      Block		comment*/++a)",
		CodeFormatter.K_EXPRESSION
	);
}
public void testBug236406_EX2() {
	String source = 
		"//        Line		comment    	    \n" +
		"i = \n" +
		"/**        Javadoc		comment    	    */\n" +
		"1     +     (/*      Block		comment*/++a)\n";
	formatSource(source,
		"// Line comment\n" + 
		"i =\n" + 
		"/** Javadoc comment */\n" + 
		"1 + (/* Block comment */++a)",
		CodeFormatter.K_EXPRESSION | CodeFormatter.F_INCLUDE_COMMENTS
	);
}
public void testBug236406_ST1() {
	String source = 
		"/**        Javadoc		comment    	    */foo1();\n" +
		"//        Line		comment    	    \n" +
		"foo2();\n" +
		"/*        Block		comment    	    */\n" +
		"foo3(); {\n" +
		"/*        indented Block		comment    	    */\n" +
		"System.out.println();}\n";
	formatSource(source,
		"/**        Javadoc		comment    	    */\n" + 
		"foo1();\n" + 
		"//        Line		comment    	    \n" + 
		"foo2();\n" + 
		"/*        Block		comment    	    */\n" + 
		"foo3();\n" + 
		"{\n" + 
		"	/*        indented Block		comment    	    */\n" + 
		"	System.out.println();\n" + 
		"}",
		CodeFormatter.K_STATEMENTS
	);
}
public void testBug236406_ST2() {
	String source = 
		"/**        Javadoc		comment    	    */foo1();\n" +
		"//        Line		comment    	    \n" +
		"foo2();\n" +
		"/*        Block		comment    	    */\n" +
		"foo3(); {\n" +
		"/*        indented Block		comment    	    */\n" +
		"System.out.println();}\n";
	formatSource(source,
		"/** Javadoc comment */\n" + 
		"foo1();\n" + 
		"// Line comment\n" + 
		"foo2();\n" + 
		"/* Block comment */\n" + 
		"foo3();\n" + 
		"{\n" + 
		"	/* indented Block comment */\n" + 
		"	System.out.println();\n" + 
		"}",
		CodeFormatter.K_STATEMENTS | CodeFormatter.F_INCLUDE_COMMENTS
	);
}

/**
 * @bug 237051: [formatter] Formatter insert blank lines after javadoc if javadoc contains Commons Attributes @@ annotations
 * @test Ensure that Commons Attributes @@ annotations do not screw up the comment formatter
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=237051"

Lines 240-245 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterRegressionTests.java (+4 lines)
240	void formatSource(String source, String formattedOutput) {	240	void formatSource(String source, String formattedOutput) {
241	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, true /repeat formatting twice/);	241	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, true /repeat formatting twice/);
242	}	242	}
		243
		244	void formatSource(String source, String formattedOutput, int kind) {
		245	formatSource(source, formattedOutput, kind, 0, true /repeat formatting twice/);
		246	}
243		247
244	void formatSource(String source, String formattedOutput, boolean repeat) {	248	void formatSource(String source, String formattedOutput, boolean repeat) {
245	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, repeat);	249	formatSource(source, formattedOutput, CodeFormatter.K_COMPILATION_UNIT \| CodeFormatter.F_INCLUDE_COMMENTS, 0, repeat);

Lines 24-29 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/comment/CommentTestCase.java (+1 lines)
24	import org.eclipse.jdt.core.tests.model.SuiteOfTestCases;	24	import org.eclipse.jdt.core.tests.model.SuiteOfTestCases;
25		25
26	public abstract class CommentTestCase extends SuiteOfTestCases {	26	public abstract class CommentTestCase extends SuiteOfTestCases {
		27
27	public static Test buildTestSuite(Class evaluationTestClass) {	28	public static Test buildTestSuite(Class evaluationTestClass) {
28	return buildTestSuite(evaluationTestClass, null); //$NON-NLS-1$	29	return buildTestSuite(evaluationTestClass, null); //$NON-NLS-1$
29	}	30	}




import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.comment.JavaDocLine;
import org.eclipse.jdt.internal.formatter.comment.MultiCommentLine;
import org.eclipse.text.edits.TextEdit;

public class JavaDocTestCase extends MultiLineTestCase {

	static {
//		TESTS_NAMES = new String[] { "test109636_2" } ;
	}

	protected static final String INFIX= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;

	protected static final String POSTFIX= MultiCommentLine.MULTI_COMMENT_END_PREFIX;

	protected static final String PREFIX= JavaDocLine.JAVADOC_START_PREFIX;

	public static Test suite() {
		return buildTestSuite(JavaDocTestCase.class);
	}


		String expected = "/**" + DELIMITER +
				" * <pre>" + DELIMITER +
				" * " +  DELIMITER +
				" * </pre>" + DELIMITER +
				" * " +  DELIMITER +
				" * " + DELIMITER +

				" * </code>" + DELIMITER +
				" */";

		String expected = DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT
			? input // do not change as <code> is an immutable tag
			:	"/**" + DELIMITER +
				" * <code>" + DELIMITER +
				" * <pre>" + DELIMITER +
				" * setLeadingComment(&quot;/* traditional comment &#42;/&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;missing comment delimiters&quot;); // wrong" + DELIMITER +
				" * setLeadingComment(&quot;/* unterminated traditional comment &quot;); // wrong" + DELIMITER +
				" * setLeadingComment(&quot;/* broken\\n traditional comment &#42;/&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// end-of-line comment\\n&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// end-of-line comment without line terminator&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// broken\\n end-of-line comment\\n&quot;); // wrong" + DELIMITER +
				" * </pre>" + DELIMITER +
				" * </code>" + DELIMITER +
				" */";
		String result=testFormat(input, options);
		assertEquals(input, result);
	}

	public void test109636_2() {

	}

	public void test109636_4() {
		Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
			Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();

		String input =
				"/**" + DELIMITER +
				" * <pre>" + DELIMITER +
				" * setLeadingComment(\"/&#42; traditional comment &#42;/\");  // correct" + DELIMITER +
				" * setLeadingComment(\"missing comment delimiters\");  // wrong" + DELIMITER +
				" * setLeadingComment(\"/&#42; unterminated traditional comment \");  // wrong" + DELIMITER +
				" * setLeadingComment(\"/&#42; broken\\n traditional comment &#42;/\");  // correct" + DELIMITER +
				" * setLeadingComment(\"// end-of-line comment\\n\");  // correct" + DELIMITER +
				" * setLeadingComment(\"// end-of-line comment without line terminator\");  // correct" + DELIMITER +
				" * setLeadingComment(\"// broken\\n end-of-line comment\\n\");  // wrong" + DELIMITER +
				" * </pre>" + DELIMITER +
				" */";

		String expected =
				"/**" + DELIMITER +
				" * <pre>" + DELIMITER +
				" * setLeadingComment(&quot;/* traditional comment &#42;/&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;missing comment delimiters&quot;); // wrong" + DELIMITER +
				" * setLeadingComment(&quot;/* unterminated traditional comment &quot;); // wrong" + DELIMITER +
				" * setLeadingComment(&quot;/* broken\\n traditional comment &#42;/&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// end-of-line comment\\n&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// end-of-line comment without line terminator&quot;); // correct" + DELIMITER +
				" * setLeadingComment(&quot;// broken\\n end-of-line comment\\n&quot;); // wrong" + DELIMITER +
				" * </pre>" + DELIMITER +
				" */";
		String result=testFormat(input, options);
		assertEquals(expected, result);
		}
	}

	/**





import junit.framework.Test;

import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.comment.MultiCommentLine;

public class MultiLineTestCase extends CommentTestCase {
	static {
//		TESTS_NAMES = new String[] { "test170580" } ;
	}
	protected static final String INFIX= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;

	protected static final String POSTFIX= MultiCommentLine.MULTI_COMMENT_END_PREFIX;

	protected static final String INFIX= " * "; //$NON-NLS-1$
	protected static final String POSTFIX= " */"; //$NON-NLS-1$
	protected static final String PREFIX= "/* "; //$NON-NLS-1$

	public static Test suite() {
		return buildTestSuite(MultiLineTestCase.class);

				" * Member comment\n" +//$NON-NLS-1$
				" */";//$NON-NLS-1$
		String result= testFormat(input, 0, input.length(), CodeFormatter.K_MULTI_LINE_COMMENT , 2);
		String expectedOutput = "/**\n" +
			" * Member comment\n" +
			" */";
				" */"
			:	"/***********************************************************************\n" +
				"	 * Member comment\n" +
				"	 */";
		assertEquals("Different output", expectedOutput, result);
	}





import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.comment.SingleCommentLine;

public class SingleLineTestCase extends CommentTestCase {

	protected static final String PREFIX= "// "; //$NON-NLS-1$

	static {
//		TESTS_NAMES = new String[] { "test109581" } ;

		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "5"); //$NON-NLS-1$
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT, DefaultCodeFormatterConstants.FALSE);
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT, DefaultCodeFormatterConstants.FALSE);
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + "//"+ DELIMITER + PREFIX + "test";
			? PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + "//"+ DELIMITER + PREFIX + "test"
			: PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\ttest" + DELIMITER + "//" + DELIMITER + "//\t\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
	}


		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "5"); //$NON-NLS-1$
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT, DefaultCodeFormatterConstants.FALSE);
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT, DefaultCodeFormatterConstants.FALSE);
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + DELIMITER + PREFIX + "test";
			? PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + DELIMITER + PREFIX + "test"
			: PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\t\ttest" + DELIMITER + PREFIX + DELIMITER + "//\t\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
	}


		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "5"); //$NON-NLS-1$
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT, DefaultCodeFormatterConstants.FALSE);
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT, DefaultCodeFormatterConstants.FALSE);
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + "//"+ DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test";
			? PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + "//"+ DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test"
			: PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\ttest" + DELIMITER + "//" + DELIMITER + PREFIX + "test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
	}

	public void testCommentBegin1() {
		String expected = PREFIX + "test";
			? PREFIX + "test"
			: PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void testCommentBegin2() {
		String expected = PREFIX + "test";
			? PREFIX + "test"
			: PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat(PREFIX + "test")); //$NON-NLS-1$ //$NON-NLS-2$
	}


	}

	public void testCommentDelimiter1() {
		String expected = PREFIX + "test" + DELIMITER + DELIMITER;
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected += DELIMITER;
		assertEquals(expected, testFormat("//\t\ttest " + DELIMITER + DELIMITER)); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void testCommentDelimiter2() {
		String expected = PREFIX + "test" + DELIMITER + DELIMITER ;
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected += DELIMITER ;
		assertEquals(expected, testFormat(PREFIX + "test " + DELIMITER + DELIMITER + DELIMITER)); //$NON-NLS-1$ //$NON-NLS-2$
	}


	}

	public void testCommentSpace1() {
		String expected = PREFIX + "test test";
			? PREFIX + "test test"
			: PREFIX + "test test" + DELIMITER;
		assertEquals(expected, testFormat("//test\t \t test")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void testCommentSpace2() {
		String expected = PREFIX + "test test";
			? PREFIX + "test test"
			: PREFIX + "test test" + DELIMITER;
		assertEquals(expected, testFormat("//test test")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void testCommentSpace3() {
		String expected = PREFIX + "test test";
			? PREFIX + "test test"
			: PREFIX + "test test" + DELIMITER;
		assertEquals(expected, testFormat(PREFIX + "test \t    \t test")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void testCommentWrapping1() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "5"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test";
			? PREFIX + "test" + DELIMITER + PREFIX + "test"
			: PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public void testCommentWrapping2() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "1"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test";
			? PREFIX + "test" + DELIMITER + PREFIX + "test"
			: PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public void testCommentWrapping3() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "32"); //$NON-NLS-1$
		String expected = PREFIX + "test test";
			? PREFIX + "test test"
			: PREFIX + "test test" + DELIMITER;
		assertEquals(expected, testFormat("//test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}


	public void testHeaderComment1() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER, DefaultCodeFormatterConstants.FALSE);
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "12"); //$NON-NLS-1$
		String expected = PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER + PREFIX + "test test";
			? PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER + PREFIX + "test test"
			: PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER;
		assertEquals(expected, testFormat("//test\t\t\t\ttest" + DELIMITER + PREFIX + "test test test test")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
	}

	public void testHeaderComment2() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_HEADER, DefaultCodeFormatterConstants.FALSE);
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "24"); //$NON-NLS-1$
		String expected = "// test" + DELIMITER + PREFIX + "test test test test" + DELIMITER;
			? "// test" + DELIMITER + PREFIX + "test test test test" + DELIMITER
			: PREFIX + "test test test test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test\t\t\t" + DELIMITER + PREFIX + "test test test test" + DELIMITER)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
	}

	public void testIllegalLineLength1() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "1"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test";
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected = expected.substring(0, expected.length()-DELIMITER.length());
		assertEquals(expected, testFormat("//test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public void testIllegalLineLength2() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "-16"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test";
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected = expected.substring(0, expected.length()-DELIMITER.length());
		assertEquals(expected, testFormat(PREFIX + "\t\t test\ttest")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public void testMultipleComments1() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "5"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test";
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected = expected.substring(0, expected.length()-DELIMITER.length());
		assertEquals(expected, testFormat("//test test" + DELIMITER + PREFIX + "test test test test")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
	}

	public void testMultipleComments2() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "12"); //$NON-NLS-1$
		String expected = "// test test" + DELIMITER +
			"// test" + DELIMITER +
			"// " + DELIMITER +
			"// test test" + DELIMITER +
			"// test test";
				"// test test"
			: PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER + PREFIX + "test test" + DELIMITER + PREFIX + "test" + DELIMITER;
		assertEquals(expected, testFormat("//test test\ttest" + DELIMITER + PREFIX + DELIMITER + PREFIX + "test test test test")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
	}

	public void testMultipleComments3() {
		setUserOption(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "11"); //$NON-NLS-1$
		String expected = PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test" + DELIMITER + PREFIX + "test";
		if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) expected = expected.substring(0, expected.length()-DELIMITER.length());
		assertEquals(expected, testFormat("//   test\t\t\ttest\ttest" + DELIMITER + PREFIX + "test test test test")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$ //$NON-NLS-9$
	}


Return to bug 236406

Lines 118-124 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/CodeFormatterVisitor.java (-33 lines)
118	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;	118	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
119	import org.eclipse.jdt.internal.formatter.align.Alignment;	119	import org.eclipse.jdt.internal.formatter.align.Alignment;
120	import org.eclipse.jdt.internal.formatter.align.AlignmentException;	120	import org.eclipse.jdt.internal.formatter.align.AlignmentException;
121	import org.eclipse.jdt.internal.formatter.comment.CommentRegion;
122	import org.eclipse.jface.text.IRegion;	121	import org.eclipse.jface.text.IRegion;
123	import org.eclipse.text.edits.TextEdit;	122	import org.eclipse.text.edits.TextEdit;
124		123
Lines 887-924 Link Here
887	}	886	}
888		887
889	/**	888	/**
890	* @see org.eclipse.jdt.core.formatter.CodeFormatter#format(int, String, int, int, int, String)
891	*/
892	public TextEdit format(String string, CommentRegion region) {
893	// reset the scribe
894	this.scribe.reset();
895
896	if (region == null) {
897	return failedToFormat();
898	}
899
900	long startTime = 0;
901	if (DEBUG){
902	startTime = System.currentTimeMillis();
903	}
904
905	final char[] compilationUnitSource = string.toCharArray();
906
907	this.scribe.initializeScanner(compilationUnitSource);
908
909	TextEdit result = null;
910	try {
911	result = region.format(this.preferences.initial_indentation_level, true);
912	} catch(AbortFormatting e){
913	return failedToFormat();
914	}
915	if (DEBUG){
916	System.out.println("Formatting time: " + (System.currentTimeMillis() - startTime)); //$NON-NLS-1$
917	}
918	return result;
919	}
920
921	/**
922	* @param source the source of the comment to format	889	* @param source the source of the comment to format
923	*/	890	*/
924	public void formatComment(int kind, String source, int start, int end, int indentationLevel) {	891	public void formatComment(int kind, String source, int start, int end, int indentationLevel) {

Lines 2200-2207 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java (-3 / +137 lines)
2200	" return null;\n" +	2200	" return null;\n" +
2201	" }\n" +	2201	" }\n" +
2202	"}\n";	2202	"}\n";
2203	// TODO (frederic) line comment should be formatted when F_INCLUDE_COMMENTS
2204	// flag will work for all snippet kinds
2205	formatSource(source,	2203	formatSource(source,
2206	"/**\n" +	2204	"/**\n" +
2207	" * Need a javadoc comment before to get the exception.\n" +	2205	" * Need a javadoc comment before to get the exception.\n" +
Lines 2213-2219 Link Here
2213	" * If there is an authority, it is:\n" +	2211	" * If there is an authority, it is:\n" +
2214	" * \n" +	2212	" * \n" +
2215	" * <pre>\n" +	2213	" * <pre>\n" +
2216	" * //class body snippet\n" +	2214	" * // class body snippet\n" +
2217	" * public class X {\n" +	2215	" * public class X {\n" +
2218	" * }\n" +	2216	" * }\n" +
2219	" * </pre>\n" +	2217	" * </pre>\n" +
Lines 2265-2270 Link Here
2265	}	2263	}
2266		2264
2267	/**	2265	/**
		2266	* @bug 236406: [formatter] Formatting qualified invocations can be broken when the Line Wrapping policy forces element to be on a new line
		2267	* @test Verify that wrapping policies forcing the first element to be on a new line are working again...
		2268	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=236406"
		2269	*/
		2270	public void testBug236406_CDB1() {
		2271	String source =
		2272	"/** Javadoc comment */void foo1() {System.out.println();}\n" +
		2273	"// Line comment \n" +
		2274	"void foo2() {System.out.println();}\n" +
		2275	"/* Block comment */\n" +
		2276	"void foo3() {\n" +
		2277	"/* statement Block comment */\n" +
		2278	"System.out.println();}\n";
		2279	formatSource(source,
		2280	"/** Javadoc comment */\n" +
		2281	"void foo1() {\n" +
		2282	" System.out.println();\n" +
		2283	"}\n" +
		2284	"\n" +
		2285	"// Line comment \n" +
		2286	"void foo2() {\n" +
		2287	" System.out.println();\n" +
		2288	"}\n" +
		2289	"\n" +
		2290	"/* Block comment */\n" +
		2291	"void foo3() {\n" +
		2292	" /* statement Block comment */\n" +
		2293	" System.out.println();\n" +
		2294	"}",
		2295	CodeFormatter.K_CLASS_BODY_DECLARATIONS
		2296	);
		2297	}
		2298	public void testBug236406_CDB2() {
		2299	String source =
		2300	"/** Javadoc comment */void foo1() {System.out.println();}\n" +
		2301	"// Line comment \n" +
		2302	"void foo2() {System.out.println();}\n" +
		2303	"/* Block comment */\n" +
		2304	"void foo3() {\n" +
		2305	"/* statement Block comment */\n" +
		2306	"System.out.println();}\n";
		2307	formatSource(source,
		2308	"/** Javadoc comment */\n" +
		2309	"void foo1() {\n" +
		2310	" System.out.println();\n" +
		2311	"}\n" +
		2312	"\n" +
		2313	"// Line comment\n" +
		2314	"void foo2() {\n" +
		2315	" System.out.println();\n" +
		2316	"}\n" +
		2317	"\n" +
		2318	"/* Block comment */\n" +
		2319	"void foo3() {\n" +
		2320	" /* statement Block comment */\n" +
		2321	" System.out.println();\n" +
		2322	"}",
		2323	CodeFormatter.K_CLASS_BODY_DECLARATIONS \| CodeFormatter.F_INCLUDE_COMMENTS
		2324	);
		2325	}
		2326	public void testBug236406_EX1() {
		2327	String source =
		2328	"// Line comment \n" +
		2329	"i = \n" +
2330	"/** Javadoc comment */\n" +
2331	"1 + (/* Block comment*/++a)\n";
2332	formatSource(source,
2333	"// Line comment \n" +
2334	"i =\n" +
2335	"/** Javadoc comment */\n" +
2336	"1 + (/* Block comment*/++a)",
2337	CodeFormatter.K_EXPRESSION
2338	);
2339	}
2340	public void testBug236406_EX2() {
2341	String source =
2342	"// Line comment \n" +
2343	"i = \n" +
2344	"/** Javadoc comment */\n" +
2345	"1 + (/* Block comment*/++a)\n";
2346	formatSource(source,
2347	"// Line comment\n" +
2348	"i =\n" +
2349	"/** Javadoc comment */\n" +
2350	"1 + (/* Block comment */++a)",
2351	CodeFormatter.K_EXPRESSION \| CodeFormatter.F_INCLUDE_COMMENTS
2352	);
2353	}
2354	public void testBug236406_ST1() {
2355	String source =
2356	"/** Javadoc comment */foo1();\n" +
2357	"// Line comment \n" +
2358	"foo2();\n" +
2359	"/* Block comment */\n" +
2360	"foo3(); {\n" +
2361	"/* indented Block comment */\n" +
2362	"System.out.println();}\n";
2363	formatSource(source,
2364	"/** Javadoc comment */\n" +
2365	"foo1();\n" +
2366	"// Line comment \n" +
2367	"foo2();\n" +
2368	"/* Block comment */\n" +
2369	"foo3();\n" +
2370	"{\n" +
2371	" /* indented Block comment */\n" +
2372	" System.out.println();\n" +
2373	"}",
2374	CodeFormatter.K_STATEMENTS
2375	);
2376	}
2377	public void testBug236406_ST2() {
2378	String source =
2379	"/** Javadoc comment */foo1();\n" +
2380	"// Line comment \n" +
2381	"foo2();\n" +
2382	"/* Block comment */\n" +
2383	"foo3(); {\n" +
2384	"/* indented Block comment */\n" +
2385	"System.out.println();}\n";
2386	formatSource(source,
2387	"/** Javadoc comment */\n" +
2388	"foo1();\n" +
2389	"// Line comment\n" +
2390	"foo2();\n" +
2391	"/* Block comment */\n" +
2392	"foo3();\n" +
2393	"{\n" +
2394	" /* indented Block comment */\n" +
2395	" System.out.println();\n" +
2396	"}",
2397	CodeFormatter.K_STATEMENTS \| CodeFormatter.F_INCLUDE_COMMENTS
2398	);
2399	}
2400
2401	/**
2268	* @bug 237051: [formatter] Formatter insert blank lines after javadoc if javadoc contains Commons Attributes @@ annotations	2402	* @bug 237051: [formatter] Formatter insert blank lines after javadoc if javadoc contains Commons Attributes @@ annotations
2269	* @test Ensure that Commons Attributes @@ annotations do not screw up the comment formatter	2403	* @test Ensure that Commons Attributes @@ annotations do not screw up the comment formatter
2270	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=237051"	2404	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=237051"

Lines 19-41 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/comment/JavaDocTestCase.java (-57 / +31 lines)
19	import org.eclipse.jdt.core.formatter.CodeFormatter;	19	import org.eclipse.jdt.core.formatter.CodeFormatter;
20	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;	20	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
21		21
22	import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
23	import org.eclipse.jdt.internal.formatter.comment.JavaDocLine;
24	import org.eclipse.jdt.internal.formatter.comment.MultiCommentLine;
25	import org.eclipse.text.edits.TextEdit;	22	import org.eclipse.text.edits.TextEdit;
26		23
27	public class JavaDocTestCase extends CommentTestCase {	24	public class JavaDocTestCase extends MultiLineTestCase {
28		25
29	static {	26	static {
30	// TESTS_NAMES = new String[] { "test109636_2" } ;	27	// TESTS_NAMES = new String[] { "test109636_2" } ;
31	}	28	}
32		29
33	protected static final String INFIX= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;
34
35	protected static final String POSTFIX= MultiCommentLine.MULTI_COMMENT_END_PREFIX;
36
37	protected static final String PREFIX= JavaDocLine.JAVADOC_START_PREFIX;
38
39	public static Test suite() {	30	public static Test suite() {
40	return buildTestSuite(JavaDocTestCase.class);	31	return buildTestSuite(JavaDocTestCase.class);
41	}	32	}
Lines 698-704 Link Here
698		689
699	String expected = "/**" + DELIMITER +	690	String expected = "/**" + DELIMITER +
700	" * <pre>" + DELIMITER +	691	" * <pre>" + DELIMITER +
701	(DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT ? " * " + DELIMITER : "") +	692	" * " + DELIMITER +
702	" * </pre>" + DELIMITER +	693	" * </pre>" + DELIMITER +
703	" * " + DELIMITER +	694	" * " + DELIMITER +
704	" * " + DELIMITER +	695	" * " + DELIMITER +
Lines 876-898 Link Here
876	" * </code>" + DELIMITER +	867	" * </code>" + DELIMITER +
877	" */";	868	" */";
878		869
879	String expected = DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT
880	? input // do not change as <code> is an immutable tag
881	: "/**" + DELIMITER +
882	" * <code>" + DELIMITER +
883	" * <pre>" + DELIMITER +
884	" * setLeadingComment("/* traditional comment */"); // correct" + DELIMITER +
885	" * setLeadingComment("missing comment delimiters"); // wrong" + DELIMITER +
886	" * setLeadingComment("/* unterminated traditional comment "); // wrong" + DELIMITER +
887	" * setLeadingComment("/* broken\\n traditional comment */"); // correct" + DELIMITER +
888	" * setLeadingComment("// end-of-line comment\\n"); // correct" + DELIMITER +
889	" * setLeadingComment("// end-of-line comment without line terminator"); // correct" + DELIMITER +
890	" * setLeadingComment("// broken\\n end-of-line comment\\n"); // wrong" + DELIMITER +
891	" * </pre>" + DELIMITER +
892	" * </code>" + DELIMITER +
893	" */";
894	String result=testFormat(input, options);	870	String result=testFormat(input, options);
895	assertEquals(expected, result);	871	assertEquals(input, result);
896	}	872	}
897		873
898	public void test109636_2() {	874	public void test109636_2() {
Lines 940-976 Link Here
940	}	916	}
941		917
942	public void test109636_4() {	918	public void test109636_4() {
943	if (DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT) {	919	Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
944	Map options = DefaultCodeFormatterConstants.getEclipseDefaultSettings();
945		920
946	String input =	921	String input =
947	"/**" + DELIMITER +	922	"/**" + DELIMITER +
948	" * <pre>" + DELIMITER +	923	" * <pre>" + DELIMITER +
949	" * setLeadingComment(\"/* traditional comment */\"); // correct" + DELIMITER +	924	" * setLeadingComment(\"/* traditional comment */\"); // correct" + DELIMITER +
950	" * setLeadingComment(\"missing comment delimiters\"); // wrong" + DELIMITER +	925	" * setLeadingComment(\"missing comment delimiters\"); // wrong" + DELIMITER +
951	" * setLeadingComment(\"/* unterminated traditional comment \"); // wrong" + DELIMITER +	926	" * setLeadingComment(\"/* unterminated traditional comment \"); // wrong" + DELIMITER +
952	" * setLeadingComment(\"/* broken\\n traditional comment */\"); // correct" + DELIMITER +	927	" * setLeadingComment(\"/* broken\\n traditional comment */\"); // correct" + DELIMITER +
953	" * setLeadingComment(\"// end-of-line comment\\n\"); // correct" + DELIMITER +	928	" * setLeadingComment(\"// end-of-line comment\\n\"); // correct" + DELIMITER +
954	" * setLeadingComment(\"// end-of-line comment without line terminator\"); // correct" + DELIMITER +	929	" * setLeadingComment(\"// end-of-line comment without line terminator\"); // correct" + DELIMITER +
955	" * setLeadingComment(\"// broken\\n end-of-line comment\\n\"); // wrong" + DELIMITER +	930	" * setLeadingComment(\"// broken\\n end-of-line comment\\n\"); // wrong" + DELIMITER +
956	" * </pre>" + DELIMITER +	931	" * </pre>" + DELIMITER +
957	" */";	932	" */";
958		933
959	String expected =	934	String expected =
960	"/**" + DELIMITER +	935	"/**" + DELIMITER +
961	" * <pre>" + DELIMITER +	936	" * <pre>" + DELIMITER +
962	" * setLeadingComment("/* traditional comment */"); // correct" + DELIMITER +	937	" * setLeadingComment("/* traditional comment */"); // correct" + DELIMITER +
963	" * setLeadingComment("missing comment delimiters"); // wrong" + DELIMITER +	938	" * setLeadingComment("missing comment delimiters"); // wrong" + DELIMITER +
964	" * setLeadingComment("/* unterminated traditional comment "); // wrong" + DELIMITER +	939	" * setLeadingComment("/* unterminated traditional comment "); // wrong" + DELIMITER +
965	" * setLeadingComment("/* broken\\n traditional comment */"); // correct" + DELIMITER +	940	" * setLeadingComment("/* broken\\n traditional comment */"); // correct" + DELIMITER +
966	" * setLeadingComment("// end-of-line comment\\n"); // correct" + DELIMITER +	941	" * setLeadingComment("// end-of-line comment\\n"); // correct" + DELIMITER +
967	" * setLeadingComment("// end-of-line comment without line terminator"); // correct" + DELIMITER +	942	" * setLeadingComment("// end-of-line comment without line terminator"); // correct" + DELIMITER +
968	" * setLeadingComment("// broken\\n end-of-line comment\\n"); // wrong" + DELIMITER +	943	" * setLeadingComment("// broken\\n end-of-line comment\\n"); // wrong" + DELIMITER +
969	" * </pre>" + DELIMITER +	944	" * </pre>" + DELIMITER +
970	" */";	945	" */";
971	String result=testFormat(input, options);	946	String result=testFormat(input, options);
972	assertEquals(expected, result);	947	assertEquals(expected, result);
973	}
974	}	948	}
975		949
976	/**	950	/**

Lines 24-48 Link Here

(-)formatter/org/eclipse/jdt/core/formatter/CodeFormatter.java (-8 / +42 lines)
24		24
25	/**	25	/**
26	* Unknown kind	26	* Unknown kind
27	*	27	*<p>
28	* Note that since 3.4, the {@link #F_INCLUDE_COMMENTS} flag can be added	28	* <b>Since 3.6</b>, if the corresponding comment options are set to
29	* to this constant in order to get the comments formatted if a compilation unit	29	* <code>true</code> then it is also possible to format the comments on the fly
30	* is processed.	30	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
		31	* </p>
31	*/	32	*/
32	public static final int K_UNKNOWN = 0x00;	33	public static final int K_UNKNOWN = 0x00;
33		34
34	/**	35	/**
35	* Kind used to format an expression	36	* Kind used to format an expression
		37	* <p>
		38	* Note that using this constant, the comments encountered while formatting
		39	* the expression may be shifted to match the correct indentation but are not
		40	* formatted.
		41	* </p><p>
		42	* <b>Since 3.6</b>, if the corresponding comment options are set to
		43	* <code>true</code> then it is also possible to format the comments on the fly
		44	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
		45	* </p>
36	*/	46	*/
37	public static final int K_EXPRESSION = 0x01;	47	public static final int K_EXPRESSION = 0x01;
38		48
39	/**	49	/**
40	* Kind used to format a set of statements	50	* Kind used to format a set of statements
		51	* <p>
		52	* Note that using this constant, the comments encountered while formatting
		53	* the statements may be shifted to match the correct indentation but are not
		54	* formatted.
		55	* </p><p>
		56	* <b>Since 3.6</b>, if the corresponding comment options are set to
		57	* <code>true</code> then it is also possible to format the comments on the fly
		58	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
		59	* </p>
41	*/	60	*/
42	public static final int K_STATEMENTS = 0x02;	61	public static final int K_STATEMENTS = 0x02;
43		62
44	/**	63	/**
45	* Kind used to format a set of class body declarations	64	* Kind used to format a set of class body declarations
		65	* <p>
		66	* Note that using this constant, the comments encountered while formatting
		67	* the body declarations may be shifted to match the correct indentation but
		68	* are not formatted.
		69	* </p><p>
		70	* <b>Since 3.6</b>, if the corresponding comment options are set to
		71	* <code>true</code> then it is also possible to format the comments on the fly
		72	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
		73	* </p>
46	*/	74	*/
47	public static final int K_CLASS_BODY_DECLARATIONS = 0x04;	75	public static final int K_CLASS_BODY_DECLARATIONS = 0x04;
48		76
Lines 50-60 Link Here
50	* Kind used to format a compilation unit	78	* Kind used to format a compilation unit
51	* <p>	79	* <p>
52	* Note that using this constant, the comments are only indented while	80	* Note that using this constant, the comments are only indented while
53	* processing the compilation unit.	81	* formatting the compilation unit.
54	* </p><p>	82	* </p><p>
55	* <b>Since 3.4</b>, if the corresponding comment option is set to	83	* <b>Since 3.4</b>, if the corresponding comment option is set to
56	* <code>true</code> then it is also possible to format the comments on the fly	84	* <code>true</code> then it is also possible to format the comments on the fly
57	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.	85	* by adding the {@link #F_INCLUDE_COMMENTS} flag to this kind of format.
		86	* </p>
58	*/	87	*/
59	public static final int K_COMPILATION_UNIT = 0x08;	88	public static final int K_COMPILATION_UNIT = 0x08;
60		89
Lines 81-89 Link Here
81	* Flag used to include the comments during the formatting of the code	110	* Flag used to include the comments during the formatting of the code
82	* snippet.	111	* snippet.
83	* <p>	112	* <p>
84	* This flag can only be combined with {@link #K_COMPILATION_UNIT} and	113	* This flag can be combined with the following kinds:
85	* {@link #K_UNKNOWN} kinds for now but might be extended to other ones	114	* <ul>
86	* in future versions.	115	* <li>{@link #K_COMPILATION_UNIT}</li>
		116	* <li>{@link #K_UNKNOWN}</li>
		117	* <li>{@link #K_CLASS_BODY_DECLARATIONS} <i>(since 3.6)</i></li>
		118	* <li>{@link #K_EXPRESSION} <i>(since 3.6)</i></li>
		119	* <li>{@link #K_STATEMENTS} <i>(since 3.6)</i></li>
		120	* </ul>
87	* </p><p>	121	* </p><p>
88	* Note also that it has an effect only when one or several format comments	122	* Note also that it has an effect only when one or several format comments
89	* options for	123	* options for

Lines 28-42 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java (-122 / +22 lines)
28	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;	28	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
29	import org.eclipse.jdt.internal.compiler.util.Util;	29	import org.eclipse.jdt.internal.compiler.util.Util;
30	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;	30	import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
31	import org.eclipse.jdt.internal.formatter.comment.CommentRegion;
32	import org.eclipse.jdt.internal.formatter.comment.JavaDocRegion;
33	import org.eclipse.jdt.internal.formatter.comment.MultiCommentRegion;
34	import org.eclipse.jface.text.Document;
35	import org.eclipse.jface.text.IDocument;
36	import org.eclipse.jface.text.IRegion;	31	import org.eclipse.jface.text.IRegion;
37	import org.eclipse.jface.text.Position;
38	import org.eclipse.jface.text.Region;	32	import org.eclipse.jface.text.Region;
39	import org.eclipse.text.edits.MultiTextEdit;
40	import org.eclipse.text.edits.TextEdit;	33	import org.eclipse.text.edits.TextEdit;
41		34
42	public class DefaultCodeFormatter extends CodeFormatter {	35	public class DefaultCodeFormatter extends CodeFormatter {
Lines 56-95 Link Here
56	\| K_MULTI_LINE_COMMENT	49	\| K_MULTI_LINE_COMMENT
57	\| K_JAVA_DOC;	50	\| K_JAVA_DOC;
58		51
59	/*
60	* Temporary internal statics to enable new comments formatter
61	* see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
62	* see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=227043
63	* TODO (frederic) remove in 3.5
64	*/
65	private final static String NEW_COMMENTS_FORMAT = System.getProperty("org.eclipse.jdt.core.formatter.comments.new"); //$NON-NLS-1$
66	public static boolean ENABLE_NEW_COMMENTS_FORMAT = !JavaCore.DISABLED.equals(NEW_COMMENTS_FORMAT);
67
68	// Scanner use to probe the kind of the source given to the formatter	52	// Scanner use to probe the kind of the source given to the formatter
69	private static Scanner PROBING_SCANNER;	53	private static Scanner PROBING_SCANNER;
70		54
71	/**
72	* Creates a comment region for a specific document partition type.
73	*
74	* @param kind the comment snippet kind
75	* @param document the document which contains the comment region
76	* @param range range of the comment region in the document
77	* @return a new comment region for the comment region range in the
78	* document
79	* @since 3.1
80	*/
81	public static CommentRegion createRegion(int kind, IDocument document, Position range, CodeFormatterVisitor formatter) {
82	switch (kind & K_MASK) {
83	case K_SINGLE_LINE_COMMENT:
84	return new CommentRegion(document, range, formatter);
85	case K_MULTI_LINE_COMMENT:
86	return new MultiCommentRegion(document, range, formatter);
87	case K_JAVA_DOC:
88	return new JavaDocRegion(document, range, formatter);
89	}
90	return null;
91	}
92
93	private CodeSnippetParsingUtil codeSnippetParsingUtil;	55	private CodeSnippetParsingUtil codeSnippetParsingUtil;
94	private Map defaultCompilerOptions;	56	private Map defaultCompilerOptions;
95		57
Lines 174-190 Link Here
174	case K_JAVA_DOC :	136	case K_JAVA_DOC :
175	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780	137	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
176	// use the integrated comment formatter to format comment	138	// use the integrated comment formatter to format comment
177	if (ENABLE_NEW_COMMENTS_FORMAT) {	139	return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
178	return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
179	}
180	// $FALL-THROUGH$ - fall through next case when old comment formatter is activated	140	// $FALL-THROUGH$ - fall through next case when old comment formatter is activated
181	case K_MULTI_LINE_COMMENT :	141	case K_MULTI_LINE_COMMENT :
182	case K_SINGLE_LINE_COMMENT :	142	case K_SINGLE_LINE_COMMENT :
183	if (ENABLE_NEW_COMMENTS_FORMAT) {	143	return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
184	return formatComment(kind & K_MASK, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)});
185	}
186	this.codeSnippetParsingUtil = new CodeSnippetParsingUtil();
187	return formatComment(kind, source, indentationLevel, lineSeparator, new IRegion[] {new Region(offset, length)}, false);
188	}	144	}
189		145
190	return format(kind, source, new IRegion[] {new Region(offset, length)}, indentationLevel, lineSeparator);	146	return format(kind, source, new IRegion[] {new Region(offset, length)}, indentationLevel, lineSeparator);
Lines 199-216 Link Here
199	}	155	}
200		156
201	this.codeSnippetParsingUtil = new CodeSnippetParsingUtil();	157	this.codeSnippetParsingUtil = new CodeSnippetParsingUtil();
		158	boolean includeComments = (kind & F_INCLUDE_COMMENTS) != 0;
202	switch(kind & K_MASK) {	159	switch(kind & K_MASK) {
203	case K_CLASS_BODY_DECLARATIONS :	160	case K_CLASS_BODY_DECLARATIONS :
204	return formatClassBodyDeclarations(source, indentationLevel, lineSeparator, regions);	161	return formatClassBodyDeclarations(source, indentationLevel, lineSeparator, regions, includeComments);
205	case K_COMPILATION_UNIT :	162	case K_COMPILATION_UNIT :
206	boolean includeComments = (kind & F_INCLUDE_COMMENTS) != 0; // \|\| FORCE_NEW_COMMENTS_FORMAT;
207	return formatCompilationUnit(source, indentationLevel, lineSeparator, regions, includeComments);	163	return formatCompilationUnit(source, indentationLevel, lineSeparator, regions, includeComments);
208	case K_EXPRESSION :	164	case K_EXPRESSION :
209	return formatExpression(source, indentationLevel, lineSeparator, regions);	165	return formatExpression(source, indentationLevel, lineSeparator, regions, includeComments);
210	case K_STATEMENTS :	166	case K_STATEMENTS :
211	return formatStatements(source, indentationLevel, lineSeparator, regions);	167	return formatStatements(source, indentationLevel, lineSeparator, regions, includeComments);
212	case K_UNKNOWN :	168	case K_UNKNOWN :
213	includeComments = (kind & F_INCLUDE_COMMENTS) != 0; // \|\| FORCE_NEW_COMMENTS_FORMAT;
214	return probeFormatting(source, indentationLevel, lineSeparator, regions, includeComments);	169	return probeFormatting(source, indentationLevel, lineSeparator, regions, includeComments);
215	case K_JAVA_DOC :	170	case K_JAVA_DOC :
216	case K_MULTI_LINE_COMMENT :	171	case K_MULTI_LINE_COMMENT :
Lines 221-234 Link Here
221	return null;	176	return null;
222	}	177	}
223		178
224	private TextEdit formatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, IRegion[] regions) {	179	private TextEdit formatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
225	ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);	180	ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);
226		181
227	if (bodyDeclarations == null) {	182	if (bodyDeclarations == null) {
228	// a problem occurred while parsing the source	183	// a problem occurred while parsing the source
229	return null;	184	return null;
230	}	185	}
231	return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions);	186	return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions, includeComments);
232	}	187	}
233		188
234	/*	189	/*
Lines 271-325 Link Here
271	return null;	226	return null;
272	}	227	}
273		228
274	/**
275	* Returns the resulting text edit after formatting the given comment.
276	*
277	* @param kind the given kind
278	* @param source the given source
279	* @param indentationLevel the given indentation level
280	* @param lineSeparator the given line separator
281	* @param regions the given regions
282	* @param includeComments TODO
283	* @return the resulting text edit
284	*/
285	private TextEdit formatComment(int kind, String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
286	Object oldOption = oldCommentFormatOption();
287	boolean isFormattingComments = false;
288	if (oldOption == null) {
289	switch (kind & K_MASK) {
290	case K_SINGLE_LINE_COMMENT:
291	isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_LINE_COMMENT));
292	break;
293	case K_MULTI_LINE_COMMENT:
294	isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT));
295	break;
296	case K_JAVA_DOC:
297	isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT));
298	}
299	} else {
300	isFormattingComments = DefaultCodeFormatterConstants.TRUE.equals(oldOption);
301	}
302	if (isFormattingComments) {
303	if (lineSeparator != null) {
304	this.preferences.line_separator = lineSeparator;
305	} else {
306	this.preferences.line_separator = Util.LINE_SEPARATOR;
307	}
308	this.preferences.initial_indentation_level = indentationLevel;
309	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, null, includeComments);
310
311	IRegion coveredRegion = getCoveredRegion(regions);
312	int offset = coveredRegion.getOffset();
313	int length = coveredRegion.getLength();
314
315	final CommentRegion region = createRegion(kind, new Document(source), new Position(offset, length), this.newCodeFormatter);
316	if (region != null) {
317	return this.newCodeFormatter.format(source, region);
318	}
319	}
320	return new MultiTextEdit();
321	}
322
323	private TextEdit formatCompilationUnit(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {	229	private TextEdit formatCompilationUnit(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
324	CompilationUnitDeclaration compilationUnitDeclaration = this.codeSnippetParsingUtil.parseCompilationUnit(source.toCharArray(), getDefaultCompilerOptions(), true);	230	CompilationUnitDeclaration compilationUnitDeclaration = this.codeSnippetParsingUtil.parseCompilationUnit(source.toCharArray(), getDefaultCompilerOptions(), true);
325		231
Lines 335-358 Link Here
335	return this.newCodeFormatter.format(source, compilationUnitDeclaration);	241	return this.newCodeFormatter.format(source, compilationUnitDeclaration);
336	}	242	}
337		243
338	private TextEdit formatExpression(String source, int indentationLevel, String lineSeparator, IRegion[] regions) {	244	private TextEdit formatExpression(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
339	Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);	245	Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);
340		246
341	if (expression == null) {	247	if (expression == null) {
342	// a problem occurred while parsing the source	248	// a problem occurred while parsing the source
343	return null;	249	return null;
344	}	250	}
345	return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions);	251	return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions, includeComments);
346	}	252	}
347		253
348	private TextEdit formatStatements(String source, int indentationLevel, String lineSeparator, IRegion[] regions) {	254	private TextEdit formatStatements(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
349	ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);	255	ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);
350		256
351	if (constructorDeclaration.statements == null) {	257	if (constructorDeclaration.statements == null) {
352	// a problem occured while parsing the source	258	// a problem occured while parsing the source
353	return null;	259	return null;
354	}	260	}
355	return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions);	261	return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions, includeComments);
356	}	262	}
357		263
358	private IRegion getCoveredRegion(IRegion[] regions) {	264	private IRegion getCoveredRegion(IRegion[] regions) {
Lines 443-449 Link Here
443	return this.defaultCompilerOptions;	349	return this.defaultCompilerOptions;
444	}	350	}
445		351
446	private TextEdit internalFormatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, ASTNode[] bodyDeclarations, IRegion[] regions) {	352	private TextEdit internalFormatClassBodyDeclarations(String source, int indentationLevel, String lineSeparator, ASTNode[] bodyDeclarations, IRegion[] regions, boolean includeComments) {
447	if (lineSeparator != null) {	353	if (lineSeparator != null) {
448	this.preferences.line_separator = lineSeparator;	354	this.preferences.line_separator = lineSeparator;
449	} else {	355	} else {
Lines 451-461 Link Here
451	}	357	}
452	this.preferences.initial_indentation_level = indentationLevel;	358	this.preferences.initial_indentation_level = indentationLevel;
453		359
454	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, false);	360	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);
455	return this.newCodeFormatter.format(source, bodyDeclarations);	361	return this.newCodeFormatter.format(source, bodyDeclarations);
456	}	362	}
457		363
458	private TextEdit internalFormatExpression(String source, int indentationLevel, String lineSeparator, Expression expression, IRegion[] regions) {	364	private TextEdit internalFormatExpression(String source, int indentationLevel, String lineSeparator, Expression expression, IRegion[] regions, boolean includeComments) {
459	if (lineSeparator != null) {	365	if (lineSeparator != null) {
460	this.preferences.line_separator = lineSeparator;	366	this.preferences.line_separator = lineSeparator;
461	} else {	367	} else {
Lines 463-475 Link Here
463	}	369	}
464	this.preferences.initial_indentation_level = indentationLevel;	370	this.preferences.initial_indentation_level = indentationLevel;
465		371
466	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, false);	372	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);
467		373
468	TextEdit textEdit = this.newCodeFormatter.format(source, expression);	374	TextEdit textEdit = this.newCodeFormatter.format(source, expression);
469	return textEdit;	375	return textEdit;
470	}	376	}
471		377
472	private TextEdit internalFormatStatements(String source, int indentationLevel, String lineSeparator, ConstructorDeclaration constructorDeclaration, IRegion[] regions) {	378	private TextEdit internalFormatStatements(String source, int indentationLevel, String lineSeparator, ConstructorDeclaration constructorDeclaration, IRegion[] regions, boolean includeComments) {
473	if (lineSeparator != null) {	379	if (lineSeparator != null) {
474	this.preferences.line_separator = lineSeparator;	380	this.preferences.line_separator = lineSeparator;
475	} else {	381	} else {
Lines 477-483 Link Here
477	}	383	}
478	this.preferences.initial_indentation_level = indentationLevel;	384	this.preferences.initial_indentation_level = indentationLevel;
479		385
480	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, false);	386	this.newCodeFormatter = new CodeFormatterVisitor(this.preferences, this.options, regions, this.codeSnippetParsingUtil, includeComments);
481		387
482	return this.newCodeFormatter.format(source, constructorDeclaration);	388	return this.newCodeFormatter.format(source, constructorDeclaration);
483	}	389	}
Lines 523-535 Link Here
523	break;	429	break;
524	}	430	}
525	if (kind != -1) {	431	if (kind != -1) {
526	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=227043	432	return formatComment(kind, source, indentationLevel, lineSeparator, regions);
527	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102780
528	// use the integrated comment formatter to format comment
529	if (ENABLE_NEW_COMMENTS_FORMAT /\|\| FORCE_NEW_COMMENTS_FORMAT/) {
530	return formatComment(kind, source, indentationLevel, lineSeparator, regions);
531	}
532	return formatComment(kind, source, indentationLevel, lineSeparator, regions, includeComments);
533	}	433	}
534	} catch (InvalidInputException e) {	434	} catch (InvalidInputException e) {
535	// ignore	435	// ignore
Lines 539-557 Link Here
539	// probe for expression	439	// probe for expression
540	Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);	440	Expression expression = this.codeSnippetParsingUtil.parseExpression(source.toCharArray(), getDefaultCompilerOptions(), true);
541	if (expression != null) {	441	if (expression != null) {
542	return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions);	442	return internalFormatExpression(source, indentationLevel, lineSeparator, expression, regions, includeComments);
543	}	443	}
544		444
545	// probe for body declarations (fields, methods, constructors)	445	// probe for body declarations (fields, methods, constructors)
546	ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);	446	ASTNode[] bodyDeclarations = this.codeSnippetParsingUtil.parseClassBodyDeclarations(source.toCharArray(), getDefaultCompilerOptions(), true);
547	if (bodyDeclarations != null) {	447	if (bodyDeclarations != null) {
548	return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions);	448	return internalFormatClassBodyDeclarations(source, indentationLevel, lineSeparator, bodyDeclarations, regions, includeComments);
549	}	449	}
550		450
551	// probe for statements	451	// probe for statements
552	ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);	452	ConstructorDeclaration constructorDeclaration = this.codeSnippetParsingUtil.parseStatements(source.toCharArray(), getDefaultCompilerOptions(), true, false);
553	if (constructorDeclaration.statements != null) {	453	if (constructorDeclaration.statements != null) {
554	return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions);	454	return internalFormatStatements(source, indentationLevel, lineSeparator, constructorDeclaration, regions, includeComments);
555	}	455	}
556		456
557	// this has to be a compilation unit	457	// this has to be a compilation unit

Removed Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/comment/CommentLine.java (-315 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.jdt.internal.formatter.comment;
13
14	import java.util.LinkedList;
15
16	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
17
18	/**
19	* General comment line in a comment region.
20	*
21	* @since 3.0
22	*/
23	public abstract class CommentLine implements IBorderAttributes {
24
25	/** Prefix of non-formattable comment lines */
26	protected static final String NON_FORMAT_START_PREFIX= "/*-"; //$NON-NLS-1$
27
28	/** The attributes of this line */
29	private int fAttributes= 0;
30
31	/** The parent region of this line */
32	private final CommentRegion fParent;
33
34	/** The comment ranges in this line */
35	private final LinkedList fRanges= new LinkedList();
36
37	/**
38	* Creates a new comment line.
39	*
40	* @param parent comment region to create the comment line for
41	*/
42	protected CommentLine(final CommentRegion parent) {
43	this.fParent= parent;
44	}
45
46	/**
47	* Adapts the line attributes from the previous line in the comment
48	* region.
49	*
50	* @param previous the previous comment line in the comment region
51	*/
52	protected abstract void adapt(final CommentLine previous);
53
54	/**
55	* Appends the specified comment range to this comment line.
56	*
57	* @param range comment range to append to this line
58	*/
59	protected void append(final CommentRange range) {
60	this.fRanges.add(range);
61	}
62
63	/**
64	* Formats this comment line as content line.
65	*
66	* @param predecessor the predecessor comment line in the comment region
67	* @param last the most recently processed comment range
68	* @param indentation the indentation of the comment region
69	* @param line the index of this comment line in the comment region
70	* @return the first comment range in this comment line
71	*/
72	protected CommentRange formatLine(final CommentLine predecessor, final CommentRange last, final String indentation, final int line) {
73
74	int offset= 0;
75	int length= 0;
76
77	CommentRange next= last;
78	CommentRange previous= null;
79
80	final int stop= this.fRanges.size() - 1;
81	final int end= this.fParent.getSize() - 1;
82
83	for (int index= stop; index >= 0; index--) {
84
85	previous= next;
86	next= (CommentRange)this.fRanges.get(index);
87
88	if (this.fParent.canFormat(previous, next)) {
89
90	offset= next.getOffset() + next.getLength();
91	length= previous.getOffset() - offset;
92
93	if (index == stop && line != end)
94	this.fParent.logEdit(this.fParent.getDelimiter(predecessor, this, previous, next, indentation), offset, length);
95	else
96	this.fParent.logEdit(this.fParent.getDelimiter(previous, next), offset, length);
97	}
98	}
99	return next;
100	}
101
102	/**
103	* Formats this comment line as end line having a lower border
104	* consisting of content line prefixes.
105	*
106	* @param range last comment range of the last comment line in the
107	* comment region
108	* @param indentation the indentation of the comment region
109	* @param length the maximal length of text in this comment region
110	* measured in average character widths
111	*/
112	protected void formatLowerBorder(final CommentRange range, final String indentation, final int length) {
113
114	final int offset= range.getOffset() + range.getLength();
115
116	final StringBuffer buffer= new StringBuffer(length);
117	final String end= getEndingPrefix();
118	final String delimiter= this.fParent.getDelimiter();
119
120	if (this.fParent.isSingleLine() && this.fParent.getSize() == 1)
121	buffer.append(end);
122	else {
123
124	final String filler= getContentPrefix().trim();
125
126	buffer.append(delimiter);
127	buffer.append(indentation);
128
129	if (this.fParent.hasBorder(BORDER_LOWER)) {
130
131	buffer.append(' ');
132	for (int character= 0; character < length; character++)
133	buffer.append(filler);
134
135	buffer.append(end.trim());
136
137	} else
138	buffer.append(end);
139	}
140	this.fParent.logEdit(buffer.toString(), offset, this.fParent.getLength() - offset);
141	}
142
143	/**
144	* Formats this comment line as start line having an upper border
145	* consisting of content line prefixes.
146	*
147	* @param range the first comment range in the comment region
148	* @param indentation the indentation of the comment region
149	* @param length the maximal length of text in this comment region
150	* measured in average character widths
151	*/
152	protected void formatUpperBorder(final CommentRange range, final String indentation, final int length) {
153
154	final StringBuffer buffer= new StringBuffer(length);
155	final String start= getStartingPrefix();
156	final String content= getContentPrefix();
157
158	if (this.fParent.isSingleLine() && this.fParent.getSize() == 1)
159	buffer.append(start);
160	else {
161
162	final String trimmed= start.trim();
163	final String filler= content.trim();
164
165	buffer.append(trimmed);
166
167	if (this.fParent.hasBorder(BORDER_UPPER)) {
168
169	for (int character= 0; character < length - trimmed.length() + start.length(); character++)
170	buffer.append(filler);
171	}
172
173	buffer.append(this.fParent.getDelimiter());
174	buffer.append(indentation);
175	buffer.append(content);
176	}
177	this.fParent.logEdit(buffer.toString(), 0, range.getOffset());
178	}
179
180	/**
181	* Returns the line prefix of content lines.
182	*
183	* @return line prefix of content lines
184	*/
185	protected abstract String getContentPrefix();
186
187	/**
188	* Returns the line prefix of end lines.
189	*
190	* @return line prefix of end lines
191	*/
192	protected abstract String getEndingPrefix();
193
194	/**
195	* Returns the first comment range in this comment line.
196	*
197	* @return the first comment range
198	*/
199	protected final CommentRange getFirst() {
200	return (CommentRange)this.fRanges.getFirst();
201	}
202
203	/**
204	* Returns the indentation reference string for this line.
205	*
206	* @return the indentation reference string for this line
207	*/
208	protected String getIndentationReference() {
209	return ""; //$NON-NLS-1$
210	}
211
212	/**
213	* Returns the last comment range in this comment line.
214	*
215	* @return the last comment range
216	*/
217	protected final CommentRange getLast() {
218	return (CommentRange)this.fRanges.getLast();
219	}
220
221	/**
222	* Returns the parent comment region of this comment line.
223	*
224	* @return the parent comment region
225	*/
226	protected final CommentRegion getParent() {
227	return this.fParent;
228	}
229
230	/**
231	* Returns the number of comment ranges in this comment line.
232	*
233	* @return the number of ranges in this line
234	*/
235	protected final int getSize() {
236	return this.fRanges.size();
237	}
238
239	/**
240	* Returns the line prefix of start lines.
241	*
242	* @return line prefix of start lines
243	*/
244	protected abstract String getStartingPrefix();
245
246	/**
247	* Is the attribute <code>attribute</code> true?
248	*
249	* @param attribute the attribute to get.
250	* @return <code>true</code> iff this attribute is <code>true</code>,
251	* <code>false</code> otherwise.
252	*/
253	protected final boolean hasAttribute(final int attribute) {
254	return (this.fAttributes & attribute) == attribute;
255	}
256
257	/**
258	* Scans this comment line for comment range boundaries.
259	*
260	* @param line the index of this line in the comment region
261	*/
262	protected abstract void scanLine(final int line);
263
264	/**
265	* Set the attribute <code>attribute</code> to true.
266	*
267	* @param attribute the attribute to set.
268	*/
269	protected final void setAttribute(final int attribute) {
270	this.fAttributes \|= attribute;
271	}
272
273	/**
274	* Tokenizes this comment line into comment ranges
275	*
276	* @param line the index of this line in the comment region
277	*/
278	protected void tokenizeLine(final int line) {
279
280	int offset= 0;
281	int index= offset;
282
283	final CommentRange range= (CommentRange)this.fRanges.get(0);
284	final int begin= range.getOffset();
285
286	final String content= this.fParent.getText(begin, range.getLength());
287	final int length= content.length();
288
289	while (offset < length) {
290
291	while (offset < length && ScannerHelper.isWhitespace(content.charAt(offset)))
292	offset++;
293
294	index= offset;
295
296	while (index < length && !ScannerHelper.isWhitespace(content.charAt(index)))
297	index++;
298
299	if (index - offset > 0) {
300	this.fParent.append(new CommentRange(begin + offset, index - offset));
301
302	offset= index;
303	}
304	}
305	}
306
307	public String toString() {
308	final StringBuffer buffer = new StringBuffer();
309	final int size = this.fRanges.size();
310	for (int i = 0; i < size; i++) {
311	buffer.append(this.fRanges.get(i)).append("\n"); //$NON-NLS-1$
312	}
313	return String.valueOf(buffer);
314	}
315	}

Removed Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/comment/JavaDocRegion.java (-365 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.jdt.internal.formatter.comment;
13
14	import java.io.IOException;
15	import java.io.StringReader;
16	import java.util.ArrayList;
17	import java.util.Iterator;
18
19	import org.eclipse.text.edits.TextEdit;
20
21	import org.eclipse.jface.text.BadLocationException;
22	import org.eclipse.jface.text.DefaultLineTracker;
23	import org.eclipse.jface.text.IDocument;
24	import org.eclipse.jface.text.ILineTracker;
25	import org.eclipse.jface.text.Position;
26	import org.eclipse.jface.text.TextUtilities;
27
28	import org.eclipse.jdt.core.formatter.CodeFormatter;
29	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
30	import org.eclipse.jdt.internal.formatter.CodeFormatterVisitor;
31
32
33	/**
34	* Javadoc region in a source code document.
35	*
36	* @since 3.0
37	*/
38	public class JavaDocRegion extends MultiCommentRegion {
39
40	/** The positions of code ranges */
41	private final ArrayList fCodePositions= new ArrayList();
42
43	/** Should HTML tags be formatted? */
44	private final boolean fFormatHtml;
45
46	/** Should source code regions be formatted? */
47	private final boolean fFormatSource;
48
49	/**
50	* Creates a new Javadoc region.
51	*
52	* @param document the document which contains the comment region
53	* @param position the position of this comment region in the document
54	* @param formatter the given formatter
55	*/
56	public JavaDocRegion(final IDocument document, final Position position, final CodeFormatterVisitor formatter) {
57	super(document, position, formatter);
58
59	this.fFormatSource = this.preferences.comment_format_source;
60	this.fFormatHtml = this.preferences.comment_format_html;
61	this.fClear = this.preferences.comment_clear_blank_lines_in_javadoc_comment;
62	}
63
64	/*
65	* @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#canFormat(org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange)
66	*/
67	protected boolean canFormat(final CommentRange previous, final CommentRange next) {
68
69	if (previous != null) {
70
71	final boolean isCurrentCode= next.hasAttribute(COMMENT_CODE);
72	final boolean isLastCode= previous.hasAttribute(COMMENT_CODE);
73
74	final int base= getOffset();
75
76	if (!isLastCode && isCurrentCode)
77	this.fCodePositions.add(new Position(base + previous.getOffset()));
78	else if (isLastCode && !isCurrentCode)
79	this.fCodePositions.add(new Position(base + next.getOffset() + next.getLength()));
80
81	if (previous.hasAttribute(COMMENT_IMMUTABLE) && next.hasAttribute(COMMENT_IMMUTABLE))
82	return false;
83
84	return true;
85	}
86	return false;
87	}
88
89	/*
90	* @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#formatRegion(java.lang.String, int)
91	*/
92	protected final void formatRegion(final String indentation, final int width) {
93
94	super.formatRegion(indentation, width);
95
96	if (this.fFormatSource) {
97
98	try {
99
100	if (this.fCodePositions.size() > 0) {
101
102	int begin= 0;
103	int end= 0;
104
105	Position position= null;
106
107	final IDocument document= getDocument();
108
109	for (int index= this.fCodePositions.size() - 1; index >= 0;) {
110
111	position= (Position)this.fCodePositions.get(index--);
112	begin= position.getOffset();
113
114	if (index >= 0) {
115	position= (Position)this.fCodePositions.get(index--);
116	end= position.getOffset();
117	} else {
118	/*
119	* Handle missing closing tag
120	* see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=57011
121	*/
122	position= null;
123	end= getOffset() + getLength() - MultiCommentLine.MULTI_COMMENT_END_PREFIX.trim().length();
124	while (end > begin && ScannerHelper.isWhitespace(document.getChar(end - 1)))
125	end--;
126	}
127
128	String snippet= document.get(begin, end - begin);
129	snippet= preprocessCodeSnippet(snippet);
130	snippet= formatCodeSnippet(snippet);
131	snippet= postprocessCodeSnippet(snippet, indentation);
132
133	logEdit(snippet, begin - getOffset(), end - begin);
134	}
135	}
136	} catch (BadLocationException e) {
137	// Can not happen
138	CommentFormatterUtil.log(e);
139	}
140	}
141	}
142
143	/**
144	* Preprocess a given code snippet.
145	*
146	* @param snippet the code snippet
147	* @return the preprocessed code snippet
148	*/
149	private String preprocessCodeSnippet(String snippet) {
150	// strip content prefix
151	StringBuffer buffer= new StringBuffer();
152	ILineTracker tracker= new DefaultLineTracker();
153	String contentPrefix= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX.trim();
154
155	buffer.setLength(0);
156	buffer.append(snippet);
157	tracker.set(snippet);
158	for (int line= tracker.getNumberOfLines() - 1; line > 0; line--) {
159	int lineOffset;
160	try {
161	lineOffset= tracker.getLineOffset(line);
162	} catch (BadLocationException e) {
163	// Can not happen
164	CommentFormatterUtil.log(e);
165	return snippet;
166	}
167	int prefixOffset= buffer.indexOf(contentPrefix, lineOffset);
168	if (prefixOffset >= 0 && buffer.substring(lineOffset, prefixOffset).trim().length() == 0)
169	buffer.delete(lineOffset, prefixOffset + contentPrefix.length() + 1);
170	}
171
172	return convertHtml2Java(buffer.toString());
173	}
174
175	/**
176	* Format the given code snippet
177	*
178	* @param snippet the code snippet
179	* @return the formatted code snippet
180	*/
181	private String formatCodeSnippet(String snippet) {
182	String lineDelimiter= TextUtilities.getDefaultLineDelimiter(getDocument());
183	TextEdit edit= CommentFormatterUtil.format2(CodeFormatter.K_UNKNOWN, snippet, 0, lineDelimiter, this.preferences.getMap());
184	if (edit != null)
185	snippet= CommentFormatterUtil.evaluateFormatterEdit(snippet, edit, null);
186	return snippet;
187	}
188
189	/**
190	* Postprocesses the given code snippet with the given indentation.
191	*
192	* @param snippet the code snippet
193	* @param indentation the indentation
194	* @return the postprocessed code snippet
195	*/
196	private String postprocessCodeSnippet(String snippet, String indentation) {
197	// patch content prefix
198	StringBuffer buffer= new StringBuffer();
199	ILineTracker tracker= new DefaultLineTracker();
200	String patch= indentation + MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;
201
202	// remove trailing spaces
203	int i= snippet.length();
204	while (i > 0 && ' ' == snippet.charAt(i-1))
205	i--;
206	snippet= snippet.substring(0, i);
207
208	buffer.setLength(0);
209	String lineDelimiter= getDelimiter();
210	if (lineDelimiter != null && snippet.indexOf(lineDelimiter) != 0)
211	buffer.append(lineDelimiter);
212	buffer.append(convertJava2Html(snippet));
213	if (lineDelimiter != null && snippet.lastIndexOf(lineDelimiter) != snippet.length() - lineDelimiter.length())
214	buffer.append(lineDelimiter);
215	tracker.set(buffer.toString());
216
217	for (int line= tracker.getNumberOfLines() - 1; line > 0; line--)
218	try {
219	buffer.insert(tracker.getLineOffset(line), patch);
220	} catch (BadLocationException e) {
221	// Can not happen
222	CommentFormatterUtil.log(e);
223	return snippet;
224	}
225
226	return buffer.toString();
227	}
228
229	/*
230	* @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markHtmlRanges()
231	*/
232	protected final void markHtmlRanges() {
233
234	markTagRanges(JAVADOC_IMMUTABLE_TAGS, COMMENT_IMMUTABLE, true);
235
236	if (this.fFormatSource)
237	markTagRanges(JAVADOC_CODE_TAGS, COMMENT_CODE, false);
238	}
239
240	/*
241	* @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markHtmlTag(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String)
242	*/
243	protected final void markHtmlTag(final CommentRange range, final char[] token) {
244
245	if (range.hasAttribute(COMMENT_HTML)) {
246
247	range.markHtmlTag(JAVADOC_IMMUTABLE_TAGS, token, COMMENT_IMMUTABLE, true, true);
248	if (this.fFormatHtml) {
249
250	range.markHtmlTag(JAVADOC_SEPARATOR_TAGS, token, COMMENT_SEPARATOR, true, true);
251	range.markHtmlTag(JAVADOC_BREAK_TAGS, token, COMMENT_BREAK, false, true);
252	range.markHtmlTag(JAVADOC_SINGLE_BREAK_TAG, token, COMMENT_BREAK, true, false);
253	range.markHtmlTag(JAVADOC_NEWLINE_TAGS, token, COMMENT_NEWLINE, true, false);
254
255	} else
256	range.markHtmlTag(JAVADOC_CODE_TAGS, token, COMMENT_SEPARATOR, true, true);
257	}
258	}
259
260	/*
261	* @see org.eclipse.jdt.internal.corext.text.comment.MultiCommentRegion#markJavadocTag(org.eclipse.jdt.internal.corext.text.comment.CommentRange, java.lang.String)
262	*/
263	protected final void markJavadocTag(final CommentRange range, final char[] token) {
264
265	range.markPrefixTag(JAVADOC_PARAM_TAGS, COMMENT_TAG_PREFIX, token, COMMENT_PARAMETER);
266
267	if (token[0] == JAVADOC_TAG_PREFIX && !range.hasAttribute(COMMENT_PARAMETER))
268	range.setAttribute(COMMENT_ROOT);
269	}
270
271	/**
272	* Marks the comment region with the HTML range tag.
273	*
274	* @param tags the HTML tag which confines the HTML range
275	* @param attribute the attribute to set if the comment range is in the
276	* HTML range
277	* @param html <code>true</code> iff the HTML tags in this HTML range
278	* should be marked too, <code>false</code> otherwise
279	*/
280	protected final void markTagRanges(final char[][] tags, final int attribute, final boolean html) {
281
282	int level= 0;
283	int count= 0;
284	char[] token= null;
285	CommentRange current= null;
286
287	for (int index= 0; index < tags.length; index++) {
288
289	level= 0;
290	for (final Iterator iterator= getRanges().iterator(); iterator.hasNext();) {
291
292	current= (CommentRange)iterator.next();
293	count= current.getLength();
294
295	if (count > 0 \|\| level > 0) { // PR44035: when inside a tag, mark blank lines as well to get proper snippet formatting
296
297	token= getText(current.getOffset(), current.getLength()).toCharArray();
298	level= current.markTagRange(token, tags[index], level, attribute, html);
299	}
300	}
301	}
302	}
303
304	/*
305	* @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#canAppend(org.eclipse.jdt.internal.corext.text.comment.CommentLine, org.eclipse.jdt.internal.corext.text.comment.CommentRange, org.eclipse.jdt.internal.corext.text.comment.CommentRange, int, int)
306	*/
307	protected boolean canAppend(CommentLine line, CommentRange previous, CommentRange next, int index, int count) {
308	// don't append code sections
309	if (next.hasAttribute(COMMENT_CODE \| COMMENT_FIRST_TOKEN) && line.getSize() != 0)
310	return false;
311	return super.canAppend(line, previous, next, index, count);
312	}
313
314	/**
315	* Converts <code>formatted</code> into valid html code suitable to be
316	* put inside <pre></pre> tags by replacing any html symbols
317	* by the relevant entities.
318	*
319	* @param formatted the formatted java code
320	* @return html version of the formatted code
321	*/
322	private String convertJava2Html(String formatted) {
323	Java2HTMLEntityReader reader= new Java2HTMLEntityReader(new StringReader(formatted));
324	char[] buf= new char[256];
325	StringBuffer buffer= new StringBuffer();
326	int l;
327	try {
328	do {
329	l= reader.read(buf);
330	if (l != -1)
331	buffer.append(buf, 0, l);
332	} while (l > 0);
333	return buffer.toString();
334	} catch (IOException e) {
335	return formatted;
336	}
337	}
338
339	/**
340	* Converts <code>html</code> into java code suitable for formatting
341	* by replacing any html entities by their plain text representation.
342	*
343	* @param html html code, may contain html entities
344	* @return plain textified version of <code>html</code>
345	*/
346	private String convertHtml2Java(String html) {
347	HTMLEntity2JavaReader reader= new HTMLEntity2JavaReader(new StringReader(html));
348	char[] buf= new char[html.length()]; // html2text never gets longer, only shorter!
349
350	try {
351	int read= reader.read(buf);
352	return new String(buf, 0, read);
353	} catch (IOException e) {
354	return html;
355	}
356	}
357
358	/*
359	* @see org.eclipse.jdt.internal.corext.text.comment.CommentRegion#createLine()
360	* @since 3.1
361	*/
362	protected CommentLine createLine() {
363	return new JavaDocLine(this);
364	}
365	}

Lines 17-34 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/comment/MultiLineTestCase.java (-14 / +6 lines)
17		17
18	import junit.framework.Test;	18	import junit.framework.Test;
19		19
20	import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
21	import org.eclipse.jdt.internal.formatter.comment.MultiCommentLine;
22
23	public class MultiLineTestCase extends CommentTestCase {	20	public class MultiLineTestCase extends CommentTestCase {
24	static {	21	static {
25	// TESTS_NAMES = new String[] { "test170580" } ;	22	// TESTS_NAMES = new String[] { "test170580" } ;
26	}	23	}
27	protected static final String INFIX= MultiCommentLine.MULTI_COMMENT_CONTENT_PREFIX;
28
29	protected static final String POSTFIX= MultiCommentLine.MULTI_COMMENT_END_PREFIX;
30		24
31	protected static final String PREFIX= MultiCommentLine.MULTI_COMMENT_START_PREFIX;	25	protected static final String INFIX= " * "; //$NON-NLS-1$
		26	protected static final String POSTFIX= " */"; //$NON-NLS-1$
		27	protected static final String PREFIX= "/* "; //$NON-NLS-1$
32		28
33	public static Test suite() {	29	public static Test suite() {
34	return buildTestSuite(MultiLineTestCase.class);	30	return buildTestSuite(MultiLineTestCase.class);
Lines 116-128 Link Here
116	" * Member comment\n" +//$NON-NLS-1$	112	" * Member comment\n" +//$NON-NLS-1$
117	" */";//$NON-NLS-1$	113	" */";//$NON-NLS-1$
118	String result= testFormat(input, 0, input.length(), CodeFormatter.K_MULTI_LINE_COMMENT , 2);	114	String result= testFormat(input, 0, input.length(), CodeFormatter.K_MULTI_LINE_COMMENT , 2);
119	String expectedOutput = DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT	115	String expectedOutput = "/**\n" +
120	? "/**\n" +	116	" * Member comment\n" +
121	" * Member comment\n" +	117	" */";
122	" */"
123	: "/***********************************************************************\n" +
124	" * Member comment\n" +
125	" */";
126	assertEquals("Different output", expectedOutput, result);	118	assertEquals("Different output", expectedOutput, result);
127	}	119	}
128		120