mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-06-06 17:26:01 +02:00
Code Issues Wiki Activity

Use StringBuilder

Browse source
This commit is contained in:
Anton Leherbauer 2008-05-15 08:53:15 +00:00
parent fec33bb137
commit 5f53601812
5 changed files with 109 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/actions/IndentAction.java
View file

@ -66,8 +66,8 @@ public class IndentAction extends TextEditorAction {
/** The caret offset after an indent operation. */ /** The caret offset after an indent operation. */
private int fCaretOffset; private int fCaretOffset;
/** /**
* Whether this is the action invoked by TAB. When <code>true</code>, indentation behaves * Whether this is the action invoked by TAB. When <code>true</code>, indentation behaves
* differently to accommodate normal TAB operation. * differently to accommodate normal TAB operation.
*/ */
private final boolean fIsTabAction; private final boolean fIsTabAction;
@ -174,8 +174,8 @@ public class IndentAction extends TextEditorAction {
* @param newLength the selection range * @param newLength the selection range
*/ */
private void selectAndReveal(int newOffset, int newLength) { private void selectAndReveal(int newOffset, int newLength) {
Assert.isTrue(newOffset >= 0); Assert.isTrue(newOffset >= 0);
Assert.isTrue(newLength >= 0); Assert.isTrue(newLength >= 0);
ITextEditor editor= getTextEditor(); ITextEditor editor= getTextEditor();
if (editor instanceof CEditor) { if (editor instanceof CEditor) {
ISourceViewer viewer= ((CEditor)editor).getViewer(); ISourceViewer viewer= ((CEditor)editor).getViewer();
@ -188,7 +188,7 @@ public class IndentAction extends TextEditorAction {
} }
/** /**
* Indents a single line using the heuristic scanner. Multiline comments are * Indents a single line using the heuristic scanner. Multiline comments are
* indented as specified by the <code>CCommentAutoIndentStrategy</code>. * indented as specified by the <code>CCommentAutoIndentStrategy</code>.
* *
* @param document the document * @param document the document
@ -196,9 +196,9 @@ public class IndentAction extends TextEditorAction {
* @param caret the caret position * @param caret the caret position
* @param indenter the indenter * @param indenter the indenter
* @param scanner the heuristic scanner * @param scanner the heuristic scanner
* @param multiLine <code>true</code> if more than one line is being indented * @param multiLine <code>true</code> if more than one line is being indented
* @return <code>true</code> if <code>document</code> was modified, <code>false</code> otherwise * @return <code>true</code> if <code>document</code> was modified, <code>false</code> otherwise
* @throws BadLocationException if the document got changed concurrently * @throws BadLocationException if the document got changed concurrently
*/ */
private boolean indentLine(IDocument document, int line, int caret, CIndenter indenter, CHeuristicScanner scanner, boolean multiLine) throws BadLocationException { private boolean indentLine(IDocument document, int line, int caret, CIndenter indenter, CHeuristicScanner scanner, boolean multiLine) throws BadLocationException {
IRegion currentLine= document.getLineInformation(line); IRegion currentLine= document.getLineInformation(line);
@ -224,9 +224,9 @@ public class IndentAction extends TextEditorAction {
wsStart= offset + slashes; wsStart= offset + slashes;
StringBuffer computed= indenter.computeIndentation(offset); StringBuilder computed= indenter.computeIndentation(offset);
if (computed == null) if (computed == null)
computed= new StringBuffer(0); computed= new StringBuilder(0);
int tabSize= getTabSize(); int tabSize= getTabSize();
while (slashes > 0 && computed.length() > 0) { while (slashes > 0 && computed.length() > 0) {
char c= computed.charAt(0); char c= computed.charAt(0);
@ -251,7 +251,7 @@ public class IndentAction extends TextEditorAction {
// standard C code indentation // standard C code indentation
if (indent == null) { if (indent == null) {
StringBuffer computed= indenter.computeIndentation(offset); StringBuilder computed= indenter.computeIndentation(offset);
if (computed != null) if (computed != null)
indent= computed.toString(); indent= computed.toString();
else else
@ -324,7 +324,7 @@ public class IndentAction extends TextEditorAction {
/** /**
* Returns the size in characters of a string. All characters count one, tabs count the editor's * Returns the size in characters of a string. All characters count one, tabs count the editor's
* preference for the tab display * preference for the tab display
* *
* @param indent the string to be measured. * @param indent the string to be measured.
* @return the size in characters of a string * @return the size in characters of a string
@ -459,7 +459,7 @@ public class IndentAction extends TextEditorAction {
} }
/** /**
* Returns if the current selection is valid, i.e. whether it is empty and the caret in the * Returns if the current selection is valid, i.e. whether it is empty and the caret in the
* whitespace at the start of a line, or covers multiple lines. * whitespace at the start of a line, or covers multiple lines.
* *
* @return <code>true</code> if the selection is valid for an indent operation * @return <code>true</code> if the selection is valid for an indent operation
@ -484,7 +484,7 @@ public class IndentAction extends TextEditorAction {
// or the selection has to extend over multiple lines // or the selection has to extend over multiple lines
if (length == 0) { if (length == 0) {
return document.get(lineOffset, offset - lineOffset).trim().length() == 0; return document.get(lineOffset, offset - lineOffset).trim().length() == 0;
} }
// return lineOffset + firstLine.getLength() < offset + length; // return lineOffset + firstLine.getLength() < offset + length;
return false; // only enable for empty selections for now return false; // only enable for empty selections for now
} catch (BadLocationException e) { } catch (BadLocationException e) {
@ -508,7 +508,7 @@ public class IndentAction extends TextEditorAction {
} }
/** /**
* Returns the document currently displayed in the editor, or <code>null</code> if none can be * Returns the document currently displayed in the editor, or <code>null</code> if none can be
* obtained. * obtained.
* *
* @return the current document or <code>null</code> * @return the current document or <code>null</code>

34
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/editor/IndentUtil.java
View file

@ -181,10 +181,10 @@ public final class IndentUtil {
boolean indentInsideLineComments= indentInsideLineComments(project); boolean indentInsideLineComments= indentInsideLineComments(project);
String current= getCurrentIndent(document, lines.getStartLine(), indentInsideLineComments); String current= getCurrentIndent(document, lines.getStartLine(), indentInsideLineComments);
StringBuffer correct= new StringBuffer(computeIndent(document, lines.getStartLine(), indenter, scanner)); StringBuilder correct= new StringBuilder(computeIndent(document, lines.getStartLine(), indenter, scanner));
int tabSize= CodeFormatterUtil.getTabWidth(project); int tabSize= CodeFormatterUtil.getTabWidth(project);
StringBuffer addition= new StringBuffer(); StringBuilder addition= new StringBuilder();
int difference= subtractIndent(correct, current, addition, tabSize); int difference= subtractIndent(correct, current, addition, tabSize);
if (difference == 0) if (difference == 0)
@ -248,7 +248,7 @@ public final class IndentUtil {
* @param shiftWidth * @param shiftWidth
* @param tabWidth * @param tabWidth
* @return number of characters deleted * @return number of characters deleted
* @throws BadLocationException * @throws BadLocationException
*/ */
public static int cutIndent(IDocument document, int line, int shiftWidth, int tabWidth) throws BadLocationException { public static int cutIndent(IDocument document, int line, int shiftWidth, int tabWidth) throws BadLocationException {
return cutIndent(document, line, shiftWidth, tabWidth, new boolean[1], 0, false); return cutIndent(document, line, shiftWidth, tabWidth, new boolean[1], 0, false);
@ -308,7 +308,7 @@ public final class IndentUtil {
* @param difference a string buffer - if the return value is positive, it will be cleared and set to the substring of <code>current</code> of that length * @param difference a string buffer - if the return value is positive, it will be cleared and set to the substring of <code>current</code> of that length
* @return the difference in lenght of <code>correct</code> and <code>current</code> * @return the difference in lenght of <code>correct</code> and <code>current</code>
*/ */
private static int subtractIndent(CharSequence correct, CharSequence current, StringBuffer difference, int tabSize) { private static int subtractIndent(CharSequence correct, CharSequence current, StringBuilder difference, int tabSize) {
int c1= computeVisualLength(correct, tabSize); int c1= computeVisualLength(correct, tabSize);
int c2= computeVisualLength(current, tabSize); int c2= computeVisualLength(current, tabSize);
int diff= c1 - c2; int diff= c1 - c2;
@ -418,7 +418,7 @@ public final class IndentUtil {
} }
/** /**
* Indents a single line using the heuristic scanner. Multiline comments are * Indents a single line using the heuristic scanner. Multiline comments are
* indented as specified by the <code>CCommentAutoIndentStrategy</code>. * indented as specified by the <code>CCommentAutoIndentStrategy</code>.
* *
* @param document the document * @param document the document
@ -448,13 +448,13 @@ public final class IndentUtil {
} else if (startingPartition.getType().equals(ICPartitions.C_PREPROCESSOR)) { } else if (startingPartition.getType().equals(ICPartitions.C_PREPROCESSOR)) {
indent= computePreprocessorIndent(document, line, startingPartition); indent= computePreprocessorIndent(document, line, startingPartition);
} else if (!commentLines[lineIndex] && startingPartition.getOffset() == offset && startingPartition.getType().equals(ICPartitions.C_SINGLE_LINE_COMMENT)) { } else if (!commentLines[lineIndex] && startingPartition.getOffset() == offset && startingPartition.getType().equals(ICPartitions.C_SINGLE_LINE_COMMENT)) {
return false; return false;
} }
} }
// standard C code indentation // standard C code indentation
if (indent == null) { if (indent == null) {
StringBuffer computed= indenter.computeIndentation(offset); StringBuilder computed= indenter.computeIndentation(offset);
if (computed != null) if (computed != null)
indent= computed.toString(); indent= computed.toString();
else else
@ -517,7 +517,7 @@ public final class IndentUtil {
// standard C code indentation // standard C code indentation
if (indent == null) { if (indent == null) {
StringBuffer computed= indenter.computeIndentation(offset); StringBuilder computed= indenter.computeIndentation(offset);
if (computed != null) if (computed != null)
indent= computed.toString(); indent= computed.toString();
else else
@ -559,7 +559,7 @@ public final class IndentUtil {
int previousLineLength= previousLine.getLength(); int previousLineLength= previousLine.getLength();
int previousLineEnd= previousLineStart + previousLineLength; int previousLineEnd= previousLineStart + previousLineLength;
StringBuffer buf= new StringBuffer(); StringBuilder buf= new StringBuilder();
int previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd); int previousLineNonWS= scanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
if (previousLineNonWS == CHeuristicScanner.NOT_FOUND || document.getChar(previousLineNonWS) != '*') { if (previousLineNonWS == CHeuristicScanner.NOT_FOUND || document.getChar(previousLineNonWS) != '*') {
// align with the comment start if the previous line is not an asterix line // align with the comment start if the previous line is not an asterix line
@ -571,7 +571,7 @@ public final class IndentUtil {
if (previousLineNonWS == CHeuristicScanner.NOT_FOUND) if (previousLineNonWS == CHeuristicScanner.NOT_FOUND)
previousLineNonWS= previousLineEnd; previousLineNonWS= previousLineEnd;
// add the initial space // add the initial space
// TODO this may be controlled by a formatter preference in the future // TODO this may be controlled by a formatter preference in the future
buf.append(' '); buf.append(' ');
} }
@ -598,9 +598,9 @@ public final class IndentUtil {
CHeuristicScanner ppScanner= new CHeuristicScanner(document, ICPartitions.C_PARTITIONING, partition.getType()); CHeuristicScanner ppScanner= new CHeuristicScanner(document, ICPartitions.C_PARTITIONING, partition.getType());
CIndenter ppIndenter= new CIndenter(document, ppScanner); CIndenter ppIndenter= new CIndenter(document, ppScanner);
if (line == ppFirstLine + 1) { if (line == ppFirstLine + 1) {
return ppIndenter.createReusingIndent(new StringBuffer(), 1).toString(); return ppIndenter.createReusingIndent(new StringBuilder(), 1).toString();
} }
StringBuffer computed= ppIndenter.computeIndentation(document.getLineOffset(line), false); StringBuilder computed= ppIndenter.computeIndentation(document.getLineOffset(line), false);
if (computed != null) { if (computed != null) {
return computed.toString(); return computed.toString();
} }
@ -612,7 +612,7 @@ public final class IndentUtil {
int previousLineNonWS= ppScanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd); int previousLineNonWS= ppScanner.findNonWhitespaceForwardInAnyPartition(previousLineStart, previousLineEnd);
String previousIndent= document.get(previousLineStart, previousLineNonWS - previousLineStart); String previousIndent= document.get(previousLineStart, previousLineNonWS - previousLineStart);
computed= new StringBuffer(previousIndent); computed= new StringBuilder(previousIndent);
return computed.toString(); return computed.toString();
} }
@ -628,7 +628,7 @@ public final class IndentUtil {
if (column > displayedWidth) { if (column > displayedWidth) {
return prefix; return prefix;
} }
final StringBuffer buffer = new StringBuffer(prefix); final StringBuilder buffer = new StringBuilder(prefix);
appendIndent(buffer, displayedWidth, tabWidth, useSpaces, column); appendIndent(buffer, displayedWidth, tabWidth, useSpaces, column);
return buffer.toString(); return buffer.toString();
} }
@ -640,9 +640,9 @@ public final class IndentUtil {
* @param tabWidth the configured tab width * @param tabWidth the configured tab width
* @param useSpaces whether tabs should be substituted by spaces * @param useSpaces whether tabs should be substituted by spaces
* @param startColumn the column where to start measurement * @param startColumn the column where to start measurement
* @return StringBuffer * @return StringBuilder
*/ */
private static StringBuffer appendIndent(StringBuffer buffer, int width, int tabWidth, boolean useSpaces, int startColumn) { private static StringBuilder appendIndent(StringBuilder buffer, int width, int tabWidth, boolean useSpaces, int startColumn) {
assert tabWidth > 0; assert tabWidth > 0;
int tabStop = startColumn - startColumn % tabWidth; int tabStop = startColumn - startColumn % tabWidth;
int tabs = useSpaces ? 0 : (width-tabStop) / tabWidth; int tabs = useSpaces ? 0 : (width-tabStop) / tabWidth;

116
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/text/CAutoIndentStrategy.java
View file

@ -49,15 +49,15 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
private static final String LINE_COMMENT= "//"; //$NON-NLS-1$ private static final String LINE_COMMENT= "//"; //$NON-NLS-1$
// private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration(); // private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();
private static class CompilationUnitInfo { // private static class CompilationUnitInfo {
char[] buffer; // char[] buffer;
int delta; // int delta;
//
CompilationUnitInfo(char[] buffer, int delta) { // CompilationUnitInfo(char[] buffer, int delta) {
this.buffer = buffer; // this.buffer = buffer;
this.delta = delta; // this.delta = delta;
} // }
} // }
private boolean fCloseBrace; private boolean fCloseBrace;
private boolean fIsSmartMode; private boolean fIsSmartMode;
@ -89,7 +89,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
// a comment starts, advance to the comment end // a comment starts, advance to the comment end
start = getCommentEnd(d, start + 1, end); start = getCommentEnd(d, start + 1, end);
} else if (next == '/') { } else if (next == '/') {
// '//'-comment: nothing to do anymore on this line // '//'-comment: nothing to do anymore on this line
start = end; start = end;
} }
} }
@ -186,7 +186,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
int indLine = d.getLineOfOffset(reference); int indLine = d.getLineOfOffset(reference);
if (indLine != -1 && indLine != line) { if (indLine != -1 && indLine != line) {
// take the indent of the found line // take the indent of the found line
StringBuffer replaceText = new StringBuffer(getIndentOfLine(d, indLine)); StringBuilder replaceText = new StringBuilder(getIndentOfLine(d, indLine));
// add the rest of the current line including the just added close bracket // add the rest of the current line including the just added close bracket
replaceText.append(d.get(whiteend, c.offset - whiteend)); replaceText.append(d.get(whiteend, c.offset - whiteend));
replaceText.append(c.text); replaceText.append(c.text);
@ -230,7 +230,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
// Only shift if the last C line is further up and is a braceless block candidate // Only shift if the last C line is further up and is a braceless block candidate
if (lastLine < line) { if (lastLine < line) {
CIndenter indenter = new CIndenter(d, scanner, fProject); CIndenter indenter = new CIndenter(d, scanner, fProject);
StringBuffer indent = indenter.computeIndentation(p, true); StringBuilder indent = indenter.computeIndentation(p, true);
String toDelete = d.get(lineOffset, c.offset - lineOffset); String toDelete = d.get(lineOffset, c.offset - lineOffset);
if (indent != null && !indent.toString().equals(toDelete)) { if (indent != null && !indent.toString().equals(toDelete)) {
c.text = indent.append(c.text).toString(); c.text = indent.append(c.text).toString();
@ -253,7 +253,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
CHeuristicScanner scanner= new CHeuristicScanner(d); CHeuristicScanner scanner= new CHeuristicScanner(d);
try { try {
ITypedRegion partition= TextUtilities.getPartition(d, fPartitioning, c.offset, false); ITypedRegion partition= TextUtilities.getPartition(d, fPartitioning, c.offset, false);
if (ICPartitions.C_PREPROCESSOR.equals(partition.getType()) && d.get(c.offset-1, 1).charAt(0) == '\\') { if (ICPartitions.C_PREPROCESSOR.equals(partition.getType()) && c.offset > 0 && d.getChar(c.offset-1) == '\\') {
scanner = new CHeuristicScanner(d, fPartitioning, ICPartitions.C_PREPROCESSOR); scanner = new CHeuristicScanner(d, fPartitioning, ICPartitions.C_PREPROCESSOR);
addIndent= 1; addIndent= 1;
} }
@ -263,7 +263,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
int start = reg.getOffset(); int start = reg.getOffset();
int lineEnd = start + reg.getLength(); int lineEnd = start + reg.getLength();
StringBuffer indent= null; StringBuilder indent= null;
CIndenter indenter= new CIndenter(d, scanner, fProject); CIndenter indenter= new CIndenter(d, scanner, fProject);
if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_AUTO_INDENT)) { if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_AUTO_INDENT)) {
indent= indenter.computeIndentation(c.offset); indent= indenter.computeIndentation(c.offset);
@ -271,18 +271,18 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
// reuse existing indent // reuse existing indent
int wsEnd= findEndOfWhiteSpace(d, start, c.offset); int wsEnd= findEndOfWhiteSpace(d, start, c.offset);
if (wsEnd > start) { if (wsEnd > start) {
indent= new StringBuffer(d.get(start, wsEnd - start)); indent= new StringBuilder(d.get(start, wsEnd - start));
addIndent= 0; addIndent= 0;
} }
} }
if (indent == null) { if (indent == null) {
indent= new StringBuffer(); indent= new StringBuilder();
} }
if (addIndent > 0 && indent.length() == 0) { if (addIndent > 0 && indent.length() == 0) {
indent= indenter.createReusingIndent(indent, addIndent); indent= indenter.createReusingIndent(indent, addIndent);
} }
StringBuffer buf = new StringBuffer(c.text + indent); StringBuilder buf = new StringBuilder(c.text + indent);
int contentStart = findEndOfWhiteSpace(d, c.offset, lineEnd); int contentStart = findEndOfWhiteSpace(d, c.offset, lineEnd);
c.length = Math.max(contentStart - c.offset, 0); c.length = Math.max(contentStart - c.offset, 0);
@ -301,10 +301,10 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
} }
buf.append(TextUtilities.getDefaultLineDelimiter(d)); buf.append(TextUtilities.getDefaultLineDelimiter(d));
StringBuffer reference = null; StringBuilder reference = null;
int nonWS = findEndOfWhiteSpace(d, start, lineEnd); int nonWS = findEndOfWhiteSpace(d, start, lineEnd);
if (nonWS < c.offset && d.getChar(nonWS) == '{') if (nonWS < c.offset && d.getChar(nonWS) == '{')
reference = new StringBuffer(d.get(start, nonWS - start)); reference = new StringBuilder(d.get(start, nonWS - start));
else else
reference = indenter.getReferenceIndentation(c.offset); reference = indenter.getReferenceIndentation(c.offset);
if (reference != null) if (reference != null)
@ -326,10 +326,10 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
c.caretOffset = c.offset + buf.length(); c.caretOffset = c.offset + buf.length();
c.shiftsCaret = false; c.shiftsCaret = false;
StringBuffer reference = null; StringBuilder reference = null;
int nonWS = findEndOfWhiteSpace(d, start, lineEnd); int nonWS = findEndOfWhiteSpace(d, start, lineEnd);
if (nonWS < c.offset && d.getChar(nonWS) == '{') if (nonWS < c.offset && d.getChar(nonWS) == '{')
reference = new StringBuffer(d.get(start, nonWS - start)); reference = new StringBuilder(d.get(start, nonWS - start));
else else
reference = indenter.getReferenceIndentation(c.offset); reference = indenter.getReferenceIndentation(c.offset);
@ -408,35 +408,35 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
} }
private boolean isClosedBrace(IDocument document, int offset, int length) { private boolean isClosedBrace(IDocument document, int offset, int length) {
CompilationUnitInfo info = getCompilationUnitForMethod(document, offset, fPartitioning);
if (info == null)
return false;
return getBlockBalance(document, offset, fPartitioning) <= 0; return getBlockBalance(document, offset, fPartitioning) <= 0;
//TODO: Use smarter algorithm based on //TODO: Use smarter algorithm based on
// CompilationUnitInfo info = getCompilationUnitForMethod(document, offset, fPartitioning);
// if (info == null)
// return false;
//
// CodeReader reader = new CodeReader(info.buffer); // CodeReader reader = new CodeReader(info.buffer);
// ICodeReaderFactory fileCreator = CDOM.getInstance().getCodeReaderFactory(CDOM.PARSE_WORKING_COPY_WHENEVER_POSSIBLE); // ICodeReaderFactory fileCreator = CDOM.getInstance().getCodeReaderFactory(CDOM.PARSE_WORKING_COPY_WHENEVER_POSSIBLE);
// //
// IScanner domScanner = new DOMScanner(reader, new ScannerInfo(), ParserMode.COMPLETE_PARSE, // IScanner domScanner = new DOMScanner(reader, new ScannerInfo(), ParserMode.COMPLETE_PARSE,
// ParserLanguage.C, ParserFactory.createDefaultLogService(), // ParserLanguage.C, ParserFactory.createDefaultLogService(),
// C_GNU_SCANNER_EXTENSION, fileCreator); // C_GNU_SCANNER_EXTENSION, fileCreator);
// //
// ISourceCodeParser parser = new GNUCPPSourceParser( // ISourceCodeParser parser = new GNUCPPSourceParser(
// domScanner, // domScanner,
// ParserMode.COMPLETE_PARSE, // ParserMode.COMPLETE_PARSE,
// ParserUtil.getParserLogService(), // ParserUtil.getParserLogService(),
// new GPPParserExtensionConfiguration()); // new GPPParserExtensionConfiguration());
// //
// IASTTranslationUnit translationUnit = parser.parse(); // IASTTranslationUnit translationUnit = parser.parse();
// final int relativeOffset = offset - info.delta; // final int relativeOffset = offset - info.delta;
// IASTNode node = translationUnit.selectNodeForLocation(reader.getPath(), relativeOffset, length); // IASTNode node = translationUnit.selectNodeForLocation(reader.getPath(), relativeOffset, length);
// //
// if (node == null) // if (node == null)
// return false; // return false;
// //
// if (node instanceof IASTCompoundStatement) { // if (node instanceof IASTCompoundStatement) {
// return getBlockBalance(document, offset, fPartitioning) <= 0; // return getBlockBalance(document, offset, fPartitioning) <= 0;
// } else if (node instanceof IASTIfStatement) { // } else if (node instanceof IASTIfStatement) {
// IASTIfStatement ifStatement = (IASTIfStatement) node; // IASTIfStatement ifStatement = (IASTIfStatement) node;
// IASTExpression expression = ifStatement.getConditionExpression(); // IASTExpression expression = ifStatement.getConditionExpression();
// IRegion expressionRegion = createRegion(expression, info.delta); // IRegion expressionRegion = createRegion(expression, info.delta);
@ -463,7 +463,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
// return pos <= offset && offset + length < elseRegion.getOffset(); // return pos <= offset && offset + length < elseRegion.getOffset();
// } // }
// } // }
// //
// return true; // return true;
// } // }
// } else if (node instanceof IASTForStatement) { // } else if (node instanceof IASTForStatement) {
@ -582,7 +582,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
// (as the first might be partially selected) and use the value to // (as the first might be partially selected) and use the value to
// indent all other lines. // indent all other lines.
boolean isIndentDetected= false; boolean isIndentDetected= false;
StringBuffer addition= new StringBuffer(); StringBuilder addition= new StringBuilder();
int insertLength= 0; int insertLength= 0;
int first= document.computeNumberOfLines(prefix) + firstLine; // don't format first line int first= document.computeNumberOfLines(prefix) + firstLine; // don't format first line
int lines= temp.getNumberOfLines(); int lines= temp.getNumberOfLines();
@ -600,7 +600,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
if (!isIndentDetected) { if (!isIndentDetected) {
// indent the first pasted line // indent the first pasted line
String current= IndentUtil.getCurrentIndent(temp, l, indentInsideLineComments); String current= IndentUtil.getCurrentIndent(temp, l, indentInsideLineComments);
StringBuffer correct= new StringBuffer(IndentUtil.computeIndent(temp, l, indenter, scanner)); StringBuilder correct= new StringBuilder(IndentUtil.computeIndent(temp, l, indenter, scanner));
insertLength= subtractIndent(correct, current, addition); insertLength= subtractIndent(correct, current, addition);
// workaround for bug 181139 // workaround for bug 181139
@ -651,7 +651,7 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
* @param difference a string buffer - if the return value is positive, it will be cleared and set to the substring of <code>current</code> of that length * @param difference a string buffer - if the return value is positive, it will be cleared and set to the substring of <code>current</code> of that length
* @return the difference in lenght of <code>correct</code> and <code>current</code> * @return the difference in lenght of <code>correct</code> and <code>current</code>
*/ */
private int subtractIndent(CharSequence correct, CharSequence current, StringBuffer difference) { private int subtractIndent(CharSequence correct, CharSequence current, StringBuilder difference) {
int c1= computeVisualLength(correct); int c1= computeVisualLength(correct);
int c2= computeVisualLength(current); int c2= computeVisualLength(current);
int diff= c1 - c2; int diff= c1 - c2;
@ -1164,29 +1164,29 @@ public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
return false; return false;
} }
private static CompilationUnitInfo getCompilationUnitForMethod(IDocument document, int offset, String partitioning) { // private static CompilationUnitInfo getCompilationUnitForMethod(IDocument document, int offset, String partitioning) {
try { // try {
CHeuristicScanner scanner = new CHeuristicScanner(document); // CHeuristicScanner scanner = new CHeuristicScanner(document);
//
IRegion sourceRange = scanner.findSurroundingBlock(offset); // IRegion sourceRange = scanner.findSurroundingBlock(offset);
if (sourceRange == null) // if (sourceRange == null)
return null; // return null;
String source = document.get(sourceRange.getOffset(), sourceRange.getLength()); // String source = document.get(sourceRange.getOffset(), sourceRange.getLength());
//
StringBuffer contents = new StringBuffer(); // StringBuilder contents = new StringBuilder();
contents.append("class ____C{void ____m()"); //$NON-NLS-1$ // contents.append("class ____C{void ____m()"); //$NON-NLS-1$
final int methodOffset = contents.length(); // final int methodOffset = contents.length();
contents.append(source); // contents.append(source);
contents.append("};"); //$NON-NLS-1$ // contents.append("};"); //$NON-NLS-1$
//
char[] buffer = contents.toString().toCharArray(); // char[] buffer = contents.toString().toCharArray();
return new CompilationUnitInfo(buffer, sourceRange.getOffset() - methodOffset); // return new CompilationUnitInfo(buffer, sourceRange.getOffset() - methodOffset);
} catch (BadLocationException e) { // } catch (BadLocationException e) {
CUIPlugin.log(e); // CUIPlugin.log(e);
} // }
//
return null; // return null;
} // }
/** /**
* Returns the block balance, i.e. zero if the blocks are balanced at * Returns the block balance, i.e. zero if the blocks are balanced at

30
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/text/CIndenter.java
View file

@ -409,7 +409,7 @@ public final class CIndenter {
* reference position to <code>offset</code> resides, or <code>null</code> * reference position to <code>offset</code> resides, or <code>null</code>
* if it cannot be determined * if it cannot be determined
*/ */
public StringBuffer getReferenceIndentation(int offset) { public StringBuilder getReferenceIndentation(int offset) {
return getReferenceIndentation(offset, false); return getReferenceIndentation(offset, false);
} }
@ -422,7 +422,7 @@ public final class CIndenter {
* reference position to <code>offset</code> resides, or <code>null</code> * reference position to <code>offset</code> resides, or <code>null</code>
* if it cannot be determined * if it cannot be determined
*/ */
private StringBuffer getReferenceIndentation(int offset, boolean assumeOpeningBrace) { private StringBuilder getReferenceIndentation(int offset, boolean assumeOpeningBrace) {
int unit; int unit;
if (assumeOpeningBrace) if (assumeOpeningBrace)
unit= findReferencePosition(offset, Symbols.TokenLBRACE); unit= findReferencePosition(offset, Symbols.TokenLBRACE);
@ -444,7 +444,7 @@ public final class CIndenter {
* which offset resides, or <code>null</code> if it cannot be * which offset resides, or <code>null</code> if it cannot be
* determined * determined
*/ */
public StringBuffer computeIndentation(int offset) { public StringBuilder computeIndentation(int offset) {
return computeIndentation(offset, false); return computeIndentation(offset, false);
} }
@ -457,8 +457,8 @@ public final class CIndenter {
* which offset resides, or <code>null</code> if it cannot be * which offset resides, or <code>null</code> if it cannot be
* determined * determined
*/ */
public StringBuffer computeIndentation(int offset, boolean assumeOpeningBrace) { public StringBuilder computeIndentation(int offset, boolean assumeOpeningBrace) {
StringBuffer reference= getReferenceIndentation(offset, assumeOpeningBrace); StringBuilder reference= getReferenceIndentation(offset, assumeOpeningBrace);
// handle special alignment // handle special alignment
if (fAlign != CHeuristicScanner.NOT_FOUND) { if (fAlign != CHeuristicScanner.NOT_FOUND) {
@ -483,13 +483,13 @@ public final class CIndenter {
* Computes the indentation for a continuation line at <code>offset</code>. * Computes the indentation for a continuation line at <code>offset</code>.
* *
* @param offset the offset in the document * @param offset the offset in the document
* @return a StringBuffer which reflects the correct indentation for * @return a StringBuilder which reflects the correct indentation for
* the line in which offset resides, or <code>null</code> if it cannot be * the line in which offset resides, or <code>null</code> if it cannot be
* determined. * determined.
* @throws BadLocationException * @throws BadLocationException
*/ */
public StringBuffer computeContinuationLineIndentation(int offset) throws BadLocationException { public StringBuilder computeContinuationLineIndentation(int offset) throws BadLocationException {
StringBuffer reference= getLeadingWhitespace(offset); StringBuilder reference= getLeadingWhitespace(offset);
IRegion line= fDocument.getLineInformationOfOffset(offset); IRegion line= fDocument.getLineInformationOfOffset(offset);
String string= fDocument.get(line.getOffset(), offset - line.getOffset()); String string= fDocument.get(line.getOffset(), offset - line.getOffset());
if (string.trim().length() == 0) if (string.trim().length() == 0)
@ -534,7 +534,7 @@ public final class CIndenter {
* @param indentLength the maximum visual indentation length * @param indentLength the maximum visual indentation length
* @return the stripped <code>reference</code> * @return the stripped <code>reference</code>
*/ */
private StringBuffer stripExceedingChars(StringBuffer reference, int indentLength) { private StringBuilder stripExceedingChars(StringBuilder reference, int indentLength) {
final int tabSize= fPrefs.prefTabSize; final int tabSize= fPrefs.prefTabSize;
int measured= 0; int measured= 0;
int chars= reference.length(); int chars= reference.length();
@ -560,15 +560,15 @@ public final class CIndenter {
/** /**
* Returns the indentation of the line at <code>offset</code> as a * Returns the indentation of the line at <code>offset</code> as a
* <code>StringBuffer</code>. If the offset is not valid, the empty string * <code>StringBuilder</code>. If the offset is not valid, the empty string
* is returned. * is returned.
* *
* @param offset the offset in the document * @param offset the offset in the document
* @return the indentation (leading whitespace) of the line in which * @return the indentation (leading whitespace) of the line in which
* <code>offset</code> is located * <code>offset</code> is located
*/ */
private StringBuffer getLeadingWhitespace(int offset) { private StringBuilder getLeadingWhitespace(int offset) {
StringBuffer indent= new StringBuffer(); StringBuilder indent= new StringBuilder();
try { try {
IRegion line= fDocument.getLineInformationOfOffset(offset); IRegion line= fDocument.getLineInformationOfOffset(offset);
int lineOffset= line.getOffset(); int lineOffset= line.getOffset();
@ -600,10 +600,10 @@ public final class CIndenter {
* @return the indentation corresponding to the document content specified * @return the indentation corresponding to the document content specified
* by <code>start</code> and <code>indent</code> * by <code>start</code> and <code>indent</code>
*/ */
private StringBuffer createIndent(int start, final int indent, final boolean convertSpaceRunsToTabs) { private StringBuilder createIndent(int start, final int indent, final boolean convertSpaceRunsToTabs) {
final boolean convertTabs= fPrefs.prefUseTabs && convertSpaceRunsToTabs; final boolean convertTabs= fPrefs.prefUseTabs && convertSpaceRunsToTabs;
final int tabLen= fPrefs.prefTabSize; final int tabLen= fPrefs.prefTabSize;
final StringBuffer ret= new StringBuffer(); final StringBuilder ret= new StringBuilder();
try { try {
int spaces= 0; int spaces= 0;
while (start < indent) { while (start < indent) {
@ -643,7 +643,7 @@ public final class CIndenter {
* @return the modified <code>buffer</code> reflecting the indentation * @return the modified <code>buffer</code> reflecting the indentation
* adapted to <code>additional</code> * adapted to <code>additional</code>
*/ */
public StringBuffer createReusingIndent(StringBuffer buffer, int additional) { public StringBuilder createReusingIndent(StringBuilder buffer, int additional) {
int refLength= computeVisualLength(buffer); int refLength= computeVisualLength(buffer);
int addLength= fPrefs.prefIndentationSize * additional; // may be < 0 int addLength= fPrefs.prefIndentationSize * additional; // may be < 0
int totalLength= Math.max(0, refLength + addLength); int totalLength= Math.max(0, refLength + addLength);

10
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/text/CStringAutoIndentStrategy.java
View file

@ -1,5 +1,5 @@
/******************************************************************************* /*******************************************************************************
* Copyright (c) 2000, 2007 IBM Corporation and others. * Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials * All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0 * are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at * which accompanies this distribution, and is available at
@ -44,7 +44,7 @@ public class CStringAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy
*/ */
private String displayString(String inputString, CharSequence indentation, String delimiter) { private String displayString(String inputString, CharSequence indentation, String delimiter) {
int length = inputString.length(); int length = inputString.length();
StringBuffer buffer = new StringBuffer(length); StringBuilder buffer = new StringBuilder(length);
java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(inputString, "\n\r", true); //$NON-NLS-1$ java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(inputString, "\n\r", true); //$NON-NLS-1$
while (tokenizer.hasMoreTokens()) { while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken(); String token = tokenizer.nextToken();
@ -73,7 +73,7 @@ public class CStringAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy
continue; continue;
} }
StringBuffer tokenBuffer = new StringBuffer(); StringBuilder tokenBuffer = new StringBuilder();
for (int i = 0; i < token.length(); i++){ for (int i = 0; i < token.length(); i++){
char c = token.charAt(i); char c = token.charAt(i);
switch (c) { switch (c) {
@ -143,9 +143,9 @@ public class CStringAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy
CHeuristicScanner scanner = new CHeuristicScanner(document); CHeuristicScanner scanner = new CHeuristicScanner(document);
CIndenter indenter = new CIndenter(document, scanner, fProject); CIndenter indenter = new CIndenter(document, scanner, fProject);
StringBuffer indentation = indenter.computeContinuationLineIndentation(offset); StringBuilder indentation = indenter.computeContinuationLineIndentation(offset);
if (indentation == null) if (indentation == null)
indentation = new StringBuffer(); indentation = new StringBuilder();
String delimiter= TextUtilities.getDefaultLineDelimiter(document); String delimiter= TextUtilities.getDefaultLineDelimiter(document);
IPreferenceStore preferenceStore= CUIPlugin.getDefault().getPreferenceStore(); IPreferenceStore preferenceStore= CUIPlugin.getDefault().getPreferenceStore();