/*******************************************************************************
* Copyright (c) 2000, 2010 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;
import org.eclipse.jdt.internal.formatter.comment.IJavaDocTagConstants;
/**
* Represents text inside a javadoc comment block.
* <p>
* Text may be simple as <code>Line inside a javadoc comment block</code> or may be a html tag. Note
* that to minimize memory footprint, only text positions are stored.
* </p>
* <p>
* Simple text may have one or several lines. When it has several lines, the positions of the line
* breaks are also stored in the {@link #separators} array.
* </p>
* <p>
* When text has html tags, then they are stored in {@link #htmlNodes} array in a recursive way.
* </p>
*/
public class FormatJavadocText extends FormatJavadocNode implements IJavaDocTagConstants {
long[] separators;
int separatorsPtr= -1;
private int htmlTagIndex= -1;
boolean immutable= false;
FormatJavadocNode[] htmlNodes;
int[] htmlIndexes;
int htmlNodesPtr= -1;
int depth= 0;
public FormatJavadocText(int start, int end, int line, int htmlIndex, int htmlDepth) {
super(start, end, line);
this.htmlTagIndex= htmlIndex;
this.depth= htmlDepth;
}
/*
* Append a text to current one.
* If the given text is not an html tag or is a closing tag, then just append to
* the current text recording the separators. Otherwise, create a new html tag
* child node.
*/
void appendText(FormatJavadocText text) {
text.immutable= this.immutable;
if (this.depth == text.depth) {
addSeparator(text);
this.sourceEnd= text.sourceEnd;
if (text.isClosingHtmlTag()) {
// close the tag
this.htmlTagIndex= text.htmlTagIndex;
}
} else {
appendNode(text);
}
if (text.isHtmlTag()) {
switch (text.htmlTagIndex & JAVADOC_TAGS_ID_MASK) {
case JAVADOC_CODE_TAGS_ID:
text.linesBefore= this.htmlNodesPtr == -1 ? 0 : 2;
break;
case JAVADOC_SEPARATOR_TAGS_ID:
text.linesBefore= 1;
break;
case JAVADOC_SINGLE_BREAK_TAG_ID:
if (!text.isClosingHtmlTag())
text.linesBefore= 1;
break;
case JAVADOC_BREAK_TAGS_ID:
if (!text.isClosingHtmlTag())
text.linesBefore= 1;
}
}
}
void appendNode(FormatJavadocNode node) {
if (++this.htmlNodesPtr == 0) { // lazy initialization
this.htmlNodes= new FormatJavadocNode[DEFAULT_ARRAY_SIZE];
} else {
if (this.htmlNodesPtr == this.htmlNodes.length) {
int size= this.htmlNodesPtr + DEFAULT_ARRAY_SIZE;
System.arraycopy(this.htmlNodes, 0, (this.htmlNodes= new FormatJavadocNode[size]), 0, this.htmlNodesPtr);
}
}
addSeparator(node);
this.htmlNodes[this.htmlNodesPtr]= node;
this.sourceEnd= node.sourceEnd;
}
private void addSeparator(FormatJavadocNode node) {
// Just append the text
if (++this.separatorsPtr == 0) { // lazy initialization
this.separators= new long[DEFAULT_ARRAY_SIZE];
this.htmlIndexes= new int[DEFAULT_ARRAY_SIZE];
} else { // resize if needed
if (this.separatorsPtr == this.separators.length) {
int size= this.separatorsPtr + DEFAULT_ARRAY_SIZE;
System.arraycopy(this.separators, 0, (this.separators= new long[size]), 0, this.separatorsPtr);
System.arraycopy(this.htmlIndexes, 0, (this.htmlIndexes= new int[size]), 0, this.separatorsPtr);
}
}
this.separators[this.separatorsPtr]= (((long)this.sourceEnd) << 32) + node.sourceStart;
this.htmlIndexes[this.separatorsPtr]= node.isText() ? ((FormatJavadocText)node).htmlTagIndex : -1;
}
void clean() {
int length= this.separators == null ? 0 : this.separators.length;
if (this.separatorsPtr != (length - 1)) {
System.arraycopy(this.separators, 0, this.separators= new long[this.separatorsPtr + 1], 0, this.separatorsPtr + 1);
System.arraycopy(this.htmlIndexes, 0, this.htmlIndexes= new int[this.separatorsPtr + 1], 0, this.separatorsPtr + 1);
}
length= this.htmlNodes == null ? 0 : this.htmlNodes.length;
if (this.htmlNodesPtr != (length - 1)) {
System.arraycopy(this.htmlNodes, 0, this.htmlNodes= new FormatJavadocNode[this.htmlNodesPtr + 1], 0, this.htmlNodesPtr + 1);
for (int i= 0; i <= this.htmlNodesPtr; i++) {
this.htmlNodes[i].clean();
}
}
}
void closeTag() {
this.htmlTagIndex|= JAVADOC_CLOSED_TAG;
}
int getHtmlTagIndex() {
return this.htmlTagIndex & JAVADOC_TAGS_INDEX_MASK;
}
int getHtmlTagID() {
return this.htmlTagIndex & JAVADOC_TAGS_ID_MASK;
}
FormatJavadocNode getLastNode() {
if (this.htmlNodes != null) {
return this.htmlNodes[this.htmlNodesPtr];
}
return null;
}
/**
* Returns whether the text is a closing html tag or not.
*
* @return <code>true</code> if the node is an html tag and has '/' before its name (e.g.
* </bla>), <code>false</code> otherwise.
*/
public boolean isClosingHtmlTag() {
return this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_CLOSED_TAG) != 0;
}
/**
* Returns whether the text is a html tag or not.
*
* @return <code>true</code> if the node is a html tag, <code>false</code> otherwise.
*/
public boolean isHtmlTag() {
return this.htmlTagIndex != -1;
}
/**
* Returns whether the node is an immutable html tag or not.
* <p>
* The text in an immutable tags is <b>never</b> formatted.
* </p>
*
* @return <code>true</code> if the node is an immutable tag, <code>false</code> otherwise.
*/
public boolean isImmutableHtmlTag() {
return this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID;
}
/**
* Returns whether the text is immutable or not.
* <p>
* A text in considered as immutable when it belongs to an immutable block or when it's an
* immutable html tag.
* </p>
*
* @return <code>true</code> if the node is an immutable tag, <code>false</code> otherwise.
*/
public boolean isImmutable() {
return this.immutable || (this.htmlTagIndex != -1 && (this.htmlTagIndex & JAVADOC_TAGS_ID_MASK) == JAVADOC_IMMUTABLE_TAGS_ID);
}
/**
* Returns whether the text at the given separator index position is after a separator tag or
* not.
*
* @return <code>true</code> if the text is after a separator tag, <code>false</code> otherwise
* or if the given index is out the range of the text separators.
*/
public boolean isTextAfterHtmlSeparatorTag(int separatorIndex) {
int ptr= separatorIndex;
if (ptr > this.separatorsPtr)
return false;
int tagIndex= this.htmlIndexes[ptr] & JAVADOC_TAGS_ID_MASK;
return tagIndex != -1 && tagIndex == JAVADOC_SEPARATOR_TAGS_ID;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.formatter.FormatJavadocNode#isText()
*/
public boolean isText() {
return true;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.formatter.FormatJavadocNode#setHeaderLine(int)
*/
void setHeaderLine(int javadocLineStart) {
for (int i= 0; i < this.htmlNodesPtr; i++) {
FormatJavadocNode node= this.htmlNodes[i];
if (!node.isText()) {
((FormatJavadocBlock)node).setHeaderLine(javadocLineStart);
}
}
}
protected void toString(StringBuffer buffer) {
StringBuffer indentation= new StringBuffer();
for (int t= 0; t <= this.depth; t++)
indentation.append('\t');
buffer.append(indentation);
if (isImmutable()) {
buffer.append("immutable "); //$NON-NLS-1$
}
buffer.append("text"); //$NON-NLS-1$
super.toString(buffer);
buffer.append(" ("); //$NON-NLS-1$
buffer.append(this.separatorsPtr + 1).append(" sections, "); //$NON-NLS-1$
buffer.append(this.htmlNodesPtr + 1).append(" html tags, "); //$NON-NLS-1$
buffer.append(this.depth).append(" depth, "); //$NON-NLS-1$
buffer.append(this.linesBefore).append(" before, "); //$NON-NLS-1$
String tagID= "no"; //$NON-NLS-1$
switch (getHtmlTagID()) {
case JAVADOC_TAGS_ID_MASK:
tagID= "mask"; //$NON-NLS-1$
break;
case JAVADOC_SINGLE_BREAK_TAG_ID:
tagID= "single break"; //$NON-NLS-1$
break;
case JAVADOC_CODE_TAGS_ID:
tagID= "code"; //$NON-NLS-1$
break;
case JAVADOC_BREAK_TAGS_ID:
tagID= "break"; //$NON-NLS-1$
break;
case JAVADOC_IMMUTABLE_TAGS_ID:
tagID= "immutable"; //$NON-NLS-1$
break;
case JAVADOC_SEPARATOR_TAGS_ID:
tagID= "separator"; //$NON-NLS-1$
break;
}
buffer.append(tagID).append(" tag id)"); //$NON-NLS-1$
buffer.append('\n');
}
public void toStringDebug(StringBuffer buffer, char[] source) {
if (buffer.length() > 0) {
for (int l= 0; l < this.linesBefore; l++) {
buffer.append('\n');
for (int t= 0; t < this.depth; t++)
buffer.append('\t');
}
}
if (this.separatorsPtr == -1) {
super.toStringDebug(buffer, source);
return;
}
int ptr= 0;
int nextStart= this.sourceStart;
int idx= 0;
while (idx <= this.separatorsPtr || (this.htmlNodesPtr != -1 && ptr <= this.htmlNodesPtr)) {
if (idx > this.separatorsPtr) {
// last node
FormatJavadocNode node= this.htmlNodes[ptr++];
node.toStringDebug(buffer, source);
return;
}
int end= (int)(this.separators[idx] >>> 32);
if (this.htmlNodesPtr >= 0 && ptr <= this.htmlNodesPtr && end > this.htmlNodes[ptr].sourceStart) {
FormatJavadocNode node= this.htmlNodes[ptr++];
node.toStringDebug(buffer, source);
} else {
if (idx > 1 && source[nextStart] != '<') {
buffer.append('\n');
for (int t= 0; t < this.depth; t++)
buffer.append('\t');
}
buffer.append(source, nextStart, end - nextStart + 1);
}
nextStart= (int)this.separators[idx++];
}
if (source[nextStart] == '<') {
switch (getHtmlTagID()) {
case JAVADOC_CODE_TAGS_ID:
buffer.append('\n');
for (int t= 0; t < this.depth; t++)
buffer.append('\t');
break;
}
}
buffer.append(source, nextStart, this.sourceEnd - nextStart + 1);
buffer.append(' ');
}
}