Attachment #166863 for bug #310811

View | Details | Raw Unified | Return to bug 310811
Collapse All | Expand All

Lines 4966-4972 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/CodeFormatterVisitor.java (-1 / +1 lines)
4966	ASTNode[] fragments = stringLiteral.literals;	4966	ASTNode[] fragments = stringLiteral.literals;
4967	int fragmentsSize = stringLiteral.counter;	4967	int fragmentsSize = stringLiteral.counter;
4968	Alignment binaryExpressionAlignment = this.scribe.createAlignment(	4968	Alignment binaryExpressionAlignment = this.scribe.createAlignment(
4969	Alignment.BINARY_EXPRESSION,	4969	Alignment.STRING_CONCATENATION,
4970	this.preferences.alignment_for_binary_expression,	4970	this.preferences.alignment_for_binary_expression,
4971	Alignment.R_OUTERMOST,	4971	Alignment.R_OUTERMOST,
4972	fragmentsSize,	4972	fragmentsSize,





	// Line separator infos
	final private String lineSeparator;
	final private String lineSeparatorAndSpace;
	final private char firstLS;
	final private int lsLength;


	OptimizedReplaceEdit previousDisabledEdit;
	private char[] disablingTag, enablingTag;

	// Well know strings
	private String[] newEmptyLines = new String[10];
	private static String[] COMMENT_INDENTATIONS = new String[20];

	// final string buffers
	private final StringBuffer tempBuffer= new StringBuffer();
	private final StringBuffer blockCommentBuffer = new StringBuffer();
	private final StringBuffer blockCommentTokensBuffer = new StringBuffer();
	private final StringBuffer codeSnippetBuffer = new StringBuffer();
	private final StringBuffer javadocBlockRefBuffer= new StringBuffer();
	private final StringBuffer javadocGapLinesBuffer = new StringBuffer();
	private StringBuffer[] javadocHtmlTagBuffers = new StringBuffer[5];
	private final StringBuffer javadocTextBuffer = new StringBuffer();
	private final StringBuffer javadocTokensBuffer = new StringBuffer();

	Scribe(CodeFormatterVisitor formatter, long sourceLevel, IRegion[] regions, CodeSnippetParsingUtil codeSnippetParsingUtil, boolean includeComments) {
		initializeScanner(sourceLevel, formatter.preferences);
		this.formatter = formatter;

			this.indentationSize = this.tabLength;
		}
		this.lineSeparator = formatter.preferences.line_separator;
		this.lineSeparatorAndSpace = this.lineSeparator+' ';
		this.firstLS = this.lineSeparator.charAt(0);
		this.lsLength = this.lineSeparator.length();
		this.indentationLevel = formatter.preferences.initial_indentation_level * this.indentationSize;

							if (linesCount == 0) {
				    			edit.replacement = ""; //$NON-NLS-1$
							} else {
								edit.replacement = getNewLineString(linesCount);
								for (int j=0; j<linesCount; j++) {
									buffer.append(this.lineSeparator);
								}
								edit.replacement = buffer.toString();
							}
						}
					}

		if (this.nlsTagCounter > 0) {
			return Util.EMPTY_STRING;
		}
		String emptyLines;
		if (this.lastNumberOfNewLines == 0) {
			linesNumber++; // add an extra line breaks
			if (this.indentEmptyLines) {
				this.tempBuffer.setLength(0);
				for (int i = 0; i < linesNumber; i++) {
					printIndentationIfNecessary(this.tempBuffer);
					this.tempBuffer.append(this.lineSeparator);
				}
				emptyLines = this.tempBuffer.toString();
			} else {
				emptyLines = getNewLineString(linesNumber);
			}
			this.lastNumberOfNewLines += linesNumber;
			this.line += linesNumber;

			this.needSpace = false;
			this.pendingSpace = false;
		} else if (this.lastNumberOfNewLines == 1) {
			if (this.indentEmptyLines) {
				this.tempBuffer.setLength(0);
				for (int i = 0; i < linesNumber; i++) {
					printIndentationIfNecessary(this.tempBuffer);
					this.tempBuffer.append(this.lineSeparator);
				}
				emptyLines = this.tempBuffer.toString();
			} else {
				emptyLines = getNewLineString(linesNumber);
			}
			this.lastNumberOfNewLines += linesNumber;
			this.line += linesNumber;

				return Util.EMPTY_STRING;
			}
			final int realNewLineNumber = linesNumber - this.lastNumberOfNewLines + 1;
			if (this.indentEmptyLines) {
				this.tempBuffer.setLength(0);
				for (int i = 0; i < realNewLineNumber; i++) {
					printIndentationIfNecessary(this.tempBuffer);
					this.tempBuffer.append(this.lineSeparator);
				}
				emptyLines = this.tempBuffer.toString();
			} else {
				emptyLines = getNewLineString(realNewLineNumber);
			}
			this.lastNumberOfNewLines += realNewLineNumber;
			this.line += realNewLineNumber;

			this.needSpace = false;
			this.pendingSpace = false;
		}
		return emptyLines;
	}

	private int getIndexOfAdaptedRegionAt(int offset) {

		return this.lineSeparator;
	}

	private String getNewLineString(int linesCount) {
		int length = this.newEmptyLines.length;
		if (linesCount > length) {
			System.arraycopy(this.newEmptyLines, 0, this.newEmptyLines = new String[linesCount+10], 0, length);
		}
		String newLineString = this.newEmptyLines[linesCount-1];
		if (newLineString == null) {
			this.tempBuffer.setLength(0);
			for (int j=0; j<linesCount; j++) {
				this.tempBuffer.append(this.lineSeparator);
			}
			newLineString = this.tempBuffer.toString();
			this.newEmptyLines[linesCount-1] = newLineString;
		}
		return newLineString;
	}

	/**
	 * Answer next indentation level based on column estimated position
	 * (if column is not indented, then use indentationLevel)

					this.indentationLevel = this.currentAlignment.location.outputIndentationLevel;

					// Create new line
					this.tempBuffer.setLength(0);
					this.tempBuffer.append(getNewLine());
					
					// Look for current indentation
					int currentIndentation = getCurrentIndentation(this.scanner.currentPosition);

					this.preserveLineBreakIndentation = true;
					
					// Print the computed indentation in the buffer
					printIndentationIfNecessary(this.tempBuffer);
					return this.tempBuffer.toString();
				}
			}
			return Util.EMPTY_STRING;

		int relativeDepth = 0, outerMostDepth = -1;
		Alignment targetAlignment = this.currentAlignment;
		int previousKind = -1;
		int insideMessage = 0;
		boolean insideStringConcat = false;
		while (targetAlignment != null){
			boolean couldBreak = targetAlignment.tieBreakRule == Alignment.R_OUTERMOST ||
				(!insideStringConcat &&
						insideMessage > 0 && targetAlignment.kind == Alignment.MESSAGE_ARGUMENTS &&
						(!targetAlignment.wasReset() || previousKind != Alignment.MESSAGE_SEND));
			if (couldBreak && targetAlignment.couldBreak()){
				outerMostDepth = relativeDepth;
			}
			switch (targetAlignment.kind) {
				case Alignment.MESSAGE_ARGUMENTS:
					insideMessageArguments = true;
					break;
				case Alignment.MESSAGE_SEND:
					insideMessage++;
					break;
				case Alignment.STRING_CONCATENATION:
					insideStringConcat = true;
					break;
			}
			previousKind = targetAlignment.kind;

					// do not throw the exception immediately to have a chance to reset
					// previously broken alignments (see bug 203588)
					alignmentException = new AlignmentException(AlignmentException.LINE_TOO_LONG, relativeDepth);
					if (insideStringConcat) throw alignmentException;
				}
			} else if (targetAlignment.wasSplit) {
				// reset the nearest already broken outermost alignment.

							this.line++;
							isNewLine = false;

							boolean addSpace = false;
							if (onFirstColumn) {
								// simply insert indentation if necessary
								buffer.append(this.lineSeparator);
								if (indentComment) {
									printIndentationIfNecessary(buffer);
								}
								if (formatComment) {
									if (ScannerHelper.isWhitespace((char) currentCharacter)) {
										int previousStartPosition = this.scanner.currentPosition;

										}
									}
									if (currentCharacter != '\r' && currentCharacter != '\n') {
										addSpace = true;
									}
								}
							} else {

										nextCharacterStart = previousStartPosition;
									}
								}
								buffer.append(this.lineSeparator);
								if (indentComment) {
									printIndentationIfNecessary(buffer);
								}
								if (formatComment) {
									int previousStartTemp = previousStart;
									int nextCharacterStartTemp = nextCharacterStart;

										nextCharacterStart = this.scanner.currentPosition;
									}
									if (currentCharacter == '*') {
										addSpace = true;
									} else {
										previousStart = previousStartTemp;
										nextCharacterStart = nextCharacterStartTemp;

									this.scanner.currentPosition = nextCharacterStart;
								}
							}
							String replacement;
							if (indentComment) {
								this.tempBuffer.setLength(0);
								this.tempBuffer.append(this.lineSeparator);
								if (this.indentationLevel > 0) {
									printIndentationIfNecessary(this.tempBuffer);
								}
								if (addSpace) {
									this.tempBuffer.append(' ');
								}
								replacement = this.tempBuffer.toString();
							} else {
								replacement = addSpace ? this.lineSeparatorAndSpace : this.lineSeparator;
							}
							addReplaceEdit(start, previousStart - 1, replacement);
						} else {
							this.column += (nextCharacterStart - previousStart);
						}

		}

		// Consume the comment prefix
		this.blockCommentBuffer.setLength(0);
		this.scanner.getNextChar();
		this.scanner.getNextChar();
		this.column += 2;
		this.scanner.skipComments = true;
		this.blockCommentTokensBuffer.setLength(0);
		int editStart = this.scanner.currentPosition;
		int editEnd = -1;


    		boolean isTokenStar = false;
			switch (token) {
				case TerminalTokens.TokenNameWHITESPACE:
					if (this.blockCommentTokensBuffer.length() > 0) {
						if (hasTextOnFirstLine == 1 && multiLines) {
							printBlockCommentHeaderLine(this.blockCommentBuffer);
							hasTextOnFirstLine = -1;
						}
						this.blockCommentBuffer.append(this.blockCommentTokensBuffer);
						this.column += this.blockCommentTokensBuffer.length();
						this.blockCommentTokensBuffer.setLength(0);
						bufferHasTokens = true;
						bufferHasNewLine = false;
					}

					isTokenStar = true;
					lineNumber = Util.getLineNumber(this.scanner.currentPosition, this.lineEnds, scannerLine>1 ? scannerLine-2 : 0, this.maxLines);
					if (lineNumber == firstLine && previousToken == SKIP_FIRST_WHITESPACE_TOKEN) {
						this.blockCommentBuffer.append(' ');
					}
					previousToken = token;
					if (this.scanner.currentCharacter == '/') {
						editEnd = this.scanner.startPosition - 1;
						// Add remaining buffered tokens
						if (this.blockCommentTokensBuffer.length() > 0) {
							this.blockCommentBuffer.append(this.blockCommentTokensBuffer);
							this.column += this.blockCommentTokensBuffer.length();
						}
						// end of comment
						if (newLinesAtBoundaries) {
							if (multiLines || hasMultiLines) {
						    	this.blockCommentBuffer.append(this.lineSeparator);
						    	this.column = 1;
						    	printIndentationIfNecessary(this.blockCommentBuffer);
							}
						}
						this.blockCommentBuffer.append(' ');
						this.column += BLOCK_FOOTER_LENGTH + 1;
				    	this.scanner.getNextChar(); // reach the end of scanner
				    	continue;

				}
				for (int i=0; i<linesGap; i++) {
					// Add remaining buffered tokens
					if (this.blockCommentTokensBuffer.length() > 0) {
						if (hasTextOnFirstLine == 1) {
							printBlockCommentHeaderLine(this.blockCommentBuffer);
							hasTextOnFirstLine = -1;
						}
						this.blockCommentBuffer.append(this.blockCommentTokensBuffer);
						this.blockCommentTokensBuffer.setLength(0);
						bufferHasTokens = true;
					}
			    	this.blockCommentBuffer.append(this.lineSeparator);
			    	this.column = 1;
			    	printIndentationIfNecessary(this.blockCommentBuffer);
		    		this.blockCommentBuffer.append(BLOCK_LINE_PREFIX);
		    		this.column += BLOCK_LINE_PREFIX_LENGTH;
		    		firstWord = true;
					multiLines = true;

	    			hasTextOnFirstLine = -1;
	    		}
    		}
    		int lastColumn = this.column + this.blockCommentTokensBuffer.length() + tokenLength;
    		if (insertSpace) lastColumn++;

    		// Append next token inserting a new line if max line is reached
			if (lineHasTokens && !firstWord && lastColumn > maxColumn) {
		    	String tokensString = this.blockCommentTokensBuffer.toString().trim();
		    	int tokensStringLength = tokensString.length();
				// not enough space on the line
				if (hasTextOnFirstLine == 1) {
					printBlockCommentHeaderLine(this.blockCommentBuffer);
				}
				if ((this.indentationLevel+tokensStringLength+tokenLength) > maxColumn) {
					// there won't be enough room even if we break the line before the buffered tokens
					// So add the buffered tokens now
					this.blockCommentBuffer.append(this.blockCommentTokensBuffer);
					this.column += this.blockCommentTokensBuffer.length();
					this.blockCommentTokensBuffer.setLength(0);
					bufferHasNewLine = false;
					bufferHasTokens = true;
				}
				if (bufferHasTokens && !bufferHasNewLine) {
			    	this.blockCommentBuffer.append(this.lineSeparator);
			    	this.column = 1;
			    	printIndentationIfNecessary(this.blockCommentBuffer);
		    		this.blockCommentBuffer.append(BLOCK_LINE_PREFIX);
			    	this.column += BLOCK_LINE_PREFIX_LENGTH;
				}
		    	if (this.blockCommentTokensBuffer.length() > 0) {
					this.blockCommentBuffer.append(tokensString);
					this.column += tokensStringLength;
					this.blockCommentTokensBuffer.setLength(0);
		    	}
				this.blockCommentBuffer.append(this.scanner.source, tokenStart, tokenLength);
				bufferHasTokens = true;
				bufferHasNewLine = false;
				this.column += tokenLength;

			} else {
				// append token to the line
				if (insertSpace)  {
					this.blockCommentTokensBuffer.append(' ');
				}
				this.blockCommentTokensBuffer.append(this.scanner.source, tokenStart, tokenLength);
			}
			previousToken = token;
			newLine = false;

		// Replace block comment text
		if (this.nlsTagCounter == 0 || !multiLines) {
			if (hasTokens || multiLines) {
				StringBuffer replacement;
				if (hasTextOnFirstLine == 1) {
					this.blockCommentTokensBuffer.setLength(0);
					replacement = this.blockCommentTokensBuffer;
					if ((hasMultiLines || multiLines)) {
						int col = this.column;
						replacement.append(this.lineSeparator);

						printIndentationIfNecessary(replacement);
						replacement.append(BLOCK_LINE_PREFIX);
				    	this.column = col;
					} else if (this.blockCommentBuffer.length()==0 || this.blockCommentBuffer.charAt(0)!=' ') {
						replacement.append(' ');
					}
					replacement.append(this.blockCommentBuffer);
				} else {
					replacement = this.blockCommentBuffer;
				}
				replacement.append(buffer);
				addReplaceEdit(editStart, editEnd, replacement.toString());
			}
		}

	    	buffer.append(BLOCK_LINE_PREFIX);
	    	this.column += BLOCK_LINE_PREFIX_LENGTH;
	    } else {
	    	this.tempBuffer.setLength(0);
	    	this.tempBuffer.append(this.lineSeparator);
	    	this.column = 1;
			printIndentationIfNecessary(this.tempBuffer);
	    	this.tempBuffer.append(BLOCK_LINE_PREFIX);
	    	this.column += BLOCK_LINE_PREFIX_LENGTH;
	    	buffer.insert(0, this.tempBuffer.toString());
	    }
    }


		// 1 - strip content prefix (@see JavaDocRegion#preprocessCodeSnippet)
		int firstLine = Util.getLineNumber(startPosition, this.lineEnds, 0, this.maxLines) - 1;
		int lastLine = Util.getLineNumber(endPosition, this.lineEnds, firstLine>1 ? firstLine-2 : 0, this.maxLines) - 1;
		this.codeSnippetBuffer.setLength(0);
		if (firstLine == lastLine && linesGap == 0) {
			this.codeSnippetBuffer.append(snippet);
		} else {
			boolean hasCharsAfterStar = false;
			if (linesGap == 0) {
				this.codeSnippetBuffer.append(this.scanner.source, startPosition, this.lineEnds[firstLine]+1-startPosition);
				firstLine++;
			}
			int initialLength = this.codeSnippetBuffer.length();
			for (int currentLine=firstLine; currentLine<=lastLine; currentLine++) {
				this.scanner.resetTo(this.lineEnds[currentLine-1]+1, this.lineEnds[currentLine]);
				int lineStart = this.scanner.currentPosition;

										// consuming the space after the star
										hasCharsAfterStar = true;
										currentLine = firstLine-1;
										this.codeSnippetBuffer.setLength(initialLength);
										continue;
									}
								}

					}
				}
				int end = currentLine == lastLine ? endPosition : this.lineEnds[currentLine];
				this.codeSnippetBuffer.append(this.scanner.source, lineStart, end+1-lineStart);
			}
		}
	
		// 2 - convert HTML to Java (@see JavaDocRegion#convertHtml2Java)
		HTMLEntity2JavaReader reader= new HTMLEntity2JavaReader(new StringReader(this.codeSnippetBuffer.toString()));
		char[] buf= new char[this.codeSnippetBuffer.length()]; // html2text never gets longer, only shorter!
		String convertedSnippet;
		try {
			int read= reader.read(buf);

		TextEdit edit= CommentFormatterUtil.format2(CodeFormatter.K_UNKNOWN | CodeFormatter.F_INCLUDE_COMMENTS, convertedSnippet, 0, this.lineSeparator, options);
		if (edit == null) {
			// 3.a - not a valid code to format, keep initial buffer
			formattedSnippet = this.codeSnippetBuffer.toString();
		} else {
			// 3.b - valid code formatted
			// 3.b.i - get the result

			// 3.b.ii- convert back to HTML (@see JavaDocRegion#convertJava2Html)
			Java2HTMLEntityReader javaReader= new Java2HTMLEntityReader(new StringReader(formattedSnippet));
			buf= new char[256];
			this.codeSnippetBuffer.setLength(0);
			int l;
			try {
				do {
					l= javaReader.read(buf);
					if (l != -1)
						this.codeSnippetBuffer.append(buf, 0, l);
				} while (l > 0);
				formattedSnippet = this.codeSnippetBuffer.toString();
			} catch (IOException e) {
				// should not happen
				CommentFormatterUtil.log(e);

		}
	
		// 4 - add the content prefix (@see JavaDocRegion#postprocessCodeSnippet)
		this.codeSnippetBuffer.setLength(0);
		ILineTracker tracker = new DefaultLineTracker();
		this.column = 1;
		printIndentationIfNecessary(this.codeSnippetBuffer); // append indentation
		this.codeSnippetBuffer.append(BLOCK_LINE_PREFIX);
		String linePrefix = this.codeSnippetBuffer.toString();
		this.codeSnippetBuffer.setLength(0);
		String replacement = formattedSnippet;
		tracker.set(formattedSnippet);
		int numberOfLines = tracker.getNumberOfLines();
		if (numberOfLines > 1) {
			int lastLineOffset = -1;
			for (int i=0; i<numberOfLines-1; i++) {
				if (i>0) this.codeSnippetBuffer.append(linePrefix);
				try {
					lastLineOffset = tracker.getLineOffset(i+1);
					this.codeSnippetBuffer.append(formattedSnippet.substring(tracker.getLineOffset(i), lastLineOffset));
				} catch (BadLocationException e) {
					// should not happen
					CommentFormatterUtil.log(e);
					return;
				}
			}
			this.codeSnippetBuffer.append(linePrefix);
			this.codeSnippetBuffer.append(formattedSnippet.substring(lastLineOffset));
			replacement = this.codeSnippetBuffer.toString();
		}
	
		// 5 - replace old text with the formatted snippet

					this.lastNumberOfNewLines++;
					this.line++;
					if (newLineString == null) {
						this.tempBuffer.setLength(0);
						this.tempBuffer.append(this.lineSeparator);
						this.column = 1;
						if (!this.formatter.preferences.never_indent_line_comments_on_first_column) {
							printIndentationIfNecessary(this.tempBuffer);
						}
					    this.tempBuffer.append(LINE_COMMENT_PREFIX);
						this.column += LINE_COMMENT_PREFIX_LENGTH;
						newLineString = this.tempBuffer.toString();
				    	firstColumn = this.column;
					} else {
						this.column = firstColumn;

	}

	void printIndentationIfNecessary() {
		this.tempBuffer.setLength(0);
		printIndentationIfNecessary(this.tempBuffer);
		if (this.tempBuffer.length() > 0) {
			addInsertEdit(this.scanner.getCurrentTokenStartPosition(), this.tempBuffer.toString());
			this.pendingSpace = false;
		}
	}

						commentIndentationLevel += this.indentationSize;
					}
				}
				setCommentIndentation(commentIndentationLevel);
				    this.commentIndentation = null;
				} else {
		    		StringBuffer indentationBuffer = new StringBuffer();
		        	for (int i=0; i<commentIndentationLevel; i++) {
		    			indentationBuffer.append(' ');
		        	}
	        		this.commentIndentation = indentationBuffer.toString();
		    	}
			}
			FormatJavadocReference reference= block.reference;
			if (reference != null) {

						printJavadocGapLines(previousEnd+1, nodeStart-1, newLines, clearBlankLines, false, null);
					}
				} else {
					this.tempBuffer.setLength(0);
					if (newLines > 0) {
						for (int j=0; j<newLines; j++) {
							printJavadocNewLine(this.tempBuffer);
						}
						addInsertEdit(nodeStart, this.tempBuffer.toString());
					}
				}
			} else {


		// First we need to know what is the indentation
		this.scanner.resetTo(block.tagEnd+1, reference.sourceEnd);
		this.javadocBlockRefBuffer.setLength(0);
		boolean needFormat = false;
		int previousToken = -1;
		int spacePosition = -1;

							case TerminalTokens.TokenNameLPAREN:
								break;
							default:	// space between method arguments
								spacePosition = this.javadocBlockRefBuffer.length();
								// $FALL-THROUGH$ - fall through next case
							case -1:
								this.javadocBlockRefBuffer.append(' ');
								this.column++;
								break;
						}

							this.lastNumberOfNewLines++;
							this.line++;
							if (newLineString == null) {
								this.tempBuffer.setLength(0);
								this.tempBuffer.append(this.lineSeparator);
						    	this.column = 1;
						    	printIndentationIfNecessary(this.tempBuffer);
					    		this.tempBuffer.append(BLOCK_LINE_PREFIX);
					    		this.column += BLOCK_LINE_PREFIX_LENGTH;
								if (this.commentIndentation != null) {
							    	this.tempBuffer.append(this.commentIndentation);
							    	this.column += this.commentIndentation.length();
						    	}
						    	newLineString = this.tempBuffer.substring(0, this.tempBuffer.length()-1); // remove last space as buffer will be inserted before a space
						    	firstColumn = this.column;
							} else {
								this.column = firstColumn;
							}
							this.column = firstColumn + this.javadocBlockRefBuffer.length() - spacePosition - 1;
							this.javadocBlockRefBuffer.insert(spacePosition, newLineString);
							if (headerLine) {
								headerLine = false;
								maxColumn--;
							}
							spacePosition = -1;
						}
						this.javadocBlockRefBuffer.append(this.scanner.source, this.scanner.startPosition, tokenLength);
			    		this.column += tokenLength;
			    		break;
				}

			}
		}
		if (needFormat) {
		    addReplaceEdit(block.tagEnd+1, reference.sourceEnd, this.javadocBlockRefBuffer.toString());
		}
    }


			// if there's no enough room to replace text, then insert the gap
			if (textStartPosition > textEndPosition) {
				if (newLines > 0) {
					this.javadocGapLinesBuffer.setLength(0);
					for (int i=0; i<newLines; i++) {
						this.javadocGapLinesBuffer.append(this.lineSeparator);
						this.column = 1;
						printIndentationIfNecessary(this.javadocGapLinesBuffer);
						if (footer) {
							this.javadocGapLinesBuffer.append(' ');
							this.column++;
						} else {
							this.javadocGapLinesBuffer.append(BLOCK_LINE_PREFIX);
							this.column += BLOCK_LINE_PREFIX_LENGTH;
						}
					}
					if (output == null) {
						addInsertEdit(textStartPosition, this.javadocGapLinesBuffer.toString());
					} else {
						output.append(this.javadocGapLinesBuffer);
					}
				}
				return;

						// we just need to replace each lines between '*' with the javadoc formatted ones
						int linesGap = this.scanner.linePtr - linePtr;
						if (linesGap > 0) {
							this.javadocGapLinesBuffer.setLength(0);
							if (lineCount > 0) {
								// TODO https://bugs.eclipse.org/bugs/show_bug.cgi?id=49619
								this.javadocGapLinesBuffer.append( ' ');
							}
							for (int i = 0; i < linesGap ; i++) {
								if (clearBlankLines && lineCount >= newLines) {

									// so remove any remaining blanks and leave
									if (textEndPosition >= start) {
										if (output == null) {
											addReplaceEdit(start, textEndPosition, this.javadocGapLinesBuffer.toString());
										} else {
											output.append(this.javadocGapLinesBuffer);
										}
									}
									return;
								}
								this.javadocGapLinesBuffer.append(this.lineSeparator);
								this.column = 1;
								printIndentationIfNecessary(this.javadocGapLinesBuffer);
								if (i == (linesGap-1)) {
									this.javadocGapLinesBuffer.append(' ');
									this.column++;
								} else {
									this.javadocGapLinesBuffer.append(BLOCK_LINE_PREFIX);
									this.column += BLOCK_LINE_PREFIX_LENGTH;
								}
								lineCount++;

							int currentTokenStartPosition = this.scanner.getCurrentTokenStartPosition();
							int tokenLength = this.scanner.currentPosition - currentTokenStartPosition;
							if (output == null) {
								addReplaceEdit(start, currentTokenStartPosition-1, this.javadocGapLinesBuffer.toString());
							} else {
								output.append(this.javadocGapLinesBuffer);
								output.append(this.scanner.source, currentTokenStartPosition, tokenLength);
							}
							this.column += tokenLength;

			// Format the last whitespaces
			if (lineCount < newLines) {
				// Insert new lines as not enough was encountered while scanning the whitespaces
				this.javadocGapLinesBuffer.setLength(0);
				if (lineCount > 0) {
					// TODO https://bugs.eclipse.org/bugs/show_bug.cgi?id=49619
					this.javadocGapLinesBuffer.append( ' ');
				}
				for (int i = lineCount; i < newLines-1; i++) {
					printJavadocNewLine(this.javadocGapLinesBuffer);
				}
				this.javadocGapLinesBuffer.append(this.lineSeparator);
				this.column = 1;
				printIndentationIfNecessary(this.javadocGapLinesBuffer);
				if (footer) {
					this.javadocGapLinesBuffer.append(' ');
					this.column++;
				} else {
					this.javadocGapLinesBuffer.append(BLOCK_LINE_PREFIX);
					this.column += BLOCK_LINE_PREFIX_LENGTH;
				}
				if (output == null) {
					if (textEndPosition >= start) {
						addReplaceEdit(start, textEndPosition, this.javadocGapLinesBuffer.toString());
					} else {
						addInsertEdit(textEndPosition+1, this.javadocGapLinesBuffer.toString());
					}
				} else {
					output.append(this.javadocGapLinesBuffer);
				}
			} else {
				// Replace all remaining whitespaces by a single space
				if (textEndPosition >= start) {
					this.javadocGapLinesBuffer.setLength(0);
					if (this.scanner.linePtr > linePtr) {
						if (lineCount > 0) {
							// TODO https://bugs.eclipse.org/bugs/show_bug.cgi?id=49619
							this.javadocGapLinesBuffer.append(' ');
						}
						this.javadocGapLinesBuffer.append(this.lineSeparator);
						this.column = 1;
						printIndentationIfNecessary(this.javadocGapLinesBuffer);
					}
					this.javadocGapLinesBuffer.append(' ');
					if (output == null) {
						addReplaceEdit(start, textEndPosition, this.javadocGapLinesBuffer.toString());
					} else {
						output.append(this.javadocGapLinesBuffer);
					}
					this.needSpace = false;
				} else if (endsOnMultiply) {

			// Iterate on text line separators
			int textLineStart = text.lineStart;
			this.scanner.tokenizeWhiteSpace = false;
			String newLineString = null;
			for (int idx=0, max=text.separatorsPtr; idx<=max ; idx++) {
				int start = (int) text.separators[idx];
				int lineStart = Util.getLineNumber(start, this.lineEnds, textLineStart-1, this.maxLines);

					if (this.scanner.currentCharacter == ' ') {
						this.scanner.getNextChar();
					}
					if (newLineString == null) {
						this.tempBuffer.setLength(0);
						this.column = 1;
						printIndentationIfNecessary(this.tempBuffer);
						this.tempBuffer.append(BLOCK_LINE_PREFIX);
						this.column += BLOCK_LINE_PREFIX_LENGTH;
						newLineString = this.tempBuffer.toString();
					}
					addReplaceEdit(end+1, this.scanner.getCurrentTokenEndPosition(), newLineString);
					textLineStart++;
				}
			}

		int lineEnd = Util.getLineNumber(block.nodes[0].sourceEnd, this.lineEnds, lineStart-1, this.maxLines);
		boolean multiLinesBlock = lineEnd > (lineStart+1);
		int previousPosition = this.scanner.currentPosition;
		String newLineString = null;
		int indentationColumn = 0;
		int leadingSpaces = -1;


					}
					// print indentation if there were spaces without any star on the line
					if (leadingSpaces > 0 && multiLinesBlock) {
						if (newLineString == null) {
							buffer = new StringBuffer();
							this.column = 1;
							this.tempBuffer.setLength(0);
							printIndentationIfNecessary(this.tempBuffer);
							this.tempBuffer.append(BLOCK_LINE_PREFIX);
							this.column += BLOCK_LINE_PREFIX_LENGTH;
							newLineString = this.tempBuffer.toString();
							indentationColumn = this.column;
						} else {
							this.column = indentationColumn;
						}
						addReplaceEdit(newLineStart, newLineStart+indentationColumn-2, newLineString);
					}
					// store line start and reset positions
					newLineStart = this.scanner.currentPosition;

						} else {
							// print indentation before the following characters
							if (offset == 0 && multiLinesBlock) {
								if (newLineString == null) {
									this.tempBuffer.setLength(0);
									this.column = 1;
									printIndentationIfNecessary(this.tempBuffer);
									this.tempBuffer.append(BLOCK_LINE_PREFIX);
									this.column += BLOCK_LINE_PREFIX_LENGTH;
									indentationColumn = this.column;
									newLineString = this.tempBuffer.toString();
								} else {
									this.column = indentationColumn;
								}
								addReplaceEdit(newLineStart, secondLineStart-1, newLineString);
							}
							offset++;
						}

			addReplaceEdit(firstLineEnd, end, " "); //$NON-NLS-1$
		}
		else if (secondLineStart > 0) {
			if (newLineString == null) {
				this.tempBuffer.setLength(0);
				this.column = 1;
				printIndentationIfNecessary(this.tempBuffer);
				this.tempBuffer.append(BLOCK_LINE_PREFIX);
				this.column += BLOCK_LINE_PREFIX_LENGTH;
				newLineString = this.tempBuffer.toString();
				indentationColumn = this.column;
			} else {
				this.column = indentationColumn;
			}
			addReplaceEdit(newLineStart, secondLineStart-1, newLineString);
		}
		else if (leadingSpaces > 0) {
			if (newLineString == null) {
				this.tempBuffer.setLength(0);
				this.column = 1;
				printIndentationIfNecessary(this.tempBuffer);
				this.tempBuffer.append(BLOCK_LINE_PREFIX);
				this.column += BLOCK_LINE_PREFIX_LENGTH;
				newLineString = this.tempBuffer.toString();
				indentationColumn = this.column;
			} else {
				this.column = indentationColumn;
			}
			addReplaceEdit(newLineStart, newLineStart+indentationColumn-2, newLineString);
		}

		// Reset

		int nextStart = textStart;
		int startLine = Util.getLineNumber(textStart, this.lineEnds, 0, this.maxLines);
	    int htmlTagID = text.getHtmlTagID();
	    if (text.depth >= this.javadocHtmlTagBuffers.length) {
	    	int length = this.javadocHtmlTagBuffers.length;
	    	System.arraycopy(this.javadocHtmlTagBuffers, 0, this.javadocHtmlTagBuffers = new StringBuffer[text.depth+6], 0, length);
	    }
	    StringBuffer buffer = this.javadocHtmlTagBuffers[text.depth];
	    if (buffer == null) {
	    	buffer = new StringBuffer();
	    	this.javadocHtmlTagBuffers[text.depth] = buffer;
	    } else {
	    	buffer.setLength(0);
	    }

	    // New line will be added before next node
	    int max = text.separatorsPtr;

					printJavadocGapLines(previousEnd+1, nodeStart-1, newLines, clearBlankLines, false, null);
				}
				if (newLines > 0) textOnNewLine = true;
				buffer.setLength(0);
				if (node.isText()) {
					if (immutable) {
						// do not change immutable tags, just increment column

	    this.column += BLOCK_LINE_PREFIX_LENGTH;
	    this.line++;
	    this.lastNumberOfNewLines++;
	}

	private void printJavadocText(FormatJavadocText text, FormatJavadocBlock block, boolean textOnNewLine) {

		boolean clearBlankLines = this.formatter.preferences.comment_clear_blank_lines_in_javadoc_comment;
		boolean joinLines = this.formatter.preferences.join_lines_in_comments;
		this.javadocTextBuffer.setLength(0);
		int textStart = text.sourceStart;
		int nextStart = textStart;
		int startLine = Util.getLineNumber(textStart, this.lineEnds, 0, this.maxLines);

				}
			}
			this.needSpace = idx > 0;
			printJavadocTextLine(this.javadocTextBuffer, nextStart, end, block, idx==0 || (!joinLines && textOnNewLine)/*first text?*/, needIndentation, false /*not an html tag*/);
			textOnNewLine = false;

			// Replace with current buffer if there are several empty lines between text lines

				int gapLine = endLine;
				if (joinLines) gapLine++; // if not preserving line break then gap must be at least of one line
				if (startLine > gapLine) {
					addReplaceEdit(textStart, end, this.javadocTextBuffer.toString());
					textStart = nextStart;
					this.javadocTextBuffer.setLength(0);
					int newLines = startLine - endLine;
					if (clearBlankLines) newLines = 1;
					printJavadocGapLines(end+1, nextStart-1, newLines, this.formatter.preferences.comment_clear_blank_lines_in_javadoc_comment, false, null);

		// Replace remaining line
		boolean needIndentation = textOnNewLine;
		this.needSpace = text.separatorsPtr >= 0;
		printJavadocTextLine(this.javadocTextBuffer, nextStart, text.sourceEnd, block, text.separatorsPtr==-1 /* first text?*/, needIndentation, false /*not an html tag*/);
		// TODO Bring back following optimization
		// if (lastNewLines != this.lastNumberOfNewLines || (this.column - currentColumn) != (text.sourceEnd - text.sourceStart + 1)) {
			addReplaceEdit(textStart, text.sourceEnd, this.javadocTextBuffer.toString());
		// }

		// Reset

		boolean headerLine = block.isHeaderLine() && this.lastNumberOfNewLines == 0;

		// First we need to know what is the indentation
		this.javadocTokensBuffer.setLength(0);
		int firstColumn = 1 + this.indentationLevel + BLOCK_LINE_PREFIX_LENGTH;
		int maxColumn = this.formatter.preferences.comment_line_length + 1;
		if (headerLine) {

				} catch (InvalidInputException iie) {
					token = consumeInvalidToken(textEnd);
				}
	    		int tokensBufferLength = this.javadocTokensBuffer.length();
    			int tokenStart = this.scanner.getCurrentTokenStartPosition();
	    		int tokenLength = (this.scanner.atEnd() ? this.scanner.eofPosition : this.scanner.currentPosition) - tokenStart;
				boolean insertSpace = (previousToken == TerminalTokens.TokenNameWHITESPACE || this.needSpace) && !textOnNewLine;
				String tokensBufferString = this.javadocTokensBuffer.toString().trim();
				switch (token) {
					case TerminalTokens.TokenNameWHITESPACE:
						if (tokensBufferLength > 0) {

								this.lastNumberOfNewLines++;
								this.line++;
								if (newLineString == null) {
									this.tempBuffer.setLength(0);
									this.tempBuffer.append(this.lineSeparator);
							    	this.column = 1;
							    	printIndentationIfNecessary(this.tempBuffer);
						    		this.tempBuffer.append(BLOCK_LINE_PREFIX);
							    	this.column += BLOCK_LINE_PREFIX_LENGTH;
									if (this.commentIndentation != null) {
										this.tempBuffer.append(this.commentIndentation);
								    	this.column += this.commentIndentation.length();
									}
						    		firstColumn = this.column;
						    		newLineString = this.tempBuffer.toString();
								} else {
									this.column = firstColumn;
								}

									headerLine = false;
								}
							} else {
								buffer.append(this.javadocTokensBuffer);
								this.column += tokensBufferLength;
							}
							this.javadocTokensBuffer.setLength(0);
						}
						textOnNewLine = false;
						previousToken = token;

	    		if (insertSpace) lastColumn++;
				boolean shouldSplit = lastColumn > maxColumn // the max length is reached
					&& (!isHtmlTag || previousToken == -1) // not an html tag or just at the beginning of it
					&& token != TerminalTokens.TokenNameAT && (tokensBufferLength == 0 || this.javadocTokensBuffer.charAt(tokensBufferLength-1) != '@'); // avoid to split just before a '@'
				if (shouldSplit) {
					// not enough space on the line
					if ((tokensBufferLength > 0 || tokenLength < maxColumn) && !isHtmlTag && tokensBufferLength > 0 && (firstColumn+tokensBufferLength+tokenLength) >= maxColumn) {
						// there won't be enough room even if we break the line before the buffered tokens
						// So add the buffered tokens now
						buffer.append(this.javadocTokensBuffer);
						this.column += tokensBufferLength;
						this.javadocTokensBuffer.setLength(0);
						tokensBufferLength = 0;
						textOnNewLine = false;
					}

						this.lastNumberOfNewLines++;
						this.line++;
						if (newLineString == null) {
							this.tempBuffer.setLength(0);
							this.tempBuffer.append(this.lineSeparator);
					    	this.column = 1;
					    	printIndentationIfNecessary(this.tempBuffer);
				    		this.tempBuffer.append(BLOCK_LINE_PREFIX);
					    	this.column += BLOCK_LINE_PREFIX_LENGTH;
							if (this.commentIndentation != null) {
								this.tempBuffer.append(this.commentIndentation);
						    	this.column += this.commentIndentation.length();
							}
				    		firstColumn = this.column;
				    		newLineString = this.tempBuffer.toString();
						} else {
							this.column = firstColumn;
						}

			    		String tokensString = tokensBufferString;
						buffer.append(tokensString);
						this.column += tokensString.length();
						this.javadocTokensBuffer.setLength(0);
						tokensBufferLength = 0;
		    		}
					buffer.append(this.scanner.source, tokenStart, tokenLength);

    			} else {
					// append token to the line
		    		if (insertSpace) {
		    			this.javadocTokensBuffer.append(' ');
		    		}
					this.javadocTokensBuffer.append(this.scanner.source, tokenStart, tokenLength);
    			}
				previousToken = token;
    			this.needSpace = false;

		finally {
			this.scanner.skipComments = false;
			// Add remaining buffered tokens
			if (this.javadocTokensBuffer.length() > 0) {
				buffer.append(this.javadocTokensBuffer);
				this.column += this.javadocTokensBuffer.length();
			}
		}
    }

			// Split the existing edit to keep the change before the beginning of the last line
			// but change the indentation after. Note that at this stage, the add*Edit methods
			// cannot be longer used as the edits are disabled
			String indentationString;
			int currentIndentation = getCurrentIndentation(this.scanner.currentPosition);
			if (currentIndentation > 0 && this.indentationLevel > 0) {
				int col = this.column;
				this.tempBuffer.setLength(0);
				printIndentationIfNecessary(this.tempBuffer);
				indentationString = this.tempBuffer.toString();
				this.column = col;
			} else {
				indentationString = Util.EMPTY_STRING;
			}
			String replacement = currentEdit.replacement;
			if (replacement.length() == 0) {
				// previous edit was a delete, as we're sure to have a new line before
				// the comment, then the edit needs to be either replaced entirely with
				// the expected indentation
				this.edits[this.editsIndex-1] = new OptimizedReplaceEdit(beginningOfLine, offset+length-beginningOfLine, indentationString);
			} else {
				int idx = replacement.lastIndexOf(this.lineSeparator);
				if (idx >= 0) {
					// replace current edit if it contains a line separator
					int start = idx + this.lsLength;
					this.tempBuffer.setLength(0);
					this.tempBuffer.append(replacement.substring(0, start));
					if (indentationString != Util.EMPTY_STRING) {
						this.tempBuffer.append(indentationString);
					}
					this.edits[this.editsIndex-1] = new OptimizedReplaceEdit(offset, length, this.tempBuffer.toString());
				}
			}
		}

		System.arraycopy(this.edits, 0, (this.edits = new OptimizedReplaceEdit[this.editsIndex * 2]), 0, this.editsIndex);
	}

	private void setCommentIndentation(int commentIndentationLevel) {
		if (commentIndentationLevel == 0) {
		    this.commentIndentation = null;
		} else {
			int length = COMMENT_INDENTATIONS.length;
			if (commentIndentationLevel > length) {
				System.arraycopy(COMMENT_INDENTATIONS, 0, COMMENT_INDENTATIONS = new String[commentIndentationLevel+10], 0, length);
			}
			this.commentIndentation = COMMENT_INDENTATIONS[commentIndentationLevel-1];
			if (this.commentIndentation == null) {
				this.tempBuffer.setLength(0);
				for (int i=0; i<commentIndentationLevel; i++) {
					this.tempBuffer.append(' ');
				}
				this.commentIndentation = this.tempBuffer.toString();
				COMMENT_INDENTATIONS[commentIndentationLevel-1] = this.commentIndentation;
			}
		}
	}

	/*
	 * Look for the tags identified by the scanner to see whether some of them
	 * may change the status of the edition for the formatter.




	public static final int SUPER_INTERFACES = 21;
	public static final int THROWS = 22;
	public static final int TYPE_MEMBERS = 23;
	public static final int STRING_CONCATENATION = 24;

	// name of alignment
	public String name;

		"superInterfaces", //$NON-NLS-1$
		"throws", //$NON-NLS-1$
		"typeMembers", //$NON-NLS-1$
		"stringConcatenation", //$NON-NLS-1$
	};

	// link to enclosing alignment

	// location to align and break on.
	public Alignment(int kind, int mode, int tieBreakRule, Scribe scribe, int fragmentCount, int sourceRestart, int continuationIndent){

		Assert.isTrue(kind >=ALLOCATION && kind <=STRING_CONCATENATION);
		this.kind = kind;
		this.name = NAMES[kind];
		this.location = new Location(scribe, sourceRestart);

Return to bug 310811

Lines 46-51 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/align/Alignment.java (-1 / +3 lines)
46	public static final int SUPER_INTERFACES = 21;	46	public static final int SUPER_INTERFACES = 21;
47	public static final int THROWS = 22;	47	public static final int THROWS = 22;
48	public static final int TYPE_MEMBERS = 23;	48	public static final int TYPE_MEMBERS = 23;
		49	public static final int STRING_CONCATENATION = 24;
49		50
50	// name of alignment	51	// name of alignment
51	public String name;	52	public String name;
Lines 74-79 Link Here
74	"superInterfaces", //$NON-NLS-1$	75	"superInterfaces", //$NON-NLS-1$
75	"throws", //$NON-NLS-1$	76	"throws", //$NON-NLS-1$
76	"typeMembers", //$NON-NLS-1$	77	"typeMembers", //$NON-NLS-1$
		78	"stringConcatenation", //$NON-NLS-1$
77	};	79	};
78		80
79	// link to enclosing alignment	81	// link to enclosing alignment
Lines 193-199 Link Here
193	// location to align and break on.	195	// location to align and break on.
194	public Alignment(int kind, int mode, int tieBreakRule, Scribe scribe, int fragmentCount, int sourceRestart, int continuationIndent){	196	public Alignment(int kind, int mode, int tieBreakRule, Scribe scribe, int fragmentCount, int sourceRestart, int continuationIndent){
195		197
196	Assert.isTrue(kind >=ALLOCATION && kind <=TYPE_MEMBERS);	198	Assert.isTrue(kind >=ALLOCATION && kind <=STRING_CONCATENATION);
197	this.kind = kind;	199	this.kind = kind;
198	this.name = NAMES[kind];	200	this.name = NAMES[kind];
199	this.location = new Location(scribe, sourceRestart);	201	this.location = new Location(scribe, sourceRestart);