/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.ruta.ide.formatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.antlr.runtime.CommonToken;
import org.apache.uima.ruta.ide.parser.ast.ActionFactory;
import org.apache.uima.ruta.ide.parser.ast.ComposedRuleElement;
import org.apache.uima.ruta.ide.parser.ast.ConditionFactory;
import org.apache.uima.ruta.ide.parser.ast.RutaAbstractDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaAction;
import org.apache.uima.ruta.ide.parser.ast.RutaBinaryArithmeticExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaBlock;
import org.apache.uima.ruta.ide.parser.ast.RutaBooleanNumberExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaCondition;
import org.apache.uima.ruta.ide.parser.ast.RutaConditionConstants;
import org.apache.uima.ruta.ide.parser.ast.RutaDeclarationsStatement;
import org.apache.uima.ruta.ide.parser.ast.RutaDeclareDeclarationsStatement;
import org.apache.uima.ruta.ide.parser.ast.RutaExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaFeatureDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaListExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaLogAction;
import org.apache.uima.ruta.ide.parser.ast.RutaPackageDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaQuantifierLiteralExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaRegExpRule;
import org.apache.uima.ruta.ide.parser.ast.RutaRule;
import org.apache.uima.ruta.ide.parser.ast.RutaRuleElement;
import org.apache.uima.ruta.ide.parser.ast.RutaStringExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaStructureAction;
import org.apache.uima.ruta.ide.parser.ast.RutaTypeConstants;
import org.apache.uima.ruta.ide.parser.ast.RutaTypeDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaVariableReference;
import org.eclipse.dltk.ast.ASTListNode;
import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.declarations.Declaration;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.expressions.StringLiteral;
import org.eclipse.dltk.ast.statements.Block;
import org.eclipse.dltk.ast.statements.Statement;
import org.eclipse.dltk.formatter.FormatterDocument;
import org.eclipse.dltk.formatter.IFormatterIndentGenerator;
/**
* Formats a document.<br>
* Use the append methods within the visit methods to preserve the comments.
*
*
*/
public class RutaFormattedPrinter extends ASTVisitor {
private FormatterDocument document;
private String lineDelimiter;
private static final String SEMI = ";";
private static final String CONCAT = " + ";
private static final String CONCAT_RULES = "% ";
private static final String COMMA = ",";
private static final int NL_DECLS_COUNT = 2;
private static final String CURLY_OPEN = "{";
private static final String CURLY_CLOSE = "}";
private static final String BRACK_OPEN = "[";
private static final String BRACK_CLOSE = "]";
private static final String THEN = "->";
private static final String PAR_OPEN = "(";
private static final String PAR_CLOSE = ")";
private static final String EQUALS = " = ";
private IFormatterIndentGenerator indentGenerator;
private StringBuilder output;
private List<CommonToken> comments;
private Iterator<CommonToken> iterator;
private CommonToken currentComment;
private int indentLevel = 0;
private int lines_before_long_declarations;
private int maxLineLength;
private boolean inBlockDeclaration = false;
private Map<Integer, Object> lastStatements = new HashMap<Integer, Object>();
private int commentLineSince = 0;
// hotfix: 0 = false, 1 = first rule element, 3 = not first rule element
private int inLargeRule = 0;
private boolean retainLB = true;
public RutaFormattedPrinter(FormatterDocument document, String lineDelimiter,
IFormatterIndentGenerator indentGenerator, List<CommonToken> comments, RutaFormatter tmf) {
this.document = document;
this.lineDelimiter = lineDelimiter;
this.indentGenerator = indentGenerator;
this.output = new StringBuilder();
// read format preferences
this.lines_before_long_declarations = tmf
.getInt(RutaFormatterConstants.LINES_BEFORE_LONG_DECLARATIONS);
this.maxLineLength = tmf.getInt(RutaFormatterConstants.MAX_LINE_LENGTH);
// comments
this.comments = comments == null ? new ArrayList<CommonToken>() : comments;
iterator = this.comments.iterator();
this.currentComment = iterator.hasNext() ? iterator.next() : null;
}
public String getOutput() {
appendLeftComments();
return this.output.toString();
}
@Override
public boolean visit(Statement s) throws Exception {
appendComments(s);
fillNewLines(s);
if (s instanceof RutaDeclarationsStatement) {
// append new lines before LONG DECLARATIONS
RutaDeclarationsStatement decls = (RutaDeclarationsStatement) s;
// if (decls.getDeclarationsCount() > NL_DECLS_COUNT) {
// for (int i = 0; i < lines_before_long_declarations; i++) {
// appendNewLine();
// }
// }
// format declarations:
// print type token
appendIntoNewLine(document.get(decls.getTypeTokenStart(), decls.getTypeTokenEnd()) + " ");
// print parent if available
if (s instanceof RutaDeclareDeclarationsStatement) {
RutaDeclareDeclarationsStatement dds = (RutaDeclareDeclarationsStatement) s;
ASTNode p = dds.getParent();
if (p != null) {
append(p);
append(" ");
}
}
// print identifiers
List<RutaAbstractDeclaration> declarations = decls.getDeclarations();
traverseAstNodes(declarations);
// print init expr
if (decls.getInitExpr() != null) {
append(EQUALS);
decls.getInitExpr().traverse(this);
}
appendStatementEnd();
return false;
}
if (s instanceof RutaRegExpRule) {
// traverse into container RutaRule to format RuleElements
if (!inBlockDeclaration) {
appendNewLine();
}
// Rules always just consists of RuleElements: whitespace separation
if (s.sourceEnd() - s.sourceStart() > 2 * maxLineLength) {
inLargeRule = 1;
indentLevel++;
}
RutaRule rule = (RutaRule) s;
List<Expression> expressions = rule.getExpressions();
if (expressions != null && !expressions.isEmpty()) {
append(expressions.get(0));
append(" " + THEN + " ");
if (expressions.size() > 1) {
for (int i = 1; i < expressions.size(); i++) {
Expression expression = expressions.get(i);
if (expression.getKind() == RutaTypeConstants.RUTA_TYPE_N && i < expressions.size() - 1) {
append(expression);
append(EQUALS);
append(expressions.get(++i));
} else {
append(expression);
}
if (i < expressions.size() - 1) {
append(COMMA + " ");
}
}
}
}
if (!inBlockDeclaration) {
appendStatementEnd();
}
if (inLargeRule > 0) {
indentLevel--;
inLargeRule = 0;
}
return false;
}
if (s instanceof RutaRule) {
// traverse into container RutaRule to format RuleElements
if (!inBlockDeclaration) {
appendNewLine();
}
// Rules always just consists of RuleElements: whitespace separation
if (s.sourceEnd() - s.sourceStart() > 2 * maxLineLength) {
inLargeRule = 1;
indentLevel++;
}
RutaRule rule = (RutaRule) s;
List<Expression> expressions = rule.getExpressions();
String sep = "";
traverseAstNodes(expressions, sep);
if (!inBlockDeclaration) {
appendStatementEnd();
}
if (inLargeRule > 0) {
indentLevel--;
inLargeRule = 0;
}
return false;
// return true;
}
if (s instanceof RutaTypeDeclaration) {
RutaTypeDeclaration rtd = (RutaTypeDeclaration) s;
append(document.get(rtd.getNameStart(), rtd.getNameEnd()));
List<RutaFeatureDeclaration> features = ((RutaTypeDeclaration) s).getFeatures();
if (features != null && !features.isEmpty()) {
append(PAR_OPEN);
for (RutaFeatureDeclaration each : features) {
append(each.getType());
append(" ");
append(each.getName());
if (features.indexOf(each) < features.size() - 1) {
append(COMMA + " ");
}
}
append(PAR_CLOSE);
}
return false;
}
if (s instanceof Declaration && !(s instanceof RutaPackageDeclaration)) {
append(s);
return false;
}
if (s instanceof RutaPackageDeclaration) {
append(s);
appendStatementEnd();
return false;
}
// append SEMIs for all other statements
appendIntoNewLine(s);
appendStatementEnd();
return false;
}
private void fillNewLines(Object s) {
Object last = lastStatements.get(indentLevel);
// if (last == null && indentLevel > 0) {
// last = lastStatements.get(indentLevel - 1);
// }
if (last != null && retainLB) {
int start = 0;
int end = 0;
if (s instanceof Statement) {
end = ((ASTNode) s).sourceStart();
} else if (s instanceof CommonToken) {
end = ((CommonToken) s).getStartIndex();
}
if (last instanceof Statement) {
start = ((ASTNode) last).sourceEnd() + 1;
} else if (last instanceof CommonToken) {
start = ((CommonToken) last).getStopIndex();
}
if (start < end) {
String string = document.get(start, end);
String replaceAll = string.replaceAll(lineDelimiter, "");
double d = (string.length() - replaceAll.length()) / lineDelimiter.length()
- commentLineSince;
if (s instanceof CommonToken && commentLineSince == 0) {
d++;
}
for (int i = 1; i < d; i++) {
appendNewLine();
}
if (d < 2 && s instanceof RutaDeclarationsStatement && !(last instanceof Declaration)) {
appendNewLine();
}
commentLineSince = 0;
}
} else if (inBlockDeclaration || s instanceof CommonToken) {
appendNewLine();
}
lastStatements.put(indentLevel, s);
}
@Override
public boolean endvisit(Statement s) throws Exception {
// if (s instanceof RutaRule) {
// append(SEMI);
// return true;
// }
return super.endvisit(s);
}
@Override
public boolean visit(Expression s) throws Exception {
// traverse Block (first child of root element:
if (s instanceof Block) {
return true;
}
if (s instanceof ComposedRuleElement) {
ComposedRuleElement cre = (ComposedRuleElement) s;
List<Expression> elements = cre.getElements();
// int length = cre.sourceEnd() - cre.sourceStart();
if (inLargeRule == 2) {
inLargeRule = 4;
}
if(cre.isAfterConcat()) {
append(CONCAT_RULES);
}
append(PAR_OPEN);
String sep = "";
if (cre.isDisjunctive() != null) {
if (cre.isDisjunctive()) {
sep = " |";
} else {
sep = " &";
}
}
traverseAstNodes(elements, sep);
append(PAR_CLOSE);
appendRuleElement(cre);
if (inLargeRule == 4) {
inLargeRule = 1;
}
return false;
}
// special format for RuleElements:
if (s instanceof RutaRuleElement) {
RutaRuleElement ruleEl = (RutaRuleElement) s;
if (inLargeRule == 2) {
appendNewLine();
} else if (inLargeRule == 1) {
inLargeRule = 2;
}
if(ruleEl.isAfterConcat()) {
append(CONCAT_RULES);
}
appendRuleElement(ruleEl);
return false;
}
// special format for actions
if (s instanceof RutaAction) {
RutaAction a = (RutaAction) s;
String name = document.get(a.getNameStart(), a.getNameEnd());
append(name);
List<? extends ASTNode> childs = a.getChilds();
if (childs != null && !childs.isEmpty()) {
boolean addPar = !a.getName().equals(ActionFactory.IMPLICIT);
if (addPar) {
append(PAR_OPEN);
}
// special format for create
if (a instanceof RutaStructureAction) {
if (name.equals("TRIE")) {
printStructureAction2(a);
} else {
printStructureAction(a);
}
} else {
traverseAstNodes(childs);
}
// special format for log
if (a instanceof RutaLogAction && ((RutaLogAction) a).isLogLevelAssigned()) {
appendSeparator(COMMA);
RutaLogAction logAction = (RutaLogAction) a;
append(logAction.getLogLevelStart(), logAction.getLogLevelEnd());
}
if (addPar) {
append(PAR_CLOSE);
}
}
return false;
}
// special format for conditions
if (s instanceof RutaCondition) {
RutaCondition c = (RutaCondition) s;
append(document.get(c.getNameStart(), c.getNameEnd()));
List<? extends ASTNode> childs = c.getChilds();
// minus is a condition without parameter parantheses:
boolean addPar = !c.getName().equals(ConditionFactory.IMPLICIT)
&& s.getKind() != RutaConditionConstants.COND_MINUS && childs != null
&& !childs.isEmpty();
if (addPar) {
append(PAR_OPEN);
}
traverseAstNodes(childs);
if (addPar) {
append(PAR_CLOSE);
}
return false;
}
// special format for boolean number expressions
if (s instanceof RutaBooleanNumberExpression) {
RutaBooleanNumberExpression tmbne = (RutaBooleanNumberExpression) s;
append(PAR_OPEN);
if (tmbne.getE1() != null) {
tmbne.getE1().traverse(this);
}
append(tmbne.getOperator());
if (tmbne.getE2() != null) {
tmbne.getE2().traverse(this);
}
append(PAR_CLOSE);
return false;
}
// special format for string expressions
if (s instanceof RutaStringExpression && ((RutaExpression) s).getExpression() != null) {
RutaStringExpression tmse = (RutaStringExpression) s;
List<?> childs = tmse.getExpression().getChilds();
Object object2 = childs.get(0);
if (object2 instanceof ASTNode) {
ASTNode astnode = (ASTNode) object2;
List<?> childs2 = astnode.getChilds();
for (Object object : childs2) {
if (object instanceof RutaExpression) {
RutaExpression expr = (RutaExpression) object;
// if (expr.isInParantheses()) {
// append(PAR_OPEN);
// append(expr);
// append(PAR_CLOSE);
// } else {
append(expr);
// }
} else if (object instanceof StringLiteral) {
StringLiteral sl = (StringLiteral) object;
String value = sl.getValue();
append(value);
} else if (object instanceof RutaVariableReference) {
RutaVariableReference vr = (RutaVariableReference) object;
append(vr.getName());
}
if (childs2.indexOf(object) < childs2.size() - 1) {
append(CONCAT);
}
}
} else {
append(s);
}
return false;
}
if (s instanceof RutaListExpression) {
RutaListExpression le = (RutaListExpression) s;
append(CURLY_OPEN);
ASTListNode exprs = le.getExprs();
traverseAstNodes(exprs.getChilds());
append(CURLY_CLOSE);
return false;
}
// special format for paranthesed expressions: (expression)
// if (s instanceof RutaExpression && ((RutaExpression) s).isInParantheses()) {
// append(PAR_OPEN);
// append(s);
// append(PAR_CLOSE);
// return false;
// }
if (s instanceof RutaBinaryArithmeticExpression) {
RutaBinaryArithmeticExpression ba = (RutaBinaryArithmeticExpression) s;
String operator = ba.getOperator();
append(operator);
append(PAR_OPEN);
traverseAstNodes(ba.getChilds());
append(PAR_CLOSE);
}
append(s);
return false;
}
/**
* structure actions like CREATE, FILL with assignments.
*
* @param a
*/
private void printStructureAction(RutaAction a) {
RutaStructureAction tmca = (RutaStructureAction) a;
// structure
if (tmca.getStructure() != null) {
append(tmca.getStructure());
}
append(COMMA);
append(" ");
// number expressions
List<Expression> indices = tmca.getExpressions();
if (indices != null) {
traverseAstNodes(indices);
if (!indices.isEmpty()) {
append(COMMA);
append(" ");
}
}
// assignments
Map<Expression, Expression> assignments = tmca.getAssignments();
Iterator it = assignments.entrySet().iterator();
while (it.hasNext()) {
if (assignments.size() > 3) {
appendNewLineAndIndent();
}
Map.Entry pairs = (Map.Entry) it.next();
try {
((Expression) pairs.getKey()).traverse(this);
} catch (Exception e) {
e.printStackTrace();
}
append(EQUALS);
try {
((Expression) pairs.getValue()).traverse(this);
} catch (Exception e) {
e.printStackTrace();
}
if (it.hasNext()) {
output.append(COMMA);
append(" ");
}
}
}
private void printStructureAction2(RutaAction a) {
RutaStructureAction tmca = (RutaStructureAction) a;
Map<Expression, Expression> assignments = tmca.getAssignments();
Iterator it = assignments.entrySet().iterator();
while (it.hasNext()) {
if (assignments.size() > 3) {
appendNewLineAndIndent();
}
Map.Entry pairs = (Map.Entry) it.next();
try {
((Expression) pairs.getKey()).traverse(this);
} catch (Exception e) {
e.printStackTrace();
}
append(EQUALS);
try {
((Expression) pairs.getValue()).traverse(this);
} catch (Exception e) {
e.printStackTrace();
}
output.append(COMMA);
append(" ");
}
// structure
if (tmca.getStructure() != null) {
append(tmca.getStructure());
}
append(COMMA);
append(" ");
// number expressions
List<Expression> indices = tmca.getExpressions();
if (indices != null) {
traverseAstNodes(indices);
}
// assignments
}
@Override
public boolean endvisit(Expression s) throws Exception {
return super.endvisit(s);
}
/**
* @param ruleEl
* @param conditions
* @param actions
* @throws Exception
*/
private void appendRuleElement(RutaRuleElement ruleEl) throws Exception {
// if (ruleEl instanceof ComposedRuleElement) {
// ComposedRuleElement cre = (ComposedRuleElement) ruleEl;
// List<Expression> elements = cre.getElements();
// append(PAR_OPEN);
// for (Expression expression : elements) {
//
// if (expression instanceof RutaRuleElement) {
// RutaRuleElement re = (RutaRuleElement) expression;
// appendRuleElement(re);
// }
// if (elements.indexOf(expression) < elements.size() - 1) {
// append(" ");
// }
//
// }
// append(PAR_CLOSE);
// } else
if (ruleEl.getHead() != null) {
append(ruleEl.getHead());
}
if(ruleEl.isWildcard()) {
append("#");
}
List<RutaCondition> conditions = ruleEl.getConditions();
List<RutaAction> actions = ruleEl.getActions();
// don't print {->} for empty rule elements
// print Quantifiers
List<? extends ASTNode> quantifierExpressions = ruleEl.getQuantifierExpressions();
if (quantifierExpressions != null && !quantifierExpressions.isEmpty()) {
if (quantifierExpressions.size() == 1) {
ASTNode astNode = quantifierExpressions.get(0);
if (astNode instanceof RutaQuantifierLiteralExpression) {
append(astNode);
} else {
append(BRACK_OPEN);
append(astNode);
append(BRACK_CLOSE);
}
} else if (quantifierExpressions.size() == 2) {
if (quantifierExpressions.get(1) instanceof RutaQuantifierLiteralExpression) {
append(BRACK_OPEN);
append(quantifierExpressions.get(0));
append(BRACK_CLOSE);
append(quantifierExpressions.get(1));
} else {
append(BRACK_OPEN);
append(quantifierExpressions.get(0));
append(COMMA + " ");
append(quantifierExpressions.get(1));
append(BRACK_CLOSE);
}
} else if (quantifierExpressions.size() == 3) {
append(BRACK_OPEN);
append(quantifierExpressions.get(0));
append(COMMA + " ");
append(quantifierExpressions.get(1));
append(BRACK_CLOSE);
append(quantifierExpressions.get(2));
}
}
if (!inBlockDeclaration && conditions == null && actions == null) {
return;
}
if (!inBlockDeclaration
&& ((conditions == null && actions.isEmpty()) || actions == null
&& (conditions != null) && conditions.isEmpty())) {
return;
}
append(CURLY_OPEN);
// print Conditions
if (conditions != null && !conditions.isEmpty()) {
traverseAstNodes(conditions);
}
if (conditions != null && !conditions.isEmpty()) {
}
// print Actions
if (actions != null && !actions.isEmpty()) {
if (conditions != null && !conditions.isEmpty()) {
append(" " + THEN + " ");
} else {
append(THEN + " ");
}
traverseAstNodes(actions);
}
append(CURLY_CLOSE);
if(ruleEl.getInlinedRules()!= null && !ruleEl.getInlinedRules().isEmpty()) {
String inlineMode = ruleEl.getInlineMode();
append(inlineMode);
append(CURLY_OPEN);
indentLevel++;
List<RutaRule> inlinedRules = ruleEl.getInlinedRules();
for (RutaRule rutaRule : inlinedRules) {
visit(rutaRule);
}
indentLevel--;
appendIntoNewLine(CURLY_CLOSE);
}
}
/**
* @param astnodes
*/
@SuppressWarnings("unchecked")
private void traverseAstNodes(List<? extends ASTNode> astnodes) {
traverseAstNodes(astnodes, COMMA);
}
/**
* @param astnodes
*/
@SuppressWarnings("unchecked")
private void traverseAstNodes(List<? extends ASTNode> astnodes, String separator) {
if (astnodes == null) {
return;
}
Iterator iterator2 = astnodes.iterator();
while (iterator2.hasNext()) {
ASTNode node = (ASTNode) iterator2.next();
try {
node.traverse(this);
} catch (Exception e) {
e.printStackTrace();
}
if (iterator2.hasNext()) {
appendSeparator(separator);
}
}
}
private void appendSeparator(String separator) {
output.append(separator);
append(" ");
}
@Override
public boolean visit(MethodDeclaration s) throws Exception {
appendComments(s);
fillNewLines(s);
// Statement last = lastStatements.get(indentLevel);
// // if (last == null && indentLevel > 0) {
// // last = lastStatements.get(indentLevel - 1);
// // }
// if (last != null && retainLB) {
// int start = last.sourceEnd() + 1;
// int end = s.sourceStart();
// if (start < end) {
// String string = document.get(start, end);
// String replaceAll = string.replaceAll(lineDelimiter, "");
// double d = (string.length() - replaceAll.length()) / lineDelimiter.length()
// - commentLineSince;
// for (int i = 1; i < d; i++) {
// appendNewLine();
// }
// commentLineSince = 0;
// }
// }
if (s instanceof RutaBlock) {
RutaBlock b = (RutaBlock) s;
appendIntoNewLine("BLOCK(");
append(b.getName());
append(") ");
this.inBlockDeclaration = true;
if (b.getRule() != null) {
b.getRule().traverse(this);
}
this.inBlockDeclaration = false;
append(" {");
indentLevel++;
b.getBody().traverse(this);
lastStatements.put(indentLevel, null);
indentLevel--;
lastStatements.put(indentLevel, s);
appendIntoNewLine("}");
appendNewLine();
return false;
}
return super.visit(s);
}
@Override
public boolean visit(ModuleDeclaration s) throws Exception {
return true;
}
@Override
public boolean visit(TypeDeclaration s) throws Exception {
return super.visit(s);
}
@Override
public boolean visitGeneral(ASTNode node) throws Exception {
return super.visitGeneral(node);
}
private void append(int begin, int end) {
append(document.get(begin, end));
}
private void append(String string) {
if (outputPosInLine() + string.length() > maxLineLength) {
appendNewLine();
indentGenerator.generateIndent(1, output);
}
output.append(string);
}
private void appendIntoNewLine(String string) {
appendNewLine();
output.append(string);
}
private void append(ASTNode s) {
appendComments(s);
// this.output.
append(document.get(s.sourceStart(), s.sourceEnd()));
}
private void appendIntoNewLine(ASTNode s) {
appendComments(s);
appendNewLine();
append(s);
}
private void appendNewLine() {
output.append(lineDelimiter);
indentGenerator.generateIndent(indentLevel, output);
}
private void appendNewLineAndIndent() {
output.append(lineDelimiter);
indentGenerator.generateIndent(indentLevel + 1, output);
}
private void appendStatementEnd() {
output.append(SEMI);
}
/**
* @param s
* @return
*/
private int appendComments(ASTNode s) {
return appendComments(s.sourceStart());
}
/**
* @param start
* @return
*/
private int appendComments(int start) {
while (currentComment != null && currentComment.getStartIndex() < start) {
String text = currentComment.getText().trim();
fillNewLines(currentComment);
append("" + text);
currentComment = iterator.hasNext() ? iterator.next() : null;
commentLineSince++;
}
return start;
}
private void appendLeftComments() {
while (currentComment != null) {
append(currentComment.getText());
currentComment = iterator.hasNext() ? iterator.next() : null;
}
}
private int outputPosInLine() {
String out = output.toString();
int lastIndexOf = out.lastIndexOf("\n");
return out.length() - lastIndexOf;
}
}