7715 lines
216 KiB
C++
Executable File
7715 lines
216 KiB
C++
Executable File
// ASFormatter.cpp
|
|
// Copyright (c) 2017 by Jim Pattee <jimp03@email.com>.
|
|
// This code is licensed under the MIT License.
|
|
// License.md describes the conditions under which this software may be distributed.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// headers
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "astyle.h"
|
|
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// astyle namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace astyle {
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// ASFormatter class
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Constructor of ASFormatter
|
|
*/
|
|
ASFormatter::ASFormatter()
|
|
{
|
|
sourceIterator = nullptr;
|
|
enhancer = new ASEnhancer;
|
|
preBraceHeaderStack = nullptr;
|
|
braceTypeStack = nullptr;
|
|
parenStack = nullptr;
|
|
structStack = nullptr;
|
|
questionMarkStack = nullptr;
|
|
lineCommentNoIndent = false;
|
|
formattingStyle = STYLE_NONE;
|
|
braceFormatMode = NONE_MODE;
|
|
pointerAlignment = PTR_ALIGN_NONE;
|
|
referenceAlignment = REF_SAME_AS_PTR;
|
|
objCColonPadMode = COLON_PAD_NO_CHANGE;
|
|
lineEnd = LINEEND_DEFAULT;
|
|
maxCodeLength = string::npos;
|
|
shouldPadCommas = false;
|
|
shouldPadOperators = false;
|
|
shouldPadParensOutside = false;
|
|
shouldPadFirstParen = false;
|
|
shouldPadParensInside = false;
|
|
shouldPadHeader = false;
|
|
shouldStripCommentPrefix = false;
|
|
shouldUnPadParens = false;
|
|
attachClosingBraceMode = false;
|
|
shouldBreakOneLineBlocks = true;
|
|
shouldBreakOneLineHeaders = false;
|
|
shouldBreakOneLineStatements = true;
|
|
shouldConvertTabs = false;
|
|
shouldIndentCol1Comments = false;
|
|
shouldIndentPreprocBlock = false;
|
|
shouldCloseTemplates = false;
|
|
shouldAttachExternC = false;
|
|
shouldAttachNamespace = false;
|
|
shouldAttachClass = false;
|
|
shouldAttachClosingWhile = false;
|
|
shouldAttachInline = false;
|
|
shouldBreakBlocks = false;
|
|
shouldBreakClosingHeaderBlocks = false;
|
|
shouldBreakClosingHeaderBraces = false;
|
|
shouldDeleteEmptyLines = false;
|
|
shouldBreakElseIfs = false;
|
|
shouldBreakLineAfterLogical = false;
|
|
shouldAddBraces = false;
|
|
shouldAddOneLineBraces = false;
|
|
shouldRemoveBraces = false;
|
|
shouldPadMethodColon = false;
|
|
shouldPadMethodPrefix = false;
|
|
shouldUnPadMethodPrefix = false;
|
|
shouldPadReturnType = false;
|
|
shouldUnPadReturnType = false;
|
|
shouldPadParamType = false;
|
|
shouldUnPadParamType = false;
|
|
|
|
// initialize ASFormatter member vectors
|
|
formatterFileType = 9; // reset to an invalid type
|
|
headers = new vector<const string*>;
|
|
nonParenHeaders = new vector<const string*>;
|
|
preDefinitionHeaders = new vector<const string*>;
|
|
preCommandHeaders = new vector<const string*>;
|
|
operators = new vector<const string*>;
|
|
assignmentOperators = new vector<const string*>;
|
|
castOperators = new vector<const string*>;
|
|
|
|
// initialize ASEnhancer member vectors
|
|
indentableMacros = new vector<const pair<const string, const string>* >;
|
|
}
|
|
|
|
/**
|
|
* Destructor of ASFormatter
|
|
*/
|
|
ASFormatter::~ASFormatter()
|
|
{
|
|
// delete ASFormatter stack vectors
|
|
deleteContainer(preBraceHeaderStack);
|
|
deleteContainer(braceTypeStack);
|
|
deleteContainer(parenStack);
|
|
deleteContainer(structStack);
|
|
deleteContainer(questionMarkStack);
|
|
|
|
// delete ASFormatter member vectors
|
|
formatterFileType = 9; // reset to an invalid type
|
|
delete headers;
|
|
delete nonParenHeaders;
|
|
delete preDefinitionHeaders;
|
|
delete preCommandHeaders;
|
|
delete operators;
|
|
delete assignmentOperators;
|
|
delete castOperators;
|
|
|
|
// delete ASEnhancer member vectors
|
|
delete indentableMacros;
|
|
|
|
// must be done when the ASFormatter object is deleted (not ASBeautifier)
|
|
// delete ASBeautifier member vectors
|
|
ASBeautifier::deleteBeautifierVectors();
|
|
|
|
delete enhancer;
|
|
}
|
|
|
|
/**
|
|
* initialize the ASFormatter.
|
|
*
|
|
* init() should be called every time a ASFormatter object is to start
|
|
* formatting a NEW source file.
|
|
* init() receives a pointer to a ASSourceIterator object that will be
|
|
* used to iterate through the source code.
|
|
*
|
|
* @param si a pointer to the ASSourceIterator or ASStreamIterator object.
|
|
*/
|
|
void ASFormatter::init(ASSourceIterator* si)
|
|
{
|
|
buildLanguageVectors();
|
|
fixOptionVariableConflicts();
|
|
ASBeautifier::init(si);
|
|
sourceIterator = si;
|
|
|
|
enhancer->init(getFileType(),
|
|
getIndentLength(),
|
|
getTabLength(),
|
|
getIndentString() == "\t",
|
|
getForceTabIndentation(),
|
|
getNamespaceIndent(),
|
|
getCaseIndent(),
|
|
shouldIndentPreprocBlock,
|
|
getPreprocDefineIndent(),
|
|
getEmptyLineFill(),
|
|
indentableMacros);
|
|
|
|
initContainer(preBraceHeaderStack, new vector<const string*>);
|
|
initContainer(parenStack, new vector<int>);
|
|
initContainer(structStack, new vector<bool>);
|
|
initContainer(questionMarkStack, new vector<bool>);
|
|
parenStack->emplace_back(0); // parenStack must contain this default entry
|
|
initContainer(braceTypeStack, new vector<BraceType>);
|
|
braceTypeStack->emplace_back(NULL_TYPE); // braceTypeStack must contain this default entry
|
|
clearFormattedLineSplitPoints();
|
|
|
|
currentHeader = nullptr;
|
|
currentLine = "";
|
|
readyFormattedLine = "";
|
|
formattedLine = "";
|
|
verbatimDelimiter = "";
|
|
currentChar = ' ';
|
|
previousChar = ' ';
|
|
previousCommandChar = ' ';
|
|
previousNonWSChar = ' ';
|
|
quoteChar = '"';
|
|
preprocBlockEnd = 0;
|
|
charNum = 0;
|
|
checksumIn = 0;
|
|
checksumOut = 0;
|
|
currentLineFirstBraceNum = string::npos;
|
|
formattedLineCommentNum = 0;
|
|
leadingSpaces = 0;
|
|
previousReadyFormattedLineLength = string::npos;
|
|
preprocBraceTypeStackSize = 0;
|
|
spacePadNum = 0;
|
|
nextLineSpacePadNum = 0;
|
|
objCColonAlign = 0;
|
|
templateDepth = 0;
|
|
squareBracketCount = 0;
|
|
runInIndentChars = 0;
|
|
tabIncrementIn = 0;
|
|
previousBraceType = NULL_TYPE;
|
|
|
|
isVirgin = true;
|
|
isInVirginLine = true;
|
|
isInLineComment = false;
|
|
isInComment = false;
|
|
isInCommentStartLine = false;
|
|
noTrimCommentContinuation = false;
|
|
isInPreprocessor = false;
|
|
isInPreprocessorBeautify = false;
|
|
doesLineStartComment = false;
|
|
lineEndsInCommentOnly = false;
|
|
lineIsCommentOnly = false;
|
|
lineIsLineCommentOnly = false;
|
|
lineIsEmpty = false;
|
|
isImmediatelyPostCommentOnly = false;
|
|
isImmediatelyPostEmptyLine = false;
|
|
isInClassInitializer = false;
|
|
isInQuote = false;
|
|
isInVerbatimQuote = false;
|
|
haveLineContinuationChar = false;
|
|
isInQuoteContinuation = false;
|
|
isHeaderInMultiStatementLine = false;
|
|
isSpecialChar = false;
|
|
isNonParenHeader = false;
|
|
foundNamespaceHeader = false;
|
|
foundClassHeader = false;
|
|
foundStructHeader = false;
|
|
foundInterfaceHeader = false;
|
|
foundPreDefinitionHeader = false;
|
|
foundPreCommandHeader = false;
|
|
foundPreCommandMacro = false;
|
|
foundTrailingReturnType = false;
|
|
foundCastOperator = false;
|
|
foundQuestionMark = false;
|
|
isInLineBreak = false;
|
|
endOfAsmReached = false;
|
|
endOfCodeReached = false;
|
|
isFormattingModeOff = false;
|
|
isInEnum = false;
|
|
isInExecSQL = false;
|
|
isInAsm = false;
|
|
isInAsmOneLine = false;
|
|
isInAsmBlock = false;
|
|
isLineReady = false;
|
|
elseHeaderFollowsComments = false;
|
|
caseHeaderFollowsComments = false;
|
|
isPreviousBraceBlockRelated = false;
|
|
isInPotentialCalculation = false;
|
|
needHeaderOpeningBrace = false;
|
|
shouldBreakLineAtNextChar = false;
|
|
shouldKeepLineUnbroken = false;
|
|
shouldReparseCurrentChar = false;
|
|
passedSemicolon = false;
|
|
passedColon = false;
|
|
isImmediatelyPostNonInStmt = false;
|
|
isCharImmediatelyPostNonInStmt = false;
|
|
isInTemplate = false;
|
|
isImmediatelyPostComment = false;
|
|
isImmediatelyPostLineComment = false;
|
|
isImmediatelyPostEmptyBlock = false;
|
|
isImmediatelyPostObjCMethodPrefix = false;
|
|
isImmediatelyPostPreprocessor = false;
|
|
isImmediatelyPostReturn = false;
|
|
isImmediatelyPostThrow = false;
|
|
isImmediatelyPostNewDelete = false;
|
|
isImmediatelyPostOperator = false;
|
|
isImmediatelyPostTemplate = false;
|
|
isImmediatelyPostPointerOrReference = false;
|
|
isCharImmediatelyPostReturn = false;
|
|
isCharImmediatelyPostThrow = false;
|
|
isCharImmediatelyPostNewDelete = false;
|
|
isCharImmediatelyPostOperator = false;
|
|
isCharImmediatelyPostComment = false;
|
|
isPreviousCharPostComment = false;
|
|
isCharImmediatelyPostLineComment = false;
|
|
isCharImmediatelyPostOpenBlock = false;
|
|
isCharImmediatelyPostCloseBlock = false;
|
|
isCharImmediatelyPostTemplate = false;
|
|
isCharImmediatelyPostPointerOrReference = false;
|
|
isInObjCInterface = false;
|
|
isInObjCMethodDefinition = false;
|
|
isInObjCReturnType = false;
|
|
isInObjCSelector = false;
|
|
breakCurrentOneLineBlock = false;
|
|
shouldRemoveNextClosingBrace = false;
|
|
isInBraceRunIn = false;
|
|
currentLineBeginsWithBrace = false;
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
isIndentableProprocessor = false;
|
|
isIndentableProprocessorBlock = false;
|
|
prependEmptyLine = false;
|
|
appendOpeningBrace = false;
|
|
foundClosingHeader = false;
|
|
isImmediatelyPostHeader = false;
|
|
isInHeader = false;
|
|
isInCase = false;
|
|
isFirstPreprocConditional = false;
|
|
processedFirstConditional = false;
|
|
isJavaStaticConstructor = false;
|
|
}
|
|
|
|
/**
|
|
* build vectors for each programing language
|
|
* depending on the file extension.
|
|
*/
|
|
void ASFormatter::buildLanguageVectors()
|
|
{
|
|
if (getFileType() == formatterFileType) // don't build unless necessary
|
|
return;
|
|
|
|
formatterFileType = getFileType();
|
|
|
|
headers->clear();
|
|
nonParenHeaders->clear();
|
|
preDefinitionHeaders->clear();
|
|
preCommandHeaders->clear();
|
|
operators->clear();
|
|
assignmentOperators->clear();
|
|
castOperators->clear();
|
|
indentableMacros->clear(); // ASEnhancer
|
|
|
|
ASResource::buildHeaders(headers, getFileType());
|
|
ASResource::buildNonParenHeaders(nonParenHeaders, getFileType());
|
|
ASResource::buildPreDefinitionHeaders(preDefinitionHeaders, getFileType());
|
|
ASResource::buildPreCommandHeaders(preCommandHeaders, getFileType());
|
|
ASResource::buildOperators(operators, getFileType());
|
|
ASResource::buildAssignmentOperators(assignmentOperators);
|
|
ASResource::buildCastOperators(castOperators);
|
|
ASResource::buildIndentableMacros(indentableMacros); //ASEnhancer
|
|
}
|
|
|
|
/**
|
|
* set the variables for each predefined style.
|
|
* this will override any previous settings.
|
|
*/
|
|
void ASFormatter::fixOptionVariableConflicts()
|
|
{
|
|
if (formattingStyle == STYLE_ALLMAN)
|
|
{
|
|
setBraceFormatMode(BREAK_MODE);
|
|
}
|
|
else if (formattingStyle == STYLE_JAVA)
|
|
{
|
|
setBraceFormatMode(ATTACH_MODE);
|
|
}
|
|
else if (formattingStyle == STYLE_KR)
|
|
{
|
|
setBraceFormatMode(LINUX_MODE);
|
|
}
|
|
else if (formattingStyle == STYLE_STROUSTRUP)
|
|
{
|
|
setBraceFormatMode(LINUX_MODE);
|
|
setBreakClosingHeaderBracesMode(true);
|
|
}
|
|
else if (formattingStyle == STYLE_WHITESMITH)
|
|
{
|
|
setBraceFormatMode(BREAK_MODE);
|
|
setBraceIndent(true);
|
|
setClassIndent(true); // avoid hanging indent with access modifiers
|
|
setSwitchIndent(true); // avoid hanging indent with case statements
|
|
}
|
|
else if (formattingStyle == STYLE_VTK)
|
|
{
|
|
// the unindented class brace does NOT cause a hanging indent like Whitesmith
|
|
setBraceFormatMode(BREAK_MODE);
|
|
setBraceIndentVtk(true); // sets both braceIndent and braceIndentVtk
|
|
setSwitchIndent(true); // avoid hanging indent with case statements
|
|
}
|
|
else if (formattingStyle == STYLE_BANNER)
|
|
{
|
|
// attached braces can have hanging indents with the closing brace
|
|
setBraceFormatMode(ATTACH_MODE);
|
|
setBraceIndent(true);
|
|
setClassIndent(true); // avoid hanging indent with access modifiers
|
|
setSwitchIndent(true); // avoid hanging indent with case statements
|
|
}
|
|
else if (formattingStyle == STYLE_GNU)
|
|
{
|
|
setBraceFormatMode(BREAK_MODE);
|
|
setBlockIndent(true);
|
|
}
|
|
else if (formattingStyle == STYLE_LINUX)
|
|
{
|
|
setBraceFormatMode(LINUX_MODE);
|
|
// always for Linux style
|
|
setMinConditionalIndentOption(MINCOND_ONEHALF);
|
|
}
|
|
else if (formattingStyle == STYLE_HORSTMANN)
|
|
{
|
|
setBraceFormatMode(RUN_IN_MODE);
|
|
setSwitchIndent(true);
|
|
}
|
|
else if (formattingStyle == STYLE_1TBS)
|
|
{
|
|
setBraceFormatMode(LINUX_MODE);
|
|
setAddBracesMode(true);
|
|
setRemoveBracesMode(false);
|
|
}
|
|
else if (formattingStyle == STYLE_GOOGLE)
|
|
{
|
|
setBraceFormatMode(ATTACH_MODE);
|
|
setModifierIndent(true);
|
|
setClassIndent(false);
|
|
}
|
|
else if (formattingStyle == STYLE_MOZILLA)
|
|
{
|
|
setBraceFormatMode(LINUX_MODE);
|
|
}
|
|
else if (formattingStyle == STYLE_PICO)
|
|
{
|
|
setBraceFormatMode(RUN_IN_MODE);
|
|
setAttachClosingBraceMode(true);
|
|
setSwitchIndent(true);
|
|
setBreakOneLineBlocksMode(false);
|
|
setBreakOneLineStatementsMode(false);
|
|
// add-braces won't work for pico, but it could be fixed if necessary
|
|
// both options should be set to true
|
|
if (shouldAddBraces)
|
|
shouldAddOneLineBraces = true;
|
|
}
|
|
else if (formattingStyle == STYLE_LISP)
|
|
{
|
|
setBraceFormatMode(ATTACH_MODE);
|
|
setAttachClosingBraceMode(true);
|
|
setBreakOneLineStatementsMode(false);
|
|
// add-one-line-braces won't work for lisp
|
|
// only shouldAddBraces should be set to true
|
|
if (shouldAddOneLineBraces)
|
|
{
|
|
shouldAddBraces = true;
|
|
shouldAddOneLineBraces = false;
|
|
}
|
|
}
|
|
setMinConditionalIndentLength();
|
|
// if not set by indent=force-tab-x set equal to indentLength
|
|
if (getTabLength() == 0)
|
|
setDefaultTabLength();
|
|
// add-one-line-braces implies keep-one-line-blocks
|
|
if (shouldAddOneLineBraces)
|
|
setBreakOneLineBlocksMode(false);
|
|
// don't allow add-braces and remove-braces
|
|
if (shouldAddBraces || shouldAddOneLineBraces)
|
|
setRemoveBracesMode(false);
|
|
// don't allow indent-classes and indent-modifiers
|
|
if (getClassIndent())
|
|
setModifierIndent(false);
|
|
}
|
|
|
|
/**
|
|
* get the next formatted line.
|
|
*
|
|
* @return formatted line.
|
|
*/
|
|
string ASFormatter::nextLine()
|
|
{
|
|
const string* newHeader = nullptr;
|
|
isInVirginLine = isVirgin;
|
|
isCharImmediatelyPostComment = false;
|
|
isPreviousCharPostComment = false;
|
|
isCharImmediatelyPostLineComment = false;
|
|
isCharImmediatelyPostOpenBlock = false;
|
|
isCharImmediatelyPostCloseBlock = false;
|
|
isCharImmediatelyPostTemplate = false;
|
|
|
|
while (!isLineReady)
|
|
{
|
|
if (shouldReparseCurrentChar)
|
|
shouldReparseCurrentChar = false;
|
|
else if (!getNextChar())
|
|
{
|
|
breakLine();
|
|
continue;
|
|
}
|
|
else // stuff to do when reading a new character...
|
|
{
|
|
// make sure that a virgin '{' at the beginning of the file will be treated as a block...
|
|
if (isInVirginLine && currentChar == '{'
|
|
&& currentLineBeginsWithBrace
|
|
&& previousCommandChar == ' ')
|
|
previousCommandChar = '{';
|
|
if (isInClassInitializer
|
|
&& isBraceType(braceTypeStack->back(), COMMAND_TYPE))
|
|
isInClassInitializer = false;
|
|
if (isInBraceRunIn)
|
|
isInLineBreak = false;
|
|
if (!isWhiteSpace(currentChar))
|
|
isInBraceRunIn = false;
|
|
isPreviousCharPostComment = isCharImmediatelyPostComment;
|
|
isCharImmediatelyPostComment = false;
|
|
isCharImmediatelyPostTemplate = false;
|
|
isCharImmediatelyPostReturn = false;
|
|
isCharImmediatelyPostThrow = false;
|
|
isCharImmediatelyPostNewDelete = false;
|
|
isCharImmediatelyPostOperator = false;
|
|
isCharImmediatelyPostPointerOrReference = false;
|
|
isCharImmediatelyPostOpenBlock = false;
|
|
isCharImmediatelyPostCloseBlock = false;
|
|
}
|
|
|
|
if ((lineIsLineCommentOnly || lineIsCommentOnly)
|
|
&& currentLine.find("*INDENT-ON*", charNum) != string::npos
|
|
&& isFormattingModeOff)
|
|
{
|
|
isFormattingModeOff = false;
|
|
breakLine();
|
|
formattedLine = currentLine;
|
|
charNum = (int) currentLine.length() - 1;
|
|
continue;
|
|
}
|
|
if (isFormattingModeOff)
|
|
{
|
|
breakLine();
|
|
formattedLine = currentLine;
|
|
charNum = (int) currentLine.length() - 1;
|
|
continue;
|
|
}
|
|
if ((lineIsLineCommentOnly || lineIsCommentOnly)
|
|
&& currentLine.find("*INDENT-OFF*", charNum) != string::npos)
|
|
{
|
|
isFormattingModeOff = true;
|
|
if (isInLineBreak) // is true if not the first line
|
|
breakLine();
|
|
formattedLine = currentLine;
|
|
charNum = (int)currentLine.length() - 1;
|
|
continue;
|
|
}
|
|
|
|
if (shouldBreakLineAtNextChar)
|
|
{
|
|
if (isWhiteSpace(currentChar) && !lineIsEmpty)
|
|
continue;
|
|
isInLineBreak = true;
|
|
shouldBreakLineAtNextChar = false;
|
|
}
|
|
|
|
if (isInExecSQL && !passedSemicolon)
|
|
{
|
|
if (currentChar == ';')
|
|
passedSemicolon = true;
|
|
appendCurrentChar();
|
|
continue;
|
|
}
|
|
|
|
if (isInLineComment)
|
|
{
|
|
formatLineCommentBody();
|
|
continue;
|
|
}
|
|
else if (isInComment)
|
|
{
|
|
formatCommentBody();
|
|
continue;
|
|
}
|
|
|
|
else if (isInQuote)
|
|
{
|
|
formatQuoteBody();
|
|
continue;
|
|
}
|
|
|
|
// not in quote or comment or line comment
|
|
|
|
if (isSequenceReached("//"))
|
|
{
|
|
formatLineCommentOpener();
|
|
testForTimeToSplitFormattedLine();
|
|
continue;
|
|
}
|
|
else if (isSequenceReached("/*"))
|
|
{
|
|
formatCommentOpener();
|
|
testForTimeToSplitFormattedLine();
|
|
continue;
|
|
}
|
|
else if (currentChar == '"'
|
|
|| (currentChar == '\'' && !isDigitSeparator(currentLine, charNum)))
|
|
{
|
|
formatQuoteOpener();
|
|
testForTimeToSplitFormattedLine();
|
|
continue;
|
|
}
|
|
// treat these preprocessor statements as a line comment
|
|
else if (currentChar == '#'
|
|
&& currentLine.find_first_not_of(" \t") == (size_t) charNum)
|
|
{
|
|
string preproc = trim(currentLine.c_str() + charNum + 1);
|
|
if (preproc.length() > 0
|
|
&& isCharPotentialHeader(preproc, 0)
|
|
&& (findKeyword(preproc, 0, "region")
|
|
|| findKeyword(preproc, 0, "endregion")
|
|
|| findKeyword(preproc, 0, "error")
|
|
|| findKeyword(preproc, 0, "warning")
|
|
|| findKeyword(preproc, 0, "line")))
|
|
{
|
|
currentLine = rtrim(currentLine); // trim the end only
|
|
// check for run-in
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{')
|
|
{
|
|
isInLineBreak = true;
|
|
isInBraceRunIn = false;
|
|
}
|
|
if (previousCommandChar == '}')
|
|
currentHeader = nullptr;
|
|
isInLineComment = true;
|
|
appendCurrentChar();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (isInPreprocessor)
|
|
{
|
|
appendCurrentChar();
|
|
continue;
|
|
}
|
|
|
|
if (isInTemplate && shouldCloseTemplates)
|
|
{
|
|
if (previousNonWSChar == '>' && isWhiteSpace(currentChar) && peekNextChar() == '>')
|
|
continue;
|
|
}
|
|
|
|
if (shouldRemoveNextClosingBrace && currentChar == '}')
|
|
{
|
|
currentLine[charNum] = currentChar = ' ';
|
|
shouldRemoveNextClosingBrace = false;
|
|
assert(adjustChecksumIn(-'}'));
|
|
if (isEmptyLine(currentLine))
|
|
continue;
|
|
}
|
|
|
|
// handle white space - needed to simplify the rest.
|
|
if (isWhiteSpace(currentChar))
|
|
{
|
|
appendCurrentChar();
|
|
continue;
|
|
}
|
|
|
|
/* not in MIDDLE of quote or comment or SQL or white-space of any type ... */
|
|
|
|
// check if in preprocessor
|
|
// ** isInPreprocessor will be automatically reset at the beginning
|
|
// of a new line in getnextChar()
|
|
if (currentChar == '#')
|
|
{
|
|
isInPreprocessor = true;
|
|
// check for run-in
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{')
|
|
{
|
|
isInLineBreak = true;
|
|
isInBraceRunIn = false;
|
|
}
|
|
processPreprocessor();
|
|
// if top level it is potentially indentable
|
|
if (shouldIndentPreprocBlock
|
|
&& (isBraceType(braceTypeStack->back(), NULL_TYPE)
|
|
|| isBraceType(braceTypeStack->back(), NAMESPACE_TYPE))
|
|
&& !foundClassHeader
|
|
&& !isInClassInitializer
|
|
&& sourceIterator->tellg() > preprocBlockEnd)
|
|
{
|
|
// indent the #if preprocessor blocks
|
|
string preproc = ASBeautifier::extractPreprocessorStatement(currentLine);
|
|
if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef
|
|
{
|
|
if (isImmediatelyPostPreprocessor)
|
|
breakLine();
|
|
isIndentableProprocessorBlock = isIndentablePreprocessorBlock(currentLine, charNum);
|
|
isIndentableProprocessor = isIndentableProprocessorBlock;
|
|
}
|
|
}
|
|
if (isIndentableProprocessorBlock
|
|
&& charNum < (int) currentLine.length() - 1
|
|
&& isWhiteSpace(currentLine[charNum + 1]))
|
|
{
|
|
size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextText != string::npos)
|
|
currentLine.erase(charNum + 1, nextText - charNum - 1);
|
|
}
|
|
if (isIndentableProprocessorBlock
|
|
&& sourceIterator->tellg() >= preprocBlockEnd)
|
|
isIndentableProprocessorBlock = false;
|
|
// need to fall thru here to reset the variables
|
|
}
|
|
|
|
/* not in preprocessor ... */
|
|
|
|
if (isImmediatelyPostComment)
|
|
{
|
|
caseHeaderFollowsComments = false;
|
|
isImmediatelyPostComment = false;
|
|
isCharImmediatelyPostComment = true;
|
|
}
|
|
|
|
if (isImmediatelyPostLineComment)
|
|
{
|
|
caseHeaderFollowsComments = false;
|
|
isImmediatelyPostLineComment = false;
|
|
isCharImmediatelyPostLineComment = true;
|
|
}
|
|
|
|
if (isImmediatelyPostReturn)
|
|
{
|
|
isImmediatelyPostReturn = false;
|
|
isCharImmediatelyPostReturn = true;
|
|
}
|
|
|
|
if (isImmediatelyPostThrow)
|
|
{
|
|
isImmediatelyPostThrow = false;
|
|
isCharImmediatelyPostThrow = true;
|
|
}
|
|
|
|
if (isImmediatelyPostNewDelete)
|
|
{
|
|
isImmediatelyPostNewDelete = false;
|
|
isCharImmediatelyPostNewDelete = true;
|
|
}
|
|
|
|
if (isImmediatelyPostOperator)
|
|
{
|
|
isImmediatelyPostOperator = false;
|
|
isCharImmediatelyPostOperator = true;
|
|
}
|
|
if (isImmediatelyPostTemplate)
|
|
{
|
|
isImmediatelyPostTemplate = false;
|
|
isCharImmediatelyPostTemplate = true;
|
|
}
|
|
if (isImmediatelyPostPointerOrReference)
|
|
{
|
|
isImmediatelyPostPointerOrReference = false;
|
|
isCharImmediatelyPostPointerOrReference = true;
|
|
}
|
|
|
|
// reset isImmediatelyPostHeader information
|
|
if (isImmediatelyPostHeader)
|
|
{
|
|
// should braces be added
|
|
if (currentChar != '{'
|
|
&& shouldAddBraces
|
|
&& (shouldBreakOneLineStatements || !isHeaderInMultiStatementLine)
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
{
|
|
bool bracesAdded = addBracesToStatement();
|
|
if (bracesAdded && !shouldAddOneLineBraces)
|
|
{
|
|
size_t firstText = currentLine.find_first_not_of(" \t");
|
|
assert(firstText != string::npos);
|
|
if ((int) firstText == charNum || shouldBreakOneLineHeaders)
|
|
breakCurrentOneLineBlock = true;
|
|
}
|
|
}
|
|
// should braces be removed
|
|
else if (currentChar == '{' && shouldRemoveBraces)
|
|
{
|
|
bool bracesRemoved = removeBracesFromStatement();
|
|
if (bracesRemoved)
|
|
{
|
|
shouldRemoveNextClosingBrace = true;
|
|
if (isBeforeAnyLineEndComment(charNum))
|
|
spacePadNum--;
|
|
else if (shouldBreakOneLineBlocks
|
|
|| (currentLineBeginsWithBrace
|
|
&& currentLine.find_first_not_of(" \t") != string::npos))
|
|
shouldBreakLineAtNextChar = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// break 'else-if' if shouldBreakElseIfs is requested
|
|
if (shouldBreakElseIfs
|
|
&& currentHeader == &AS_ELSE
|
|
&& isOkToBreakBlock(braceTypeStack->back())
|
|
&& !isBeforeAnyComment()
|
|
&& (shouldBreakOneLineStatements || !isHeaderInMultiStatementLine))
|
|
{
|
|
string nextText = peekNextText(currentLine.substr(charNum));
|
|
if (nextText.length() > 0
|
|
&& isCharPotentialHeader(nextText, 0)
|
|
&& ASBase::findHeader(nextText, 0, headers) == &AS_IF)
|
|
{
|
|
isInLineBreak = true;
|
|
}
|
|
}
|
|
|
|
// break a header (e.g. if, while, else) from the following statement
|
|
if (shouldBreakOneLineHeaders
|
|
&& peekNextChar() != ' '
|
|
&& (shouldBreakOneLineStatements
|
|
|| (!isHeaderInMultiStatementLine
|
|
&& !isMultiStatementLine()))
|
|
&& isOkToBreakBlock(braceTypeStack->back())
|
|
&& !isBeforeAnyComment())
|
|
{
|
|
if (currentChar == '{')
|
|
{
|
|
if (!currentLineBeginsWithBrace)
|
|
{
|
|
if (isOneLineBlockReached(currentLine, charNum) == 3)
|
|
isInLineBreak = false;
|
|
else
|
|
breakCurrentOneLineBlock = true;
|
|
}
|
|
}
|
|
else if (currentHeader == &AS_ELSE)
|
|
{
|
|
string nextText = peekNextText(currentLine.substr(charNum), true);
|
|
if (nextText.length() > 0
|
|
&& ((isCharPotentialHeader(nextText, 0)
|
|
&& ASBase::findHeader(nextText, 0, headers) != &AS_IF)
|
|
|| nextText[0] == '{'))
|
|
isInLineBreak = true;
|
|
}
|
|
else
|
|
{
|
|
isInLineBreak = true;
|
|
}
|
|
}
|
|
|
|
isImmediatelyPostHeader = false;
|
|
}
|
|
|
|
if (passedSemicolon) // need to break the formattedLine
|
|
{
|
|
passedSemicolon = false;
|
|
if (parenStack->back() == 0 && !isCharImmediatelyPostComment && currentChar != ';') // allow ;;
|
|
{
|
|
// does a one-line block have ending comments?
|
|
if (isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE))
|
|
{
|
|
size_t blockEnd = currentLine.rfind(AS_CLOSE_BRACE);
|
|
assert(blockEnd != string::npos);
|
|
// move ending comments to this formattedLine
|
|
if (isBeforeAnyLineEndComment(blockEnd))
|
|
{
|
|
size_t commentStart = currentLine.find_first_not_of(" \t", blockEnd + 1);
|
|
assert(commentStart != string::npos);
|
|
assert((currentLine.compare(commentStart, 2, "//") == 0)
|
|
|| (currentLine.compare(commentStart, 2, "/*") == 0));
|
|
formattedLine.append(getIndentLength() - 1, ' ');
|
|
// append comment
|
|
int charNumSave = charNum;
|
|
charNum = commentStart;
|
|
while (charNum < (int) currentLine.length())
|
|
{
|
|
currentChar = currentLine[charNum];
|
|
if (currentChar == '\t' && shouldConvertTabs)
|
|
convertTabToSpaces();
|
|
formattedLine.append(1, currentChar);
|
|
++charNum;
|
|
}
|
|
size_t commentLength = currentLine.length() - commentStart;
|
|
currentLine.erase(commentStart, commentLength);
|
|
charNum = charNumSave;
|
|
currentChar = currentLine[charNum];
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
isInExecSQL = false;
|
|
shouldReparseCurrentChar = true;
|
|
if (formattedLine.find_first_not_of(" \t") != string::npos)
|
|
isInLineBreak = true;
|
|
if (needHeaderOpeningBrace)
|
|
{
|
|
isCharImmediatelyPostCloseBlock = true;
|
|
needHeaderOpeningBrace = false;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (passedColon)
|
|
{
|
|
passedColon = false;
|
|
if (parenStack->back() == 0
|
|
&& !isBeforeAnyComment()
|
|
&& (formattedLine.find_first_not_of(" \t") != string::npos))
|
|
{
|
|
shouldReparseCurrentChar = true;
|
|
isInLineBreak = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Check if in template declaration, e.g. foo<bar> or foo<bar,fig>
|
|
if (!isInTemplate && currentChar == '<')
|
|
{
|
|
checkIfTemplateOpener();
|
|
}
|
|
|
|
// handle parens
|
|
if (currentChar == '(' || currentChar == '[' || (isInTemplate && currentChar == '<'))
|
|
{
|
|
questionMarkStack->push_back(foundQuestionMark);
|
|
foundQuestionMark = false;
|
|
parenStack->back()++;
|
|
if (currentChar == '[')
|
|
{
|
|
++squareBracketCount;
|
|
if (getAlignMethodColon() && squareBracketCount == 1 && isCStyle())
|
|
objCColonAlign = findObjCColonAlignment();
|
|
}
|
|
}
|
|
else if (currentChar == ')' || currentChar == ']' || (isInTemplate && currentChar == '>'))
|
|
{
|
|
foundPreCommandHeader = false;
|
|
parenStack->back()--;
|
|
// this can happen in preprocessor directives
|
|
if (parenStack->back() < 0)
|
|
parenStack->back() = 0;
|
|
if (!questionMarkStack->empty())
|
|
{
|
|
foundQuestionMark = questionMarkStack->back();
|
|
questionMarkStack->pop_back();
|
|
}
|
|
if (isInTemplate && currentChar == '>')
|
|
{
|
|
templateDepth--;
|
|
if (templateDepth == 0)
|
|
{
|
|
isInTemplate = false;
|
|
isImmediatelyPostTemplate = true;
|
|
}
|
|
}
|
|
|
|
// check if this parenthesis closes a header, e.g. if (...), while (...)
|
|
if (isInHeader && parenStack->back() == 0)
|
|
{
|
|
isInHeader = false;
|
|
isImmediatelyPostHeader = true;
|
|
foundQuestionMark = false;
|
|
}
|
|
if (currentChar == ']')
|
|
{
|
|
--squareBracketCount;
|
|
if (squareBracketCount <= 0)
|
|
{
|
|
squareBracketCount = 0;
|
|
objCColonAlign = 0;
|
|
}
|
|
}
|
|
if (currentChar == ')')
|
|
{
|
|
foundCastOperator = false;
|
|
if (parenStack->back() == 0)
|
|
endOfAsmReached = true;
|
|
}
|
|
}
|
|
|
|
// handle braces
|
|
if (currentChar == '{' || currentChar == '}')
|
|
{
|
|
// if appendOpeningBrace this was already done for the original brace
|
|
if (currentChar == '{' && !appendOpeningBrace)
|
|
{
|
|
BraceType newBraceType = getBraceType();
|
|
breakCurrentOneLineBlock = false;
|
|
foundNamespaceHeader = false;
|
|
foundClassHeader = false;
|
|
foundStructHeader = false;
|
|
foundInterfaceHeader = false;
|
|
foundPreDefinitionHeader = false;
|
|
foundPreCommandHeader = false;
|
|
foundPreCommandMacro = false;
|
|
foundTrailingReturnType = false;
|
|
isInPotentialCalculation = false;
|
|
isInObjCMethodDefinition = false;
|
|
isInObjCInterface = false;
|
|
isInEnum = false;
|
|
isJavaStaticConstructor = false;
|
|
isCharImmediatelyPostNonInStmt = false;
|
|
needHeaderOpeningBrace = false;
|
|
shouldKeepLineUnbroken = false;
|
|
objCColonAlign = 0;
|
|
|
|
isPreviousBraceBlockRelated = !isBraceType(newBraceType, ARRAY_TYPE);
|
|
braceTypeStack->emplace_back(newBraceType);
|
|
preBraceHeaderStack->emplace_back(currentHeader);
|
|
currentHeader = nullptr;
|
|
structStack->push_back(isInIndentableStruct);
|
|
if (isBraceType(newBraceType, STRUCT_TYPE) && isCStyle())
|
|
isInIndentableStruct = isStructAccessModified(currentLine, charNum);
|
|
else
|
|
isInIndentableStruct = false;
|
|
}
|
|
|
|
// this must be done before the braceTypeStack is popped
|
|
BraceType braceType = braceTypeStack->back();
|
|
bool isOpeningArrayBrace = (isBraceType(braceType, ARRAY_TYPE)
|
|
&& braceTypeStack->size() >= 2
|
|
&& !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2], ARRAY_TYPE)
|
|
);
|
|
|
|
if (currentChar == '}')
|
|
{
|
|
// if a request has been made to append a post block empty line,
|
|
// but the block exists immediately before a closing brace,
|
|
// then there is no need for the post block empty line.
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
if (isInAsm)
|
|
endOfAsmReached = true;
|
|
isInAsmOneLine = isInQuote = false;
|
|
shouldKeepLineUnbroken = false;
|
|
squareBracketCount = 0;
|
|
|
|
if (braceTypeStack->size() > 1)
|
|
{
|
|
previousBraceType = braceTypeStack->back();
|
|
braceTypeStack->pop_back();
|
|
isPreviousBraceBlockRelated = !isBraceType(braceType, ARRAY_TYPE);
|
|
}
|
|
else
|
|
{
|
|
previousBraceType = NULL_TYPE;
|
|
isPreviousBraceBlockRelated = false;
|
|
}
|
|
|
|
if (!preBraceHeaderStack->empty())
|
|
{
|
|
currentHeader = preBraceHeaderStack->back();
|
|
preBraceHeaderStack->pop_back();
|
|
}
|
|
else
|
|
currentHeader = nullptr;
|
|
|
|
if (!structStack->empty())
|
|
{
|
|
isInIndentableStruct = structStack->back();
|
|
structStack->pop_back();
|
|
}
|
|
else
|
|
isInIndentableStruct = false;
|
|
|
|
if (isNonInStatementArray
|
|
&& (!isBraceType(braceTypeStack->back(), ARRAY_TYPE) // check previous brace
|
|
|| peekNextChar() == ';')) // check for "};" added V2.01
|
|
isImmediatelyPostNonInStmt = true;
|
|
|
|
if (!shouldBreakOneLineStatements
|
|
&& ASBeautifier::getNextWord(currentLine, charNum) == AS_ELSE)
|
|
{
|
|
// handle special case of "else" at the end of line
|
|
size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (ASBeautifier::peekNextChar(currentLine, nextText + 3) == ' ')
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
}
|
|
|
|
// format braces
|
|
appendOpeningBrace = false;
|
|
if (isBraceType(braceType, ARRAY_TYPE))
|
|
{
|
|
formatArrayBraces(braceType, isOpeningArrayBrace);
|
|
}
|
|
else
|
|
{
|
|
if (currentChar == '{')
|
|
formatOpeningBrace(braceType);
|
|
else
|
|
formatClosingBrace(braceType);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ((((previousCommandChar == '{' && isPreviousBraceBlockRelated)
|
|
|| ((previousCommandChar == '}'
|
|
&& !isImmediatelyPostEmptyBlock
|
|
&& isPreviousBraceBlockRelated
|
|
&& !isPreviousCharPostComment // Fixes wrongly appended newlines after '}' immediately after comments
|
|
&& peekNextChar() != ' '
|
|
&& !isBraceType(previousBraceType, DEFINITION_TYPE))
|
|
&& !isBraceType(braceTypeStack->back(), DEFINITION_TYPE)))
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
// check for array
|
|
|| (previousCommandChar == '{' // added 9/30/2010
|
|
&& isBraceType(braceTypeStack->back(), ARRAY_TYPE)
|
|
&& !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)
|
|
&& isNonInStatementArray)
|
|
// check for pico one line braces
|
|
|| (formattingStyle == STYLE_PICO
|
|
&& (previousCommandChar == '{' && isPreviousBraceBlockRelated)
|
|
&& isBraceType(braceTypeStack->back(), COMMAND_TYPE)
|
|
&& isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)
|
|
&& braceFormatMode == RUN_IN_MODE)
|
|
)
|
|
{
|
|
isCharImmediatelyPostOpenBlock = (previousCommandChar == '{');
|
|
isCharImmediatelyPostCloseBlock = (previousCommandChar == '}');
|
|
|
|
if (isCharImmediatelyPostOpenBlock
|
|
&& !isCharImmediatelyPostComment
|
|
&& !isCharImmediatelyPostLineComment)
|
|
{
|
|
previousCommandChar = ' ';
|
|
|
|
if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)
|
|
&& (isBraceType(braceTypeStack->back(), BREAK_BLOCK_TYPE)
|
|
|| shouldBreakOneLineBlocks))
|
|
isInLineBreak = true;
|
|
else if (currentLineBeginsWithBrace)
|
|
formatRunIn();
|
|
else
|
|
breakLine();
|
|
}
|
|
else if (braceFormatMode == RUN_IN_MODE
|
|
&& currentChar != '#')
|
|
formatRunIn();
|
|
else
|
|
isInLineBreak = true;
|
|
}
|
|
else if (isCharImmediatelyPostCloseBlock
|
|
&& shouldBreakOneLineStatements
|
|
&& !isCharImmediatelyPostComment
|
|
&& ((isLegalNameChar(currentChar) && currentChar != '.')
|
|
|| currentChar == '+'
|
|
|| currentChar == '-'
|
|
|| currentChar == '*'
|
|
|| currentChar == '&'
|
|
|| currentChar == '('))
|
|
{
|
|
previousCommandChar = ' ';
|
|
isInLineBreak = true;
|
|
}
|
|
}
|
|
|
|
// reset block handling flags
|
|
isImmediatelyPostEmptyBlock = false;
|
|
|
|
// look for headers
|
|
bool isPotentialHeader = isCharPotentialHeader(currentLine, charNum);
|
|
|
|
if (isPotentialHeader && !isInTemplate && squareBracketCount == 0)
|
|
{
|
|
isNonParenHeader = false;
|
|
foundClosingHeader = false;
|
|
|
|
newHeader = findHeader(headers);
|
|
|
|
// Qt headers may be variables in C++
|
|
if (isCStyle()
|
|
&& (newHeader == &AS_FOREVER || newHeader == &AS_FOREACH))
|
|
{
|
|
if (currentLine.find_first_of("=;", charNum) != string::npos)
|
|
newHeader = nullptr;
|
|
}
|
|
if (isJavaStyle()
|
|
&& (newHeader == &AS_SYNCHRONIZED))
|
|
{
|
|
// want synchronized statements not synchronized methods
|
|
if (!isBraceType(braceTypeStack->back(), COMMAND_TYPE))
|
|
newHeader = nullptr;
|
|
}
|
|
else if (newHeader == &AS_USING
|
|
&& ASBeautifier::peekNextChar(
|
|
currentLine, charNum + (*newHeader).length() - 1) != '(')
|
|
newHeader = nullptr;
|
|
|
|
if (newHeader != nullptr)
|
|
{
|
|
foundClosingHeader = isClosingHeader(newHeader);
|
|
|
|
if (!foundClosingHeader)
|
|
{
|
|
// these are closing headers
|
|
if ((newHeader == &AS_WHILE && currentHeader == &AS_DO)
|
|
|| (newHeader == &_AS_FINALLY && currentHeader == &_AS_TRY)
|
|
|| (newHeader == &_AS_EXCEPT && currentHeader == &_AS_TRY))
|
|
foundClosingHeader = true;
|
|
// don't append empty block for these related headers
|
|
else if (isSharpStyle()
|
|
&& previousNonWSChar == '}'
|
|
&& ((newHeader == &AS_SET && currentHeader == &AS_GET)
|
|
|| (newHeader == &AS_REMOVE && currentHeader == &AS_ADD))
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
}
|
|
|
|
// TODO: this can be removed in a future release
|
|
// version 3.0 - break erroneous attached header from previous versions
|
|
if (isSharpStyle()
|
|
&& ((newHeader == &AS_SET && currentHeader == &AS_GET)
|
|
|| (newHeader == &AS_REMOVE && currentHeader == &AS_ADD))
|
|
&& !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)
|
|
&& currentLine[currentLine.find_first_not_of(" \t")] == '}')
|
|
isInLineBreak = true;
|
|
// END TODO
|
|
|
|
const string* previousHeader = currentHeader;
|
|
currentHeader = newHeader;
|
|
needHeaderOpeningBrace = true;
|
|
|
|
// is the previous statement on the same line?
|
|
if ((previousNonWSChar == ';' || previousNonWSChar == ':')
|
|
&& !isInLineBreak
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
{
|
|
// if breaking lines, break the line at the header
|
|
// except for multiple 'case' statements on a line
|
|
if (maxCodeLength != string::npos
|
|
&& previousHeader != &AS_CASE)
|
|
isInLineBreak = true;
|
|
else
|
|
isHeaderInMultiStatementLine = true;
|
|
}
|
|
|
|
if (foundClosingHeader && previousNonWSChar == '}')
|
|
{
|
|
if (isOkToBreakBlock(braceTypeStack->back()))
|
|
isLineBreakBeforeClosingHeader();
|
|
|
|
// get the adjustment for a comment following the closing header
|
|
if (isInLineBreak)
|
|
nextLineSpacePadNum = getNextLineCommentAdjustment();
|
|
else
|
|
spacePadNum = getCurrentLineCommentAdjustment();
|
|
}
|
|
|
|
// check if the found header is non-paren header
|
|
isNonParenHeader = findHeader(nonParenHeaders) != nullptr;
|
|
|
|
if (isNonParenHeader
|
|
&& (currentHeader == &AS_CATCH
|
|
|| currentHeader == &AS_CASE))
|
|
{
|
|
int startChar = charNum + currentHeader->length() - 1;
|
|
if (ASBeautifier::peekNextChar(currentLine, startChar) == '(')
|
|
isNonParenHeader = false;
|
|
}
|
|
|
|
// join 'else if' statements
|
|
if (currentHeader == &AS_IF
|
|
&& previousHeader == &AS_ELSE
|
|
&& isInLineBreak
|
|
&& !shouldBreakElseIfs
|
|
&& !isCharImmediatelyPostLineComment
|
|
&& !isImmediatelyPostPreprocessor)
|
|
{
|
|
// 'else' must be last thing on the line
|
|
size_t start = formattedLine.length() >= 6 ? formattedLine.length() - 6 : 0;
|
|
if (formattedLine.find(AS_ELSE, start) != string::npos)
|
|
{
|
|
appendSpacePad();
|
|
isInLineBreak = false;
|
|
}
|
|
}
|
|
|
|
appendSequence(*currentHeader);
|
|
goForward(currentHeader->length() - 1);
|
|
// if a paren-header is found add a space after it, if needed
|
|
// this checks currentLine, appendSpacePad() checks formattedLine
|
|
// in 'case' and C# 'catch' can be either a paren or non-paren header
|
|
if (shouldPadHeader
|
|
&& !isNonParenHeader
|
|
&& charNum < (int) currentLine.length() - 1 && !isWhiteSpace(currentLine[charNum + 1]))
|
|
appendSpacePad();
|
|
|
|
// Signal that a header has been reached
|
|
// *** But treat a closing while() (as in do...while)
|
|
// as if it were NOT a header since a closing while()
|
|
// should never have a block after it!
|
|
if (currentHeader != &AS_CASE && currentHeader != &AS_DEFAULT
|
|
&& !(foundClosingHeader && currentHeader == &AS_WHILE))
|
|
{
|
|
isInHeader = true;
|
|
|
|
// in C# 'catch' and 'delegate' can be a paren or non-paren header
|
|
if (isNonParenHeader && !isSharpStyleWithParen(currentHeader))
|
|
{
|
|
isImmediatelyPostHeader = true;
|
|
isInHeader = false;
|
|
}
|
|
}
|
|
|
|
if (shouldBreakBlocks
|
|
&& isOkToBreakBlock(braceTypeStack->back())
|
|
&& !isHeaderInMultiStatementLine)
|
|
{
|
|
if (previousHeader == nullptr
|
|
&& !foundClosingHeader
|
|
&& !isCharImmediatelyPostOpenBlock
|
|
&& !isImmediatelyPostCommentOnly)
|
|
{
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
|
|
if (isClosingHeader(currentHeader)
|
|
|| foundClosingHeader)
|
|
{
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
}
|
|
|
|
if (shouldBreakClosingHeaderBlocks
|
|
&& isCharImmediatelyPostCloseBlock
|
|
&& !isImmediatelyPostCommentOnly
|
|
&& !(currentHeader == &AS_WHILE // do-while
|
|
&& foundClosingHeader))
|
|
{
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
}
|
|
|
|
if (currentHeader == &AS_CASE
|
|
|| currentHeader == &AS_DEFAULT)
|
|
isInCase = true;
|
|
|
|
continue;
|
|
}
|
|
else if ((newHeader = findHeader(preDefinitionHeaders)) != nullptr
|
|
&& parenStack->back() == 0
|
|
&& !isInEnum) // not C++11 enum class
|
|
{
|
|
if (newHeader == &AS_NAMESPACE || newHeader == &AS_MODULE)
|
|
foundNamespaceHeader = true;
|
|
if (newHeader == &AS_CLASS)
|
|
foundClassHeader = true;
|
|
if (newHeader == &AS_STRUCT)
|
|
foundStructHeader = true;
|
|
if (newHeader == &AS_INTERFACE)
|
|
foundInterfaceHeader = true;
|
|
foundPreDefinitionHeader = true;
|
|
appendSequence(*newHeader);
|
|
goForward(newHeader->length() - 1);
|
|
|
|
continue;
|
|
}
|
|
else if ((newHeader = findHeader(preCommandHeaders)) != nullptr)
|
|
{
|
|
// a 'const' variable is not a preCommandHeader
|
|
if (previousNonWSChar == ')')
|
|
foundPreCommandHeader = true;
|
|
}
|
|
else if ((newHeader = findHeader(castOperators)) != nullptr)
|
|
{
|
|
foundCastOperator = true;
|
|
appendSequence(*newHeader);
|
|
goForward(newHeader->length() - 1);
|
|
continue;
|
|
}
|
|
} // (isPotentialHeader && !isInTemplate)
|
|
|
|
if (isInLineBreak) // OK to break line here
|
|
{
|
|
breakLine();
|
|
if (isInVirginLine) // adjust for the first line
|
|
{
|
|
lineCommentNoBeautify = lineCommentNoIndent;
|
|
lineCommentNoIndent = false;
|
|
if (isImmediatelyPostPreprocessor)
|
|
{
|
|
isInIndentablePreproc = isIndentableProprocessor;
|
|
isIndentableProprocessor = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (previousNonWSChar == '}' || currentChar == ';')
|
|
{
|
|
if (currentChar == ';')
|
|
{
|
|
squareBracketCount = 0;
|
|
|
|
if (((shouldBreakOneLineStatements
|
|
|| isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE))
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
&& !(attachClosingBraceMode && peekNextChar() == '}'))
|
|
{
|
|
passedSemicolon = true;
|
|
}
|
|
else if (!shouldBreakOneLineStatements
|
|
&& ASBeautifier::getNextWord(currentLine, charNum) == AS_ELSE)
|
|
{
|
|
// handle special case of "else" at the end of line
|
|
size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (ASBeautifier::peekNextChar(currentLine, nextText + 3) == ' ')
|
|
passedSemicolon = true;
|
|
}
|
|
|
|
if (shouldBreakBlocks
|
|
&& currentHeader != nullptr
|
|
&& currentHeader != &AS_CASE
|
|
&& currentHeader != &AS_DEFAULT
|
|
&& !isHeaderInMultiStatementLine
|
|
&& parenStack->back() == 0)
|
|
{
|
|
isAppendPostBlockEmptyLineRequested = true;
|
|
}
|
|
}
|
|
if (currentChar != ';'
|
|
|| (needHeaderOpeningBrace && parenStack->back() == 0))
|
|
currentHeader = nullptr;
|
|
resetEndOfStatement();
|
|
}
|
|
|
|
if (currentChar == ':'
|
|
&& previousChar != ':' // not part of '::'
|
|
&& peekNextChar() != ':') // not part of '::'
|
|
{
|
|
if (isInCase)
|
|
{
|
|
isInCase = false;
|
|
if (shouldBreakOneLineStatements)
|
|
passedColon = true;
|
|
}
|
|
else if (isCStyle() // for C/C++ only
|
|
&& isOkToBreakBlock(braceTypeStack->back())
|
|
&& shouldBreakOneLineStatements
|
|
&& !foundQuestionMark // not in a ?: sequence
|
|
&& !foundPreDefinitionHeader // not in a definition block
|
|
&& previousCommandChar != ')' // not after closing paren of a method header
|
|
&& !foundPreCommandHeader // not after a 'noexcept'
|
|
&& squareBracketCount == 0 // not in objC method call
|
|
&& !isInObjCMethodDefinition // not objC '-' or '+' method
|
|
&& !isInObjCInterface // not objC @interface
|
|
&& !isInObjCSelector // not objC @selector
|
|
&& !isDigit(peekNextChar()) // not a bit field
|
|
&& !isInEnum // not an enum with a base type
|
|
&& !isInAsm // not in extended assembler
|
|
&& !isInAsmOneLine // not in extended assembler
|
|
&& !isInAsmBlock) // not in extended assembler
|
|
{
|
|
passedColon = true;
|
|
}
|
|
|
|
if (isCStyle()
|
|
&& shouldPadMethodColon
|
|
&& (squareBracketCount > 0 || isInObjCMethodDefinition || isInObjCSelector)
|
|
&& !foundQuestionMark) // not in a ?: sequence
|
|
padObjCMethodColon();
|
|
|
|
if (isInObjCInterface)
|
|
{
|
|
appendSpacePad();
|
|
if ((int) currentLine.length() > charNum + 1
|
|
&& !isWhiteSpace(currentLine[charNum + 1]))
|
|
currentLine.insert(charNum + 1, " ");
|
|
}
|
|
|
|
if (isClassInitializer())
|
|
isInClassInitializer = true;
|
|
}
|
|
|
|
if (currentChar == '?')
|
|
foundQuestionMark = true;
|
|
|
|
if (isPotentialHeader && !isInTemplate)
|
|
{
|
|
if (findKeyword(currentLine, charNum, AS_NEW)
|
|
|| findKeyword(currentLine, charNum, AS_DELETE))
|
|
{
|
|
isInPotentialCalculation = false;
|
|
isImmediatelyPostNewDelete = true;
|
|
}
|
|
|
|
if (findKeyword(currentLine, charNum, AS_RETURN))
|
|
{
|
|
isInPotentialCalculation = true; // return is the same as an = sign
|
|
isImmediatelyPostReturn = true;
|
|
}
|
|
|
|
if (findKeyword(currentLine, charNum, AS_OPERATOR))
|
|
isImmediatelyPostOperator = true;
|
|
|
|
if (findKeyword(currentLine, charNum, AS_ENUM))
|
|
{
|
|
size_t firstNum = currentLine.find_first_of("(){},/");
|
|
if (firstNum == string::npos
|
|
|| currentLine[firstNum] == '{'
|
|
|| currentLine[firstNum] == '/')
|
|
isInEnum = true;
|
|
}
|
|
|
|
if (isCStyle()
|
|
&& findKeyword(currentLine, charNum, AS_THROW)
|
|
&& previousCommandChar != ')'
|
|
&& !foundPreCommandHeader) // 'const' throw()
|
|
isImmediatelyPostThrow = true;
|
|
|
|
if (isCStyle() && findKeyword(currentLine, charNum, AS_EXTERN) && isExternC())
|
|
isInExternC = true;
|
|
|
|
if (isCStyle() && findKeyword(currentLine, charNum, AS_AUTO)
|
|
&& (isBraceType(braceTypeStack->back(), NULL_TYPE)
|
|
|| isBraceType(braceTypeStack->back(), NAMESPACE_TYPE)
|
|
|| isBraceType(braceTypeStack->back(), CLASS_TYPE)))
|
|
foundTrailingReturnType = true;
|
|
|
|
// Objective-C NSException macros are preCommandHeaders
|
|
if (isCStyle() && findKeyword(currentLine, charNum, AS_NS_DURING))
|
|
foundPreCommandMacro = true;
|
|
if (isCStyle() && findKeyword(currentLine, charNum, AS_NS_HANDLER))
|
|
foundPreCommandMacro = true;
|
|
|
|
if (isCStyle() && isExecSQL(currentLine, charNum))
|
|
isInExecSQL = true;
|
|
|
|
if (isCStyle())
|
|
{
|
|
if (findKeyword(currentLine, charNum, AS_ASM)
|
|
|| findKeyword(currentLine, charNum, AS__ASM__))
|
|
{
|
|
isInAsm = true;
|
|
}
|
|
else if (findKeyword(currentLine, charNum, AS_MS_ASM) // microsoft specific
|
|
|| findKeyword(currentLine, charNum, AS_MS__ASM))
|
|
{
|
|
int index = 4;
|
|
if (peekNextChar() == '_') // check for __asm
|
|
index = 5;
|
|
|
|
char peekedChar = ASBase::peekNextChar(currentLine, charNum + index);
|
|
if (peekedChar == '{' || peekedChar == ' ')
|
|
isInAsmBlock = true;
|
|
else
|
|
isInAsmOneLine = true;
|
|
}
|
|
}
|
|
|
|
if (isJavaStyle()
|
|
&& (findKeyword(currentLine, charNum, AS_STATIC)
|
|
&& isNextCharOpeningBrace(charNum + 6)))
|
|
isJavaStaticConstructor = true;
|
|
|
|
if (isSharpStyle()
|
|
&& (findKeyword(currentLine, charNum, AS_DELEGATE)
|
|
|| findKeyword(currentLine, charNum, AS_UNCHECKED)))
|
|
isSharpDelegate = true;
|
|
|
|
// append the entire name
|
|
string name = getCurrentWord(currentLine, charNum);
|
|
// must pad the 'and' and 'or' operators if required
|
|
if (name == "and" || name == "or")
|
|
{
|
|
if (shouldPadOperators && previousNonWSChar != ':')
|
|
{
|
|
appendSpacePad();
|
|
appendOperator(name);
|
|
goForward(name.length() - 1);
|
|
if (!isBeforeAnyComment()
|
|
&& !(currentLine.compare(charNum + 1, 1, AS_SEMICOLON) == 0)
|
|
&& !(currentLine.compare(charNum + 1, 2, AS_SCOPE_RESOLUTION) == 0))
|
|
appendSpaceAfter();
|
|
}
|
|
else
|
|
{
|
|
appendOperator(name);
|
|
goForward(name.length() - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
appendSequence(name);
|
|
goForward(name.length() - 1);
|
|
}
|
|
|
|
continue;
|
|
|
|
} // (isPotentialHeader && !isInTemplate)
|
|
|
|
// determine if this is an Objective-C statement
|
|
|
|
if (currentChar == '@'
|
|
&& isCharPotentialHeader(currentLine, charNum + 1)
|
|
&& findKeyword(currentLine, charNum + 1, AS_INTERFACE)
|
|
&& isBraceType(braceTypeStack->back(), NULL_TYPE))
|
|
{
|
|
isInObjCInterface = true;
|
|
string name = '@' + AS_INTERFACE;
|
|
appendSequence(name);
|
|
goForward(name.length() - 1);
|
|
continue;
|
|
}
|
|
else if (currentChar == '@'
|
|
&& isCharPotentialHeader(currentLine, charNum + 1)
|
|
&& findKeyword(currentLine, charNum + 1, AS_SELECTOR))
|
|
{
|
|
isInObjCSelector = true;
|
|
string name = '@' + AS_SELECTOR;
|
|
appendSequence(name);
|
|
goForward(name.length() - 1);
|
|
continue;
|
|
}
|
|
else if ((currentChar == '-' || currentChar == '+')
|
|
&& (int) currentLine.find_first_not_of(" \t") == charNum
|
|
&& peekNextChar() == '('
|
|
&& isBraceType(braceTypeStack->back(), NULL_TYPE)
|
|
&& !isInPotentialCalculation)
|
|
{
|
|
isInObjCMethodDefinition = true;
|
|
isImmediatelyPostObjCMethodPrefix = true;
|
|
isInObjCInterface = false;
|
|
if (getAlignMethodColon())
|
|
objCColonAlign = findObjCColonAlignment();
|
|
appendCurrentChar();
|
|
continue;
|
|
}
|
|
|
|
// determine if this is a potential calculation
|
|
|
|
bool isPotentialOperator = isCharPotentialOperator(currentChar);
|
|
newHeader = nullptr;
|
|
|
|
if (isPotentialOperator)
|
|
{
|
|
newHeader = findOperator(operators);
|
|
|
|
// check for Java ? wildcard
|
|
if (newHeader != nullptr
|
|
&& newHeader == &AS_GCC_MIN_ASSIGN
|
|
&& isJavaStyle()
|
|
&& isInTemplate)
|
|
newHeader = nullptr;
|
|
|
|
if (newHeader != nullptr)
|
|
{
|
|
if (newHeader == &AS_LAMBDA)
|
|
foundPreCommandHeader = true;
|
|
|
|
// correct mistake of two >> closing a template
|
|
if (isInTemplate && (newHeader == &AS_GR_GR || newHeader == &AS_GR_GR_GR))
|
|
newHeader = &AS_GR;
|
|
|
|
if (!isInPotentialCalculation)
|
|
{
|
|
// must determine if newHeader is an assignment operator
|
|
// do NOT use findOperator - the length must be exact!!!
|
|
if (find(begin(*assignmentOperators), end(*assignmentOperators), newHeader)
|
|
!= end(*assignmentOperators))
|
|
{
|
|
foundPreCommandHeader = false;
|
|
char peekedChar = peekNextChar();
|
|
isInPotentialCalculation = !(newHeader == &AS_EQUAL && peekedChar == '*')
|
|
&& !(newHeader == &AS_EQUAL && peekedChar == '&')
|
|
&& !isCharImmediatelyPostOperator;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// process pointers and references
|
|
// check newHeader to eliminate things like '&&' sequence
|
|
if (newHeader != nullptr && !isJavaStyle()
|
|
&& (newHeader == &AS_MULT
|
|
|| newHeader == &AS_BIT_AND
|
|
|| newHeader == &AS_BIT_XOR
|
|
|| newHeader == &AS_AND)
|
|
&& isPointerOrReference())
|
|
{
|
|
if (!isDereferenceOrAddressOf() && !isOperatorPaddingDisabled())
|
|
formatPointerOrReference();
|
|
else
|
|
{
|
|
appendOperator(*newHeader);
|
|
goForward(newHeader->length() - 1);
|
|
}
|
|
isImmediatelyPostPointerOrReference = true;
|
|
continue;
|
|
}
|
|
|
|
if (shouldPadOperators && newHeader != nullptr && !isOperatorPaddingDisabled())
|
|
{
|
|
padOperators(newHeader);
|
|
continue;
|
|
}
|
|
|
|
// remove spaces before commas
|
|
if (currentChar == ',')
|
|
{
|
|
const size_t len = formattedLine.length();
|
|
size_t lastText = formattedLine.find_last_not_of(' ');
|
|
if (lastText != string::npos && lastText < len - 1)
|
|
{
|
|
formattedLine.resize(lastText + 1);
|
|
int size_diff = len - (lastText + 1);
|
|
spacePadNum -= size_diff;
|
|
}
|
|
}
|
|
|
|
// pad commas and semi-colons
|
|
if (currentChar == ';'
|
|
|| (currentChar == ',' && (shouldPadOperators || shouldPadCommas)))
|
|
{
|
|
char nextChar = ' ';
|
|
if (charNum + 1 < (int) currentLine.length())
|
|
nextChar = currentLine[charNum + 1];
|
|
if (!isWhiteSpace(nextChar)
|
|
&& nextChar != '}'
|
|
&& nextChar != ')'
|
|
&& nextChar != ']'
|
|
&& nextChar != '>'
|
|
&& nextChar != ';'
|
|
&& !isBeforeAnyComment()
|
|
/* && !(isBraceType(braceTypeStack->back(), ARRAY_TYPE)) */
|
|
)
|
|
{
|
|
appendCurrentChar();
|
|
appendSpaceAfter();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// pad parens
|
|
if (currentChar == '(' || currentChar == ')')
|
|
{
|
|
if (currentChar == '(')
|
|
{
|
|
if (shouldPadHeader
|
|
&& (isCharImmediatelyPostReturn
|
|
|| isCharImmediatelyPostThrow
|
|
|| isCharImmediatelyPostNewDelete))
|
|
appendSpacePad();
|
|
}
|
|
|
|
if (shouldPadParensOutside || shouldPadParensInside || shouldUnPadParens || shouldPadFirstParen)
|
|
padParens();
|
|
else
|
|
appendCurrentChar();
|
|
|
|
if (isInObjCMethodDefinition)
|
|
{
|
|
if (currentChar == '(' && isImmediatelyPostObjCMethodPrefix)
|
|
{
|
|
if (shouldPadMethodPrefix || shouldUnPadMethodPrefix)
|
|
padObjCMethodPrefix();
|
|
isImmediatelyPostObjCMethodPrefix = false;
|
|
isInObjCReturnType = true;
|
|
}
|
|
else if (currentChar == ')' && isInObjCReturnType)
|
|
{
|
|
if (shouldPadReturnType || shouldUnPadReturnType)
|
|
padObjCReturnType();
|
|
isInObjCReturnType = false;
|
|
}
|
|
else if (shouldPadParamType || shouldUnPadParamType)
|
|
padObjCParamType();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// bypass the entire operator
|
|
if (newHeader != nullptr)
|
|
{
|
|
appendOperator(*newHeader);
|
|
goForward(newHeader->length() - 1);
|
|
continue;
|
|
}
|
|
|
|
appendCurrentChar();
|
|
|
|
} // end of while loop * end of while loop * end of while loop * end of while loop
|
|
|
|
// return a beautified (i.e. correctly indented) line.
|
|
|
|
string beautifiedLine;
|
|
size_t readyFormattedLineLength = trim(readyFormattedLine).length();
|
|
bool isInNamespace = isBraceType(braceTypeStack->back(), NAMESPACE_TYPE);
|
|
|
|
if (prependEmptyLine // prepend a blank line before this formatted line
|
|
&& readyFormattedLineLength > 0
|
|
&& previousReadyFormattedLineLength > 0)
|
|
{
|
|
isLineReady = true; // signal a waiting readyFormattedLine
|
|
beautifiedLine = beautify("");
|
|
previousReadyFormattedLineLength = 0;
|
|
// call the enhancer for new empty lines
|
|
enhancer->enhance(beautifiedLine, isInNamespace, isInPreprocessorBeautify, isInBeautifySQL);
|
|
}
|
|
else // format the current formatted line
|
|
{
|
|
isLineReady = false;
|
|
runInIndentContinuation = runInIndentChars;
|
|
beautifiedLine = beautify(readyFormattedLine);
|
|
previousReadyFormattedLineLength = readyFormattedLineLength;
|
|
// the enhancer is not called for no-indent line comments
|
|
if (!lineCommentNoBeautify && !isFormattingModeOff)
|
|
enhancer->enhance(beautifiedLine, isInNamespace, isInPreprocessorBeautify, isInBeautifySQL);
|
|
runInIndentChars = 0;
|
|
lineCommentNoBeautify = lineCommentNoIndent;
|
|
lineCommentNoIndent = false;
|
|
isInIndentablePreproc = isIndentableProprocessor;
|
|
isIndentableProprocessor = false;
|
|
isElseHeaderIndent = elseHeaderFollowsComments;
|
|
isCaseHeaderCommentIndent = caseHeaderFollowsComments;
|
|
objCColonAlignSubsequent = objCColonAlign;
|
|
if (isCharImmediatelyPostNonInStmt)
|
|
{
|
|
isNonInStatementArray = false;
|
|
isCharImmediatelyPostNonInStmt = false;
|
|
}
|
|
isInPreprocessorBeautify = isInPreprocessor; // used by ASEnhancer
|
|
isInBeautifySQL = isInExecSQL; // used by ASEnhancer
|
|
}
|
|
|
|
prependEmptyLine = false;
|
|
assert(computeChecksumOut(beautifiedLine));
|
|
return beautifiedLine;
|
|
}
|
|
|
|
/**
|
|
* check if there are any indented lines ready to be read by nextLine()
|
|
*
|
|
* @return are there any indented lines ready?
|
|
*/
|
|
bool ASFormatter::hasMoreLines() const
|
|
{
|
|
return !endOfCodeReached;
|
|
}
|
|
|
|
/**
|
|
* comparison function for BraceType enum
|
|
*/
|
|
bool ASFormatter::isBraceType(BraceType a, BraceType b) const
|
|
{
|
|
if (a == NULL_TYPE || b == NULL_TYPE)
|
|
return (a == b);
|
|
return ((a & b) == b);
|
|
}
|
|
|
|
/**
|
|
* set the formatting style.
|
|
*
|
|
* @param style the formatting style.
|
|
*/
|
|
void ASFormatter::setFormattingStyle(FormatStyle style)
|
|
{
|
|
formattingStyle = style;
|
|
}
|
|
|
|
/**
|
|
* set the add braces mode.
|
|
* options:
|
|
* true braces added to headers for single line statements.
|
|
* false braces NOT added to headers for single line statements.
|
|
*
|
|
* @param state the add braces state.
|
|
*/
|
|
void ASFormatter::setAddBracesMode(bool state)
|
|
{
|
|
shouldAddBraces = state;
|
|
}
|
|
|
|
/**
|
|
* set the add one line braces mode.
|
|
* options:
|
|
* true one line braces added to headers for single line statements.
|
|
* false one line braces NOT added to headers for single line statements.
|
|
*
|
|
* @param state the add one line braces state.
|
|
*/
|
|
void ASFormatter::setAddOneLineBracesMode(bool state)
|
|
{
|
|
shouldAddBraces = state;
|
|
shouldAddOneLineBraces = state;
|
|
}
|
|
|
|
/**
|
|
* set the remove braces mode.
|
|
* options:
|
|
* true braces removed from headers for single line statements.
|
|
* false braces NOT removed from headers for single line statements.
|
|
*
|
|
* @param state the remove braces state.
|
|
*/
|
|
void ASFormatter::setRemoveBracesMode(bool state)
|
|
{
|
|
shouldRemoveBraces = state;
|
|
}
|
|
|
|
// retained for compatability with release 2.06
|
|
// "Brackets" have been changed to "Braces" in 3.0
|
|
// it is referenced only by the old "bracket" options
|
|
void ASFormatter::setAddBracketsMode(bool state)
|
|
{
|
|
setAddBracesMode(state);
|
|
}
|
|
|
|
// retained for compatability with release 2.06
|
|
// "Brackets" have been changed to "Braces" in 3.0
|
|
// it is referenced only by the old "bracket" options
|
|
void ASFormatter::setAddOneLineBracketsMode(bool state)
|
|
{
|
|
setAddOneLineBracesMode(state);
|
|
}
|
|
|
|
// retained for compatability with release 2.06
|
|
// "Brackets" have been changed to "Braces" in 3.0
|
|
// it is referenced only by the old "bracket" options
|
|
void ASFormatter::setRemoveBracketsMode(bool state)
|
|
{
|
|
setRemoveBracesMode(state);
|
|
}
|
|
|
|
// retained for compatability with release 2.06
|
|
// "Brackets" have been changed to "Braces" in 3.0
|
|
// it is referenced only by the old "bracket" options
|
|
void ASFormatter::setBreakClosingHeaderBracketsMode(bool state)
|
|
{
|
|
setBreakClosingHeaderBracesMode(state);
|
|
}
|
|
|
|
|
|
/**
|
|
* set the brace formatting mode.
|
|
* options:
|
|
*
|
|
* @param mode the brace formatting mode.
|
|
*/
|
|
void ASFormatter::setBraceFormatMode(BraceMode mode)
|
|
{
|
|
braceFormatMode = mode;
|
|
}
|
|
|
|
/**
|
|
* set 'break after' mode for maximum code length
|
|
*
|
|
* @param state the 'break after' mode.
|
|
*/
|
|
void ASFormatter::setBreakAfterMode(bool state)
|
|
{
|
|
shouldBreakLineAfterLogical = state;
|
|
}
|
|
|
|
/**
|
|
* set closing header brace breaking mode
|
|
* options:
|
|
* true braces just before closing headers (e.g. 'else', 'catch')
|
|
* will be broken, even if standard braces are attached.
|
|
* false closing header braces will be treated as standard braces.
|
|
*
|
|
* @param state the closing header brace breaking mode.
|
|
*/
|
|
void ASFormatter::setBreakClosingHeaderBracesMode(bool state)
|
|
{
|
|
shouldBreakClosingHeaderBraces = state;
|
|
}
|
|
|
|
/**
|
|
* set 'else if()' breaking mode
|
|
* options:
|
|
* true 'else' headers will be broken from their succeeding 'if' headers.
|
|
* false 'else' headers will be attached to their succeeding 'if' headers.
|
|
*
|
|
* @param state the 'else if()' breaking mode.
|
|
*/
|
|
void ASFormatter::setBreakElseIfsMode(bool state)
|
|
{
|
|
shouldBreakElseIfs = state;
|
|
}
|
|
|
|
/**
|
|
* set comma padding mode.
|
|
* options:
|
|
* true statement commas and semicolons will be padded with spaces around them.
|
|
* false statement commas and semicolons will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setCommaPaddingMode(bool state)
|
|
{
|
|
shouldPadCommas = state;
|
|
}
|
|
|
|
/**
|
|
* set maximum code length
|
|
*
|
|
* @param max the maximum code length.
|
|
*/
|
|
void ASFormatter::setMaxCodeLength(int max)
|
|
{
|
|
maxCodeLength = max;
|
|
}
|
|
|
|
/**
|
|
* set operator padding mode.
|
|
* options:
|
|
* true statement operators will be padded with spaces around them.
|
|
* false statement operators will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setOperatorPaddingMode(bool state)
|
|
{
|
|
shouldPadOperators = state;
|
|
}
|
|
|
|
/**
|
|
* set parenthesis outside padding mode.
|
|
* options:
|
|
* true statement parentheses will be padded with spaces around them.
|
|
* false statement parentheses will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setParensOutsidePaddingMode(bool state)
|
|
{
|
|
shouldPadParensOutside = state;
|
|
}
|
|
|
|
/**
|
|
* set parenthesis inside padding mode.
|
|
* options:
|
|
* true statement parenthesis will be padded with spaces around them.
|
|
* false statement parenthesis will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setParensInsidePaddingMode(bool state)
|
|
{
|
|
shouldPadParensInside = state;
|
|
}
|
|
|
|
/**
|
|
* set padding mode before one or more open parentheses.
|
|
* options:
|
|
* true first open parenthesis will be padded with a space before.
|
|
* false first open parenthesis will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setParensFirstPaddingMode(bool state)
|
|
{
|
|
shouldPadFirstParen = state;
|
|
}
|
|
|
|
/**
|
|
* set header padding mode.
|
|
* options:
|
|
* true headers will be padded with spaces around them.
|
|
* false headers will not be padded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setParensHeaderPaddingMode(bool state)
|
|
{
|
|
shouldPadHeader = state;
|
|
}
|
|
|
|
/**
|
|
* set parenthesis unpadding mode.
|
|
* options:
|
|
* true statement parenthesis will be unpadded with spaces removed around them.
|
|
* false statement parenthesis will not be unpadded.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setParensUnPaddingMode(bool state)
|
|
{
|
|
shouldUnPadParens = state;
|
|
}
|
|
|
|
/**
|
|
* set the state of the preprocessor indentation option.
|
|
* If true, #ifdef blocks at level 0 will be indented.
|
|
*
|
|
* @param state state of option.
|
|
*/
|
|
void ASFormatter::setPreprocBlockIndent(bool state)
|
|
{
|
|
shouldIndentPreprocBlock = state;
|
|
}
|
|
|
|
/**
|
|
* Set strip comment prefix mode.
|
|
* options:
|
|
* true strip leading '*' in a comment.
|
|
* false leading '*' in a comment will be left unchanged.
|
|
*
|
|
* @param state the strip comment prefix mode.
|
|
*/
|
|
void ASFormatter::setStripCommentPrefix(bool state)
|
|
{
|
|
shouldStripCommentPrefix = state;
|
|
}
|
|
|
|
/**
|
|
* set objective-c '-' or '+' class prefix padding mode.
|
|
* options:
|
|
* true class prefix will be padded a spaces after them.
|
|
* false class prefix will be left unchanged.
|
|
*
|
|
* @param state the padding mode.
|
|
*/
|
|
void ASFormatter::setMethodPrefixPaddingMode(bool state)
|
|
{
|
|
shouldPadMethodPrefix = state;
|
|
}
|
|
|
|
/**
|
|
* set objective-c '-' or '+' class prefix unpadding mode.
|
|
* options:
|
|
* true class prefix will be unpadded with spaces after them removed.
|
|
* false class prefix will left unchanged.
|
|
*
|
|
* @param state the unpadding mode.
|
|
*/
|
|
void ASFormatter::setMethodPrefixUnPaddingMode(bool state)
|
|
{
|
|
shouldUnPadMethodPrefix = state;
|
|
}
|
|
|
|
// set objective-c '-' or '+' return type padding mode.
|
|
void ASFormatter::setReturnTypePaddingMode(bool state)
|
|
{
|
|
shouldPadReturnType = state;
|
|
}
|
|
|
|
// set objective-c '-' or '+' return type unpadding mode.
|
|
void ASFormatter::setReturnTypeUnPaddingMode(bool state)
|
|
{
|
|
shouldUnPadReturnType = state;
|
|
}
|
|
|
|
// set objective-c method parameter type padding mode.
|
|
void ASFormatter::setParamTypePaddingMode(bool state)
|
|
{
|
|
shouldPadParamType = state;
|
|
}
|
|
|
|
// set objective-c method parameter type unpadding mode.
|
|
void ASFormatter::setParamTypeUnPaddingMode(bool state)
|
|
{
|
|
shouldUnPadParamType = state;
|
|
}
|
|
|
|
/**
|
|
* set objective-c method colon padding mode.
|
|
*
|
|
* @param mode objective-c colon padding mode.
|
|
*/
|
|
void ASFormatter::setObjCColonPaddingMode(ObjCColonPad mode)
|
|
{
|
|
shouldPadMethodColon = true;
|
|
objCColonPadMode = mode;
|
|
}
|
|
|
|
/**
|
|
* set option to attach closing braces
|
|
*
|
|
* @param state true = attach, false = don't attach.
|
|
*/
|
|
void ASFormatter::setAttachClosingBraceMode(bool state)
|
|
{
|
|
attachClosingBraceMode = state;
|
|
}
|
|
|
|
/**
|
|
* set option to attach class braces
|
|
*
|
|
* @param state true = attach, false = use style default.
|
|
*/
|
|
void ASFormatter::setAttachClass(bool state)
|
|
{
|
|
shouldAttachClass = state;
|
|
}
|
|
|
|
/**
|
|
* set option to attach extern "C" braces
|
|
*
|
|
* @param state true = attach, false = use style default.
|
|
*/
|
|
void ASFormatter::setAttachExternC(bool state)
|
|
{
|
|
shouldAttachExternC = state;
|
|
}
|
|
|
|
/**
|
|
* set option to attach namespace braces
|
|
*
|
|
* @param state true = attach, false = use style default.
|
|
*/
|
|
void ASFormatter::setAttachNamespace(bool state)
|
|
{
|
|
shouldAttachNamespace = state;
|
|
}
|
|
|
|
/**
|
|
* set option to attach inline braces
|
|
*
|
|
* @param state true = attach, false = use style default.
|
|
*/
|
|
void ASFormatter::setAttachInline(bool state)
|
|
{
|
|
shouldAttachInline = state;
|
|
}
|
|
|
|
void ASFormatter::setAttachClosingWhile(bool state)
|
|
{
|
|
shouldAttachClosingWhile = state;
|
|
}
|
|
|
|
/**
|
|
* set option to break/not break one-line blocks
|
|
*
|
|
* @param state true = break, false = don't break.
|
|
*/
|
|
void ASFormatter::setBreakOneLineBlocksMode(bool state)
|
|
{
|
|
shouldBreakOneLineBlocks = state;
|
|
}
|
|
|
|
/**
|
|
* set one line headers breaking mode
|
|
*/
|
|
void ASFormatter::setBreakOneLineHeadersMode(bool state)
|
|
{
|
|
shouldBreakOneLineHeaders = state;
|
|
}
|
|
|
|
/**
|
|
* set option to break/not break lines consisting of multiple statements.
|
|
*
|
|
* @param state true = break, false = don't break.
|
|
*/
|
|
void ASFormatter::setBreakOneLineStatementsMode(bool state)
|
|
{
|
|
shouldBreakOneLineStatements = state;
|
|
}
|
|
|
|
void ASFormatter::setCloseTemplatesMode(bool state)
|
|
{
|
|
shouldCloseTemplates = state;
|
|
}
|
|
|
|
/**
|
|
* set option to convert tabs to spaces.
|
|
*
|
|
* @param state true = convert, false = don't convert.
|
|
*/
|
|
void ASFormatter::setTabSpaceConversionMode(bool state)
|
|
{
|
|
shouldConvertTabs = state;
|
|
}
|
|
|
|
/**
|
|
* set option to indent comments in column 1.
|
|
*
|
|
* @param state true = indent, false = don't indent.
|
|
*/
|
|
void ASFormatter::setIndentCol1CommentsMode(bool state)
|
|
{
|
|
shouldIndentCol1Comments = state;
|
|
}
|
|
|
|
/**
|
|
* set option to force all line ends to a particular style.
|
|
*
|
|
* @param fmt format enum value
|
|
*/
|
|
void ASFormatter::setLineEndFormat(LineEndFormat fmt)
|
|
{
|
|
lineEnd = fmt;
|
|
}
|
|
|
|
/**
|
|
* set option to break unrelated blocks of code with empty lines.
|
|
*
|
|
* @param state true = convert, false = don't convert.
|
|
*/
|
|
void ASFormatter::setBreakBlocksMode(bool state)
|
|
{
|
|
shouldBreakBlocks = state;
|
|
}
|
|
|
|
/**
|
|
* set option to break closing header blocks of code (such as 'else', 'catch', ...) with empty lines.
|
|
*
|
|
* @param state true = convert, false = don't convert.
|
|
*/
|
|
void ASFormatter::setBreakClosingHeaderBlocksMode(bool state)
|
|
{
|
|
shouldBreakClosingHeaderBlocks = state;
|
|
}
|
|
|
|
/**
|
|
* set option to delete empty lines.
|
|
*
|
|
* @param state true = delete, false = don't delete.
|
|
*/
|
|
void ASFormatter::setDeleteEmptyLinesMode(bool state)
|
|
{
|
|
shouldDeleteEmptyLines = state;
|
|
}
|
|
|
|
/**
|
|
* set the pointer alignment.
|
|
*
|
|
* @param alignment the pointer alignment.
|
|
*/
|
|
void ASFormatter::setPointerAlignment(PointerAlign alignment)
|
|
{
|
|
pointerAlignment = alignment;
|
|
}
|
|
|
|
void ASFormatter::setReferenceAlignment(ReferenceAlign alignment)
|
|
{
|
|
referenceAlignment = alignment;
|
|
}
|
|
|
|
/**
|
|
* jump over several characters.
|
|
*
|
|
* @param i the number of characters to jump over.
|
|
*/
|
|
void ASFormatter::goForward(int i)
|
|
{
|
|
while (--i >= 0)
|
|
getNextChar();
|
|
}
|
|
|
|
/**
|
|
* peek at the next unread character.
|
|
*
|
|
* @return the next unread character.
|
|
*/
|
|
char ASFormatter::peekNextChar() const
|
|
{
|
|
char ch = ' ';
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
|
|
if (peekNum == string::npos)
|
|
return ch;
|
|
|
|
ch = currentLine[peekNum];
|
|
|
|
return ch;
|
|
}
|
|
|
|
/**
|
|
* check if current placement is before a comment
|
|
*
|
|
* @return is before a comment.
|
|
*/
|
|
bool ASFormatter::isBeforeComment() const
|
|
{
|
|
bool foundComment = false;
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
|
|
if (peekNum == string::npos)
|
|
return foundComment;
|
|
|
|
foundComment = (currentLine.compare(peekNum, 2, "/*") == 0);
|
|
|
|
return foundComment;
|
|
}
|
|
|
|
/**
|
|
* check if current placement is before a comment or line-comment
|
|
*
|
|
* @return is before a comment or line-comment.
|
|
*/
|
|
bool ASFormatter::isBeforeAnyComment() const
|
|
{
|
|
bool foundComment = false;
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
|
|
if (peekNum == string::npos)
|
|
return foundComment;
|
|
|
|
foundComment = (currentLine.compare(peekNum, 2, "/*") == 0
|
|
|| currentLine.compare(peekNum, 2, "//") == 0);
|
|
|
|
return foundComment;
|
|
}
|
|
|
|
/**
|
|
* check if current placement is before a comment or line-comment
|
|
* if a block comment it must be at the end of the line
|
|
*
|
|
* @return is before a comment or line-comment.
|
|
*/
|
|
bool ASFormatter::isBeforeAnyLineEndComment(int startPos) const
|
|
{
|
|
bool foundLineEndComment = false;
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", startPos + 1);
|
|
|
|
if (peekNum != string::npos)
|
|
{
|
|
if (currentLine.compare(peekNum, 2, "//") == 0)
|
|
foundLineEndComment = true;
|
|
else if (currentLine.compare(peekNum, 2, "/*") == 0)
|
|
{
|
|
// comment must be closed on this line with nothing after it
|
|
size_t endNum = currentLine.find("*/", peekNum + 2);
|
|
if (endNum != string::npos)
|
|
{
|
|
size_t nextChar = currentLine.find_first_not_of(" \t", endNum + 2);
|
|
if (nextChar == string::npos)
|
|
foundLineEndComment = true;
|
|
}
|
|
}
|
|
}
|
|
return foundLineEndComment;
|
|
}
|
|
|
|
/**
|
|
* check if current placement is before a comment followed by a line-comment
|
|
*
|
|
* @return is before a multiple line-end comment.
|
|
*/
|
|
bool ASFormatter::isBeforeMultipleLineEndComments(int startPos) const
|
|
{
|
|
bool foundMultipleLineEndComment = false;
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", startPos + 1);
|
|
|
|
if (peekNum != string::npos)
|
|
{
|
|
if (currentLine.compare(peekNum, 2, "/*") == 0)
|
|
{
|
|
// comment must be closed on this line with nothing after it
|
|
size_t endNum = currentLine.find("*/", peekNum + 2);
|
|
if (endNum != string::npos)
|
|
{
|
|
size_t nextChar = currentLine.find_first_not_of(" \t", endNum + 2);
|
|
if (nextChar != string::npos
|
|
&& currentLine.compare(nextChar, 2, "//") == 0)
|
|
foundMultipleLineEndComment = true;
|
|
}
|
|
}
|
|
}
|
|
return foundMultipleLineEndComment;
|
|
}
|
|
|
|
/**
|
|
* get the next character, increasing the current placement in the process.
|
|
* the new character is inserted into the variable currentChar.
|
|
*
|
|
* @return whether succeeded to receive the new character.
|
|
*/
|
|
bool ASFormatter::getNextChar()
|
|
{
|
|
isInLineBreak = false;
|
|
previousChar = currentChar;
|
|
|
|
if (!isWhiteSpace(currentChar))
|
|
{
|
|
previousNonWSChar = currentChar;
|
|
if (!isInComment && !isInLineComment && !isInQuote
|
|
&& !isImmediatelyPostComment
|
|
&& !isImmediatelyPostLineComment
|
|
&& !isInPreprocessor
|
|
&& !isSequenceReached("/*")
|
|
&& !isSequenceReached("//"))
|
|
previousCommandChar = currentChar;
|
|
}
|
|
|
|
if (charNum + 1 < (int) currentLine.length()
|
|
&& (!isWhiteSpace(peekNextChar()) || isInComment || isInLineComment))
|
|
{
|
|
currentChar = currentLine[++charNum];
|
|
|
|
if (currentChar == '\t' && shouldConvertTabs)
|
|
convertTabToSpaces();
|
|
|
|
return true;
|
|
}
|
|
|
|
// end of line has been reached
|
|
return getNextLine();
|
|
}
|
|
|
|
/**
|
|
* get the next line of input, increasing the current placement in the process.
|
|
*
|
|
* @param emptyLineWasDeleted an empty line was deleted.
|
|
* @return whether succeeded in reading the next line.
|
|
*/
|
|
bool ASFormatter::getNextLine(bool emptyLineWasDeleted /*false*/)
|
|
{
|
|
if (!sourceIterator->hasMoreLines())
|
|
{
|
|
endOfCodeReached = true;
|
|
return false;
|
|
}
|
|
if (appendOpeningBrace)
|
|
currentLine = "{"; // append brace that was removed from the previous line
|
|
else
|
|
{
|
|
currentLine = sourceIterator->nextLine(emptyLineWasDeleted);
|
|
assert(computeChecksumIn(currentLine));
|
|
}
|
|
// reset variables for new line
|
|
inLineNumber++;
|
|
if (endOfAsmReached)
|
|
endOfAsmReached = isInAsmBlock = isInAsm = false;
|
|
shouldKeepLineUnbroken = false;
|
|
isInCommentStartLine = false;
|
|
isInCase = false;
|
|
isInAsmOneLine = false;
|
|
isHeaderInMultiStatementLine = false;
|
|
isInQuoteContinuation = isInVerbatimQuote || haveLineContinuationChar;
|
|
haveLineContinuationChar = false;
|
|
isImmediatelyPostEmptyLine = lineIsEmpty;
|
|
previousChar = ' ';
|
|
|
|
if (currentLine.length() == 0)
|
|
currentLine = string(" "); // a null is inserted if this is not done
|
|
|
|
// unless reading in the first line of the file, break a new line.
|
|
if (!isVirgin)
|
|
isInLineBreak = true;
|
|
else
|
|
isVirgin = false;
|
|
|
|
if (isImmediatelyPostNonInStmt)
|
|
{
|
|
isCharImmediatelyPostNonInStmt = true;
|
|
isImmediatelyPostNonInStmt = false;
|
|
}
|
|
|
|
// check if is in preprocessor before line trimming
|
|
// a blank line after a \ will remove the flag
|
|
isImmediatelyPostPreprocessor = isInPreprocessor;
|
|
if (!isInComment
|
|
&& (previousNonWSChar != '\\'
|
|
|| isEmptyLine(currentLine)))
|
|
isInPreprocessor = false;
|
|
|
|
if (passedSemicolon)
|
|
isInExecSQL = false;
|
|
initNewLine();
|
|
|
|
currentChar = currentLine[charNum];
|
|
if (isInBraceRunIn && previousNonWSChar == '{' && !isInComment)
|
|
isInLineBreak = false;
|
|
isInBraceRunIn = false;
|
|
|
|
if (currentChar == '\t' && shouldConvertTabs)
|
|
convertTabToSpaces();
|
|
|
|
// check for an empty line inside a command brace.
|
|
// if yes then read the next line (calls getNextLine recursively).
|
|
// must be after initNewLine.
|
|
if (shouldDeleteEmptyLines
|
|
&& lineIsEmpty
|
|
&& isBraceType((*braceTypeStack)[braceTypeStack->size() - 1], COMMAND_TYPE))
|
|
{
|
|
if (!shouldBreakBlocks || previousNonWSChar == '{' || !commentAndHeaderFollows())
|
|
{
|
|
isInPreprocessor = isImmediatelyPostPreprocessor; // restore
|
|
lineIsEmpty = false;
|
|
return getNextLine(true);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* jump over the leading white space in the current line,
|
|
* IF the line does not begin a comment or is in a preprocessor definition.
|
|
*/
|
|
void ASFormatter::initNewLine()
|
|
{
|
|
size_t len = currentLine.length();
|
|
size_t tabSize = getTabLength();
|
|
charNum = 0;
|
|
|
|
// don't trim these
|
|
if (isInQuoteContinuation
|
|
|| (isInPreprocessor && !getPreprocDefineIndent()))
|
|
return;
|
|
|
|
// SQL continuation lines must be adjusted so the leading spaces
|
|
// is equivalent to the opening EXEC SQL
|
|
if (isInExecSQL)
|
|
{
|
|
// replace leading tabs with spaces
|
|
// so that continuation indent will be spaces
|
|
size_t tabCount_ = 0;
|
|
size_t i;
|
|
for (i = 0; i < currentLine.length(); i++)
|
|
{
|
|
if (!isWhiteSpace(currentLine[i])) // stop at first text
|
|
break;
|
|
if (currentLine[i] == '\t')
|
|
{
|
|
size_t numSpaces = tabSize - ((tabCount_ + i) % tabSize);
|
|
currentLine.replace(i, 1, numSpaces, ' ');
|
|
tabCount_++;
|
|
i += tabSize - 1;
|
|
}
|
|
}
|
|
// this will correct the format if EXEC SQL is not a hanging indent
|
|
trimContinuationLine();
|
|
return;
|
|
}
|
|
|
|
// comment continuation lines must be adjusted so the leading spaces
|
|
// is equivalent to the opening comment
|
|
if (isInComment)
|
|
{
|
|
if (noTrimCommentContinuation)
|
|
leadingSpaces = tabIncrementIn = 0;
|
|
trimContinuationLine();
|
|
return;
|
|
}
|
|
|
|
// compute leading spaces
|
|
isImmediatelyPostCommentOnly = lineIsLineCommentOnly || lineEndsInCommentOnly;
|
|
lineIsCommentOnly = false;
|
|
lineIsLineCommentOnly = false;
|
|
lineEndsInCommentOnly = false;
|
|
doesLineStartComment = false;
|
|
currentLineBeginsWithBrace = false;
|
|
lineIsEmpty = false;
|
|
currentLineFirstBraceNum = string::npos;
|
|
tabIncrementIn = 0;
|
|
|
|
// bypass whitespace at the start of a line
|
|
// preprocessor tabs are replaced later in the program
|
|
for (charNum = 0; isWhiteSpace(currentLine[charNum]) && charNum + 1 < (int) len; charNum++)
|
|
{
|
|
if (currentLine[charNum] == '\t' && !isInPreprocessor)
|
|
tabIncrementIn += tabSize - 1 - ((tabIncrementIn + charNum) % tabSize);
|
|
}
|
|
leadingSpaces = charNum + tabIncrementIn;
|
|
|
|
if (isSequenceReached("/*"))
|
|
{
|
|
doesLineStartComment = true;
|
|
if ((int) currentLine.length() > charNum + 2
|
|
&& currentLine.find("*/", charNum + 2) != string::npos)
|
|
lineIsCommentOnly = true;
|
|
}
|
|
else if (isSequenceReached("//"))
|
|
{
|
|
lineIsLineCommentOnly = true;
|
|
}
|
|
else if (isSequenceReached("{"))
|
|
{
|
|
currentLineBeginsWithBrace = true;
|
|
currentLineFirstBraceNum = charNum;
|
|
size_t firstText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (firstText != string::npos)
|
|
{
|
|
if (currentLine.compare(firstText, 2, "//") == 0)
|
|
lineIsLineCommentOnly = true;
|
|
else if (currentLine.compare(firstText, 2, "/*") == 0
|
|
|| isExecSQL(currentLine, firstText))
|
|
{
|
|
// get the extra adjustment
|
|
size_t j;
|
|
for (j = charNum + 1; j < firstText && isWhiteSpace(currentLine[j]); j++)
|
|
{
|
|
if (currentLine[j] == '\t')
|
|
tabIncrementIn += tabSize - 1 - ((tabIncrementIn + j) % tabSize);
|
|
}
|
|
leadingSpaces = j + tabIncrementIn;
|
|
if (currentLine.compare(firstText, 2, "/*") == 0)
|
|
doesLineStartComment = true;
|
|
}
|
|
}
|
|
}
|
|
else if (isWhiteSpace(currentLine[charNum]) && !(charNum + 1 < (int) currentLine.length()))
|
|
{
|
|
lineIsEmpty = true;
|
|
}
|
|
|
|
// do not trim indented preprocessor define (except for comment continuation lines)
|
|
if (isInPreprocessor)
|
|
{
|
|
if (!doesLineStartComment)
|
|
leadingSpaces = 0;
|
|
charNum = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a character to the current formatted line.
|
|
* The formattedLine split points are updated.
|
|
*
|
|
* @param ch the character to append.
|
|
* @param canBreakLine if true, a registered line-break
|
|
*/
|
|
void ASFormatter::appendChar(char ch, bool canBreakLine)
|
|
{
|
|
if (canBreakLine && isInLineBreak)
|
|
breakLine();
|
|
|
|
formattedLine.append(1, ch);
|
|
isImmediatelyPostCommentOnly = false;
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
// These compares reduce the frequency of function calls.
|
|
if (isOkToSplitFormattedLine())
|
|
updateFormattedLineSplitPoints(ch);
|
|
if (formattedLine.length() > maxCodeLength)
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a string sequence to the current formatted line.
|
|
* The formattedLine split points are NOT updated.
|
|
* But the formattedLine is checked for time to split.
|
|
*
|
|
* @param sequence the sequence to append.
|
|
* @param canBreakLine if true, a registered line-break
|
|
*/
|
|
void ASFormatter::appendSequence(const string& sequence, bool canBreakLine)
|
|
{
|
|
if (canBreakLine && isInLineBreak)
|
|
breakLine();
|
|
formattedLine.append(sequence);
|
|
if (formattedLine.length() > maxCodeLength)
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
|
|
/**
|
|
* Append an operator sequence to the current formatted line.
|
|
* The formattedLine split points are updated.
|
|
*
|
|
* @param sequence the sequence to append.
|
|
* @param canBreakLine if true, a registered line-break
|
|
*/
|
|
void ASFormatter::appendOperator(const string& sequence, bool canBreakLine)
|
|
{
|
|
if (canBreakLine && isInLineBreak)
|
|
breakLine();
|
|
formattedLine.append(sequence);
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
// These compares reduce the frequency of function calls.
|
|
if (isOkToSplitFormattedLine())
|
|
updateFormattedLineSplitPointsOperator(sequence);
|
|
if (formattedLine.length() > maxCodeLength)
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* append a space to the current formattedline, UNLESS the
|
|
* last character is already a white-space character.
|
|
*/
|
|
void ASFormatter::appendSpacePad()
|
|
{
|
|
int len = formattedLine.length();
|
|
if (len > 0 && !isWhiteSpace(formattedLine[len - 1]))
|
|
{
|
|
formattedLine.append(1, ' ');
|
|
spacePadNum++;
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
// These compares reduce the frequency of function calls.
|
|
if (isOkToSplitFormattedLine())
|
|
updateFormattedLineSplitPoints(' ');
|
|
if (formattedLine.length() > maxCodeLength)
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* append a space to the current formattedline, UNLESS the
|
|
* next character is already a white-space character.
|
|
*/
|
|
void ASFormatter::appendSpaceAfter()
|
|
{
|
|
int len = currentLine.length();
|
|
if (charNum + 1 < len && !isWhiteSpace(currentLine[charNum + 1]))
|
|
{
|
|
formattedLine.append(1, ' ');
|
|
spacePadNum++;
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
// These compares reduce the frequency of function calls.
|
|
if (isOkToSplitFormattedLine())
|
|
updateFormattedLineSplitPoints(' ');
|
|
if (formattedLine.length() > maxCodeLength)
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* register a line break for the formatted line.
|
|
*/
|
|
void ASFormatter::breakLine(bool isSplitLine /*false*/)
|
|
{
|
|
isLineReady = true;
|
|
isInLineBreak = false;
|
|
spacePadNum = nextLineSpacePadNum;
|
|
nextLineSpacePadNum = 0;
|
|
readyFormattedLine = formattedLine;
|
|
formattedLine.erase();
|
|
// queue an empty line prepend request if one exists
|
|
prependEmptyLine = isPrependPostBlockEmptyLineRequested;
|
|
|
|
if (!isSplitLine)
|
|
{
|
|
formattedLineCommentNum = string::npos;
|
|
clearFormattedLineSplitPoints();
|
|
|
|
if (isAppendPostBlockEmptyLineRequested)
|
|
{
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
else
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* check if the currently reached open-brace (i.e. '{')
|
|
* opens a:
|
|
* - a definition type block (such as a class or namespace),
|
|
* - a command block (such as a method block)
|
|
* - a static array
|
|
* this method takes for granted that the current character
|
|
* is an opening brace.
|
|
*
|
|
* @return the type of the opened block.
|
|
*/
|
|
BraceType ASFormatter::getBraceType()
|
|
{
|
|
assert(currentChar == '{');
|
|
|
|
BraceType returnVal = NULL_TYPE;
|
|
|
|
if ((previousNonWSChar == '='
|
|
|| isBraceType(braceTypeStack->back(), ARRAY_TYPE))
|
|
&& previousCommandChar != ')'
|
|
&& !isNonParenHeader)
|
|
returnVal = ARRAY_TYPE;
|
|
else if (foundPreDefinitionHeader && previousCommandChar != ')')
|
|
{
|
|
returnVal = DEFINITION_TYPE;
|
|
if (foundNamespaceHeader)
|
|
returnVal = (BraceType)(returnVal | NAMESPACE_TYPE);
|
|
else if (foundClassHeader)
|
|
returnVal = (BraceType)(returnVal | CLASS_TYPE);
|
|
else if (foundStructHeader)
|
|
returnVal = (BraceType)(returnVal | STRUCT_TYPE);
|
|
else if (foundInterfaceHeader)
|
|
returnVal = (BraceType)(returnVal | INTERFACE_TYPE);
|
|
}
|
|
else if (isInEnum)
|
|
{
|
|
returnVal = (BraceType)(ARRAY_TYPE | ENUM_TYPE);
|
|
}
|
|
else
|
|
{
|
|
bool isCommandType = (foundPreCommandHeader
|
|
|| foundPreCommandMacro
|
|
|| (currentHeader != nullptr && isNonParenHeader)
|
|
|| (previousCommandChar == ')')
|
|
|| (previousCommandChar == ':' && !foundQuestionMark)
|
|
|| (previousCommandChar == ';')
|
|
|| ((previousCommandChar == '{' || previousCommandChar == '}')
|
|
&& isPreviousBraceBlockRelated)
|
|
|| (isInClassInitializer
|
|
&& (!isLegalNameChar(previousNonWSChar) || foundPreCommandHeader))
|
|
|| foundTrailingReturnType
|
|
|| isInObjCMethodDefinition
|
|
|| isInObjCInterface
|
|
|| isJavaStaticConstructor
|
|
|| isSharpDelegate);
|
|
|
|
// C# methods containing 'get', 'set', 'add', and 'remove' do NOT end with parens
|
|
if (!isCommandType && isSharpStyle() && isNextWordSharpNonParenHeader(charNum + 1))
|
|
{
|
|
isCommandType = true;
|
|
isSharpAccessor = true;
|
|
}
|
|
|
|
if (isInExternC)
|
|
returnVal = (isCommandType ? COMMAND_TYPE : EXTERN_TYPE);
|
|
else
|
|
returnVal = (isCommandType ? COMMAND_TYPE : ARRAY_TYPE);
|
|
}
|
|
|
|
int foundOneLineBlock = isOneLineBlockReached(currentLine, charNum);
|
|
|
|
if (foundOneLineBlock == 2 && returnVal == COMMAND_TYPE)
|
|
returnVal = ARRAY_TYPE;
|
|
|
|
if (foundOneLineBlock > 0)
|
|
{
|
|
returnVal = (BraceType) (returnVal | SINGLE_LINE_TYPE);
|
|
if (breakCurrentOneLineBlock)
|
|
returnVal = (BraceType) (returnVal | BREAK_BLOCK_TYPE);
|
|
if (foundOneLineBlock == 3)
|
|
returnVal = (BraceType)(returnVal | EMPTY_BLOCK_TYPE);
|
|
}
|
|
|
|
if (isBraceType(returnVal, ARRAY_TYPE))
|
|
{
|
|
if (isNonInStatementArrayBrace())
|
|
{
|
|
returnVal = (BraceType)(returnVal | ARRAY_NIS_TYPE);
|
|
isNonInStatementArray = true;
|
|
isImmediatelyPostNonInStmt = false; // in case of "},{"
|
|
nonInStatementBrace = formattedLine.length() - 1;
|
|
}
|
|
if (isUniformInitializerBrace())
|
|
returnVal = (BraceType)(returnVal | INIT_TYPE);
|
|
}
|
|
|
|
return returnVal;
|
|
}
|
|
|
|
/**
|
|
* check if a colon is a class initializer separator
|
|
*
|
|
* @return whether it is a class initializer separator
|
|
*/
|
|
bool ASFormatter::isClassInitializer() const
|
|
{
|
|
assert(currentChar == ':');
|
|
assert(previousChar != ':' && peekNextChar() != ':'); // not part of '::'
|
|
|
|
// this should be similar to ASBeautifier::parseCurrentLine()
|
|
bool foundClassInitializer = false;
|
|
|
|
if (foundQuestionMark)
|
|
{
|
|
// do nothing special
|
|
}
|
|
else if (parenStack->back() > 0)
|
|
{
|
|
// found a 'for' loop or an objective-C statement
|
|
// so do nothing special
|
|
}
|
|
else if (isInEnum)
|
|
{
|
|
// found an enum with a base-type
|
|
}
|
|
else if (isCStyle()
|
|
&& !isInCase
|
|
&& (previousCommandChar == ')' || foundPreCommandHeader))
|
|
{
|
|
// found a 'class' c'tor initializer
|
|
foundClassInitializer = true;
|
|
}
|
|
return foundClassInitializer;
|
|
}
|
|
|
|
/**
|
|
* check if a line is empty
|
|
*
|
|
* @return whether line is empty
|
|
*/
|
|
bool ASFormatter::isEmptyLine(const string& line) const
|
|
{
|
|
return line.find_first_not_of(" \t") == string::npos;
|
|
}
|
|
|
|
/**
|
|
* Check if the following text is "C" as in extern "C".
|
|
*
|
|
* @return whether the statement is extern "C"
|
|
*/
|
|
bool ASFormatter::isExternC() const
|
|
{
|
|
// charNum should be at 'extern'
|
|
assert(!isWhiteSpace(currentLine[charNum]));
|
|
size_t startQuote = currentLine.find_first_of(" \t\"", charNum);
|
|
if (startQuote == string::npos)
|
|
return false;
|
|
startQuote = currentLine.find_first_not_of(" \t", startQuote);
|
|
if (startQuote == string::npos)
|
|
return false;
|
|
if (currentLine.compare(startQuote, 3, "\"C\"") != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check if the currently reached '*', '&' or '^' character is
|
|
* a pointer-or-reference symbol, or another operator.
|
|
* A pointer dereference (*) or an "address of" character (&)
|
|
* counts as a pointer or reference because it is not an
|
|
* arithmetic operator.
|
|
*
|
|
* @return whether current character is a reference-or-pointer
|
|
*/
|
|
bool ASFormatter::isPointerOrReference() const
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
|
|
if (isJavaStyle())
|
|
return false;
|
|
|
|
if (isCharImmediatelyPostOperator)
|
|
return false;
|
|
|
|
// get the last legal word (may be a number)
|
|
string lastWord = getPreviousWord(currentLine, charNum);
|
|
if (lastWord.empty())
|
|
lastWord = " ";
|
|
|
|
// check for preceding or following numeric values
|
|
string nextText = peekNextText(currentLine.substr(charNum + 1));
|
|
if (nextText.length() == 0)
|
|
nextText = " ";
|
|
char nextChar = nextText[0];
|
|
if (isDigit(lastWord[0])
|
|
|| isDigit(nextChar)
|
|
|| nextChar == '!'
|
|
|| nextChar == '~')
|
|
return false;
|
|
|
|
// check for multiply then a dereference (a * *b)
|
|
if (currentChar == '*'
|
|
&& charNum < (int) currentLine.length() - 1
|
|
&& isWhiteSpace(currentLine[charNum + 1])
|
|
&& nextChar == '*')
|
|
return false;
|
|
|
|
if ((foundCastOperator && nextChar == '>')
|
|
|| isPointerOrReferenceVariable(lastWord))
|
|
return true;
|
|
|
|
if (isInClassInitializer
|
|
&& previousNonWSChar != '('
|
|
&& previousNonWSChar != '{'
|
|
&& previousCommandChar != ','
|
|
&& nextChar != ')'
|
|
&& nextChar != '}')
|
|
return false;
|
|
|
|
//check for rvalue reference
|
|
if (currentChar == '&' && nextChar == '&')
|
|
{
|
|
if (previousNonWSChar == '>')
|
|
return true;
|
|
string followingText;
|
|
if ((int) currentLine.length() > charNum + 2)
|
|
followingText = peekNextText(currentLine.substr(charNum + 2));
|
|
if (followingText.length() > 0 && followingText[0] == ')')
|
|
return true;
|
|
if (currentHeader != nullptr || isInPotentialCalculation)
|
|
return false;
|
|
if (parenStack->back() > 0 && isBraceType(braceTypeStack->back(), COMMAND_TYPE))
|
|
return false;
|
|
return true;
|
|
}
|
|
if (nextChar == '*'
|
|
|| previousNonWSChar == '='
|
|
|| previousNonWSChar == '('
|
|
|| previousNonWSChar == '['
|
|
|| isCharImmediatelyPostReturn
|
|
|| isInTemplate
|
|
|| isCharImmediatelyPostTemplate
|
|
|| currentHeader == &AS_CATCH
|
|
|| currentHeader == &AS_FOREACH
|
|
|| currentHeader == &AS_QFOREACH)
|
|
return true;
|
|
|
|
if (isBraceType(braceTypeStack->back(), ARRAY_TYPE)
|
|
&& isLegalNameChar(lastWord[0])
|
|
&& isLegalNameChar(nextChar)
|
|
&& previousNonWSChar != ')')
|
|
{
|
|
if (isArrayOperator())
|
|
return false;
|
|
}
|
|
|
|
// checks on operators in parens
|
|
if (parenStack->back() > 0
|
|
&& isLegalNameChar(lastWord[0])
|
|
&& isLegalNameChar(nextChar))
|
|
{
|
|
// if followed by an assignment it is a pointer or reference
|
|
// if followed by semicolon it is a pointer or reference in range-based for
|
|
const string* followingOperator = getFollowingOperator();
|
|
if (followingOperator != nullptr
|
|
&& followingOperator != &AS_MULT
|
|
&& followingOperator != &AS_BIT_AND)
|
|
{
|
|
if (followingOperator == &AS_ASSIGN || followingOperator == &AS_COLON)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
if (isBraceType(braceTypeStack->back(), COMMAND_TYPE)
|
|
|| squareBracketCount > 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// checks on operators in parens with following '('
|
|
if (parenStack->back() > 0
|
|
&& nextChar == '('
|
|
&& previousNonWSChar != ','
|
|
&& previousNonWSChar != '('
|
|
&& previousNonWSChar != '!'
|
|
&& previousNonWSChar != '&'
|
|
&& previousNonWSChar != '*'
|
|
&& previousNonWSChar != '|')
|
|
return false;
|
|
|
|
if (nextChar == '-'
|
|
|| nextChar == '+')
|
|
{
|
|
size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextNum != string::npos)
|
|
{
|
|
if (currentLine.compare(nextNum, 2, "++") != 0
|
|
&& currentLine.compare(nextNum, 2, "--") != 0)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool isPR = (!isInPotentialCalculation
|
|
|| (!isLegalNameChar(previousNonWSChar)
|
|
&& !(previousNonWSChar == ')' && nextChar == '(')
|
|
&& !(previousNonWSChar == ')' && currentChar == '*' && !isImmediatelyPostCast())
|
|
&& previousNonWSChar != ']')
|
|
|| (!isWhiteSpace(nextChar)
|
|
&& nextChar != '-'
|
|
&& nextChar != '('
|
|
&& nextChar != '['
|
|
&& !isLegalNameChar(nextChar))
|
|
);
|
|
|
|
return isPR;
|
|
}
|
|
|
|
/**
|
|
* Check if the currently reached '*' or '&' character is
|
|
* a dereferenced pointer or "address of" symbol.
|
|
* NOTE: this MUST be a pointer or reference as determined by
|
|
* the function isPointerOrReference().
|
|
*
|
|
* @return whether current character is a dereference or address of
|
|
*/
|
|
bool ASFormatter::isDereferenceOrAddressOf() const
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
|
|
if (isCharImmediatelyPostTemplate)
|
|
return false;
|
|
|
|
if (previousNonWSChar == '='
|
|
|| previousNonWSChar == ','
|
|
|| previousNonWSChar == '.'
|
|
|| previousNonWSChar == '{'
|
|
|| previousNonWSChar == '>'
|
|
|| previousNonWSChar == '<'
|
|
|| previousNonWSChar == '?'
|
|
|| isCharImmediatelyPostLineComment
|
|
|| isCharImmediatelyPostComment
|
|
|| isCharImmediatelyPostReturn)
|
|
return true;
|
|
|
|
char nextChar = peekNextChar();
|
|
if (currentChar == '*' && nextChar == '*')
|
|
{
|
|
if (previousNonWSChar == '(')
|
|
return true;
|
|
if ((int) currentLine.length() < charNum + 2)
|
|
return true;
|
|
return false;
|
|
}
|
|
if (currentChar == '&' && nextChar == '&')
|
|
{
|
|
if (previousNonWSChar == '(' || isInTemplate)
|
|
return true;
|
|
if ((int) currentLine.length() < charNum + 2)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// check first char on the line
|
|
if (charNum == (int) currentLine.find_first_not_of(" \t")
|
|
&& (isBraceType(braceTypeStack->back(), COMMAND_TYPE)
|
|
|| parenStack->back() != 0))
|
|
return true;
|
|
|
|
string nextText = peekNextText(currentLine.substr(charNum + 1));
|
|
if (nextText.length() > 0)
|
|
{
|
|
if (nextText[0] == ')' || nextText[0] == '>'
|
|
|| nextText[0] == ',' || nextText[0] == '=')
|
|
return false;
|
|
if (nextText[0] == ';')
|
|
return true;
|
|
}
|
|
|
|
// check for reference to a pointer *& (cannot have &*)
|
|
if ((currentChar == '*' && nextChar == '&')
|
|
|| (previousNonWSChar == '*' && currentChar == '&'))
|
|
return false;
|
|
|
|
if (!isBraceType(braceTypeStack->back(), COMMAND_TYPE)
|
|
&& parenStack->back() == 0)
|
|
return false;
|
|
|
|
string lastWord = getPreviousWord(currentLine, charNum);
|
|
if (lastWord == "else" || lastWord == "delete")
|
|
return true;
|
|
|
|
if (isPointerOrReferenceVariable(lastWord))
|
|
return false;
|
|
|
|
bool isDA = (!(isLegalNameChar(previousNonWSChar) || previousNonWSChar == '>')
|
|
|| (nextText.length() > 0 && !isLegalNameChar(nextText[0]) && nextText[0] != '/')
|
|
|| (ispunct((unsigned char)previousNonWSChar) && previousNonWSChar != '.')
|
|
|| isCharImmediatelyPostReturn);
|
|
|
|
return isDA;
|
|
}
|
|
|
|
/**
|
|
* Check if the currently reached '*' or '&' character is
|
|
* centered with one space on each side.
|
|
* Only spaces are checked, not tabs.
|
|
* If true then a space will be deleted on the output.
|
|
*
|
|
* @return whether current character is centered.
|
|
*/
|
|
bool ASFormatter::isPointerOrReferenceCentered() const
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
|
|
int prNum = charNum;
|
|
int lineLength = (int) currentLine.length();
|
|
|
|
// check for end of line
|
|
if (peekNextChar() == ' ')
|
|
return false;
|
|
|
|
// check space before
|
|
if (prNum < 1
|
|
|| currentLine[prNum - 1] != ' ')
|
|
return false;
|
|
|
|
// check no space before that
|
|
if (prNum < 2
|
|
|| currentLine[prNum - 2] == ' ')
|
|
return false;
|
|
|
|
// check for ** or &&
|
|
if (prNum + 1 < lineLength
|
|
&& (currentLine[prNum + 1] == '*' || currentLine[prNum + 1] == '&'))
|
|
prNum++;
|
|
|
|
// check space after
|
|
if (prNum + 1 <= lineLength
|
|
&& currentLine[prNum + 1] != ' ')
|
|
return false;
|
|
|
|
// check no space after that
|
|
if (prNum + 2 < lineLength
|
|
&& currentLine[prNum + 2] == ' ')
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check if a word is a pointer or reference variable type.
|
|
*
|
|
* @return whether word is a pointer or reference variable.
|
|
*/
|
|
bool ASFormatter::isPointerOrReferenceVariable(const string& word) const
|
|
{
|
|
return (word == "char"
|
|
|| word == "int"
|
|
|| word == "void"
|
|
|| (word.length() >= 6 // check end of word for _t
|
|
&& word.compare(word.length() - 2, 2, "_t") == 0)
|
|
|| word == "INT"
|
|
|| word == "VOID");
|
|
}
|
|
|
|
/**
|
|
* check if the currently reached '+' or '-' character is a unary operator
|
|
* this method takes for granted that the current character
|
|
* is a '+' or '-'.
|
|
*
|
|
* @return whether the current '+' or '-' is a unary operator.
|
|
*/
|
|
bool ASFormatter::isUnaryOperator() const
|
|
{
|
|
assert(currentChar == '+' || currentChar == '-');
|
|
|
|
return ((isCharImmediatelyPostReturn || !isLegalNameChar(previousCommandChar))
|
|
&& previousCommandChar != '.'
|
|
&& previousCommandChar != '\"'
|
|
&& previousCommandChar != '\''
|
|
&& previousCommandChar != ')'
|
|
&& previousCommandChar != ']');
|
|
}
|
|
|
|
/**
|
|
* check if the currently reached comment is in a 'switch' statement
|
|
*
|
|
* @return whether the current '+' or '-' is in an exponent.
|
|
*/
|
|
bool ASFormatter::isInSwitchStatement() const
|
|
{
|
|
assert(isInLineComment || isInComment);
|
|
if (!preBraceHeaderStack->empty())
|
|
for (size_t i = 1; i < preBraceHeaderStack->size(); i++)
|
|
if (preBraceHeaderStack->at(i) == &AS_SWITCH)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* check if the currently reached '+' or '-' character is
|
|
* part of an exponent, i.e. 0.2E-5.
|
|
*
|
|
* @return whether the current '+' or '-' is in an exponent.
|
|
*/
|
|
bool ASFormatter::isInExponent() const
|
|
{
|
|
assert(currentChar == '+' || currentChar == '-');
|
|
|
|
if (charNum >= 2)
|
|
{
|
|
char prevPrevFormattedChar = currentLine[charNum - 2];
|
|
char prevFormattedChar = currentLine[charNum - 1];
|
|
return ((prevFormattedChar == 'e' || prevFormattedChar == 'E')
|
|
&& (prevPrevFormattedChar == '.' || isDigit(prevPrevFormattedChar)));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* check if an array brace should NOT have an in-statement indent
|
|
*
|
|
* @return the array is non in-statement
|
|
*/
|
|
bool ASFormatter::isNonInStatementArrayBrace() const
|
|
{
|
|
bool returnVal = false;
|
|
char nextChar = peekNextChar();
|
|
// if this opening brace begins the line there will be no inStatement indent
|
|
if (currentLineBeginsWithBrace
|
|
&& charNum == (int) currentLineFirstBraceNum
|
|
&& nextChar != '}')
|
|
returnVal = true;
|
|
// if an opening brace ends the line there will be no inStatement indent
|
|
if (isWhiteSpace(nextChar)
|
|
|| isBeforeAnyLineEndComment(charNum)
|
|
|| nextChar == '{')
|
|
returnVal = true;
|
|
|
|
// Java "new Type [] {...}" IS an inStatement indent
|
|
if (isJavaStyle() && previousNonWSChar == ']')
|
|
returnVal = false;
|
|
|
|
return returnVal;
|
|
}
|
|
|
|
/**
|
|
* check if a one-line block has been reached,
|
|
* i.e. if the currently reached '{' character is closed
|
|
* with a complimentary '}' elsewhere on the current line,
|
|
*.
|
|
* @return 0 = one-line block has not been reached.
|
|
* 1 = one-line block has been reached.
|
|
* 2 = one-line block has been reached and is followed by a comma.
|
|
* 3 = one-line block has been reached and is an empty block.
|
|
*/
|
|
int ASFormatter::isOneLineBlockReached(const string& line, int startChar) const
|
|
{
|
|
assert(line[startChar] == '{');
|
|
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
bool hasText = false;
|
|
int braceCount = 0;
|
|
int lineLength = line.length();
|
|
char quoteChar_ = ' ';
|
|
char ch = ' ';
|
|
char prevCh = ' ';
|
|
|
|
for (int i = startChar; i < lineLength; ++i)
|
|
{
|
|
ch = line[i];
|
|
|
|
if (isInComment_)
|
|
{
|
|
if (line.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
++i;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (ch == '\\')
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
if (isInQuote_)
|
|
{
|
|
if (ch == quoteChar_)
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
|
|
if (ch == '"'
|
|
|| (ch == '\'' && !isDigitSeparator(line, i)))
|
|
{
|
|
isInQuote_ = true;
|
|
quoteChar_ = ch;
|
|
continue;
|
|
}
|
|
|
|
if (line.compare(i, 2, "//") == 0)
|
|
break;
|
|
|
|
if (line.compare(i, 2, "/*") == 0)
|
|
{
|
|
isInComment_ = true;
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
if (ch == '{')
|
|
{
|
|
++braceCount;
|
|
continue;
|
|
}
|
|
if (ch == '}')
|
|
{
|
|
--braceCount;
|
|
if (braceCount == 0)
|
|
{
|
|
// is this an array?
|
|
if (parenStack->back() == 0 && prevCh != '}')
|
|
{
|
|
size_t peekNum = line.find_first_not_of(" \t", i + 1);
|
|
if (peekNum != string::npos && line[peekNum] == ',')
|
|
return 2;
|
|
}
|
|
if (!hasText)
|
|
return 3; // is an empty block
|
|
return 1;
|
|
}
|
|
}
|
|
if (ch == ';')
|
|
continue;
|
|
if (!isWhiteSpace(ch))
|
|
{
|
|
hasText = true;
|
|
prevCh = ch;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* peek at the next word to determine if it is a C# non-paren header.
|
|
* will look ahead in the input file if necessary.
|
|
*
|
|
* @param startChar position on currentLine to start the search
|
|
* @return true if the next word is get or set.
|
|
*/
|
|
bool ASFormatter::isNextWordSharpNonParenHeader(int startChar) const
|
|
{
|
|
// look ahead to find the next non-comment text
|
|
string nextText = peekNextText(currentLine.substr(startChar));
|
|
if (nextText.length() == 0)
|
|
return false;
|
|
if (nextText[0] == '[')
|
|
return true;
|
|
if (!isCharPotentialHeader(nextText, 0))
|
|
return false;
|
|
if (findKeyword(nextText, 0, AS_GET) || findKeyword(nextText, 0, AS_SET)
|
|
|| findKeyword(nextText, 0, AS_ADD) || findKeyword(nextText, 0, AS_REMOVE))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* peek at the next char to determine if it is an opening brace.
|
|
* will look ahead in the input file if necessary.
|
|
* this determines a java static constructor.
|
|
*
|
|
* @param startChar position on currentLine to start the search
|
|
* @return true if the next word is an opening brace.
|
|
*/
|
|
bool ASFormatter::isNextCharOpeningBrace(int startChar) const
|
|
{
|
|
bool retVal = false;
|
|
string nextText = peekNextText(currentLine.substr(startChar));
|
|
if (nextText.length() > 0
|
|
&& nextText.compare(0, 1, "{") == 0)
|
|
retVal = true;
|
|
return retVal;
|
|
}
|
|
|
|
/**
|
|
* Check if operator and, pointer, and reference padding is disabled.
|
|
* Disabling is done thru a NOPAD tag in an ending comment.
|
|
*
|
|
* @return true if the formatting on this line is disabled.
|
|
*/
|
|
bool ASFormatter::isOperatorPaddingDisabled() const
|
|
{
|
|
size_t commentStart = currentLine.find("//", charNum);
|
|
if (commentStart == string::npos)
|
|
{
|
|
commentStart = currentLine.find("/*", charNum);
|
|
// comment must end on this line
|
|
if (commentStart != string::npos)
|
|
{
|
|
size_t commentEnd = currentLine.find("*/", commentStart + 2);
|
|
if (commentEnd == string::npos)
|
|
commentStart = string::npos;
|
|
}
|
|
}
|
|
if (commentStart == string::npos)
|
|
return false;
|
|
size_t noPadStart = currentLine.find("*NOPAD*", commentStart);
|
|
if (noPadStart == string::npos)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Determine if an opening array-type brace should have a leading space pad.
|
|
* This is to identify C++11 uniform initializers.
|
|
*/
|
|
bool ASFormatter::isUniformInitializerBrace() const
|
|
{
|
|
if (isCStyle() && !isInEnum && !isImmediatelyPostPreprocessor)
|
|
{
|
|
if (isInClassInitializer
|
|
|| isLegalNameChar(previousNonWSChar))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine if there is a following statement on the current line.
|
|
*/
|
|
bool ASFormatter::isMultiStatementLine() const
|
|
{
|
|
assert((isImmediatelyPostHeader || foundClosingHeader));
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
int semiCount_ = 0;
|
|
int parenCount_ = 0;
|
|
int braceCount_ = 0;
|
|
|
|
for (size_t i = 0; i < currentLine.length(); i++)
|
|
{
|
|
if (isInComment_)
|
|
{
|
|
if (currentLine.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
continue;
|
|
}
|
|
}
|
|
if (currentLine.compare(i, 2, "/*") == 0)
|
|
{
|
|
isInComment_ = true;
|
|
continue;
|
|
}
|
|
if (currentLine.compare(i, 2, "//") == 0)
|
|
return false;
|
|
if (isInQuote_)
|
|
{
|
|
if (currentLine[i] == '"' || currentLine[i] == '\'')
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
if (currentLine[i] == '"' || currentLine[i] == '\'')
|
|
{
|
|
isInQuote_ = true;
|
|
continue;
|
|
}
|
|
if (currentLine[i] == '(')
|
|
{
|
|
++parenCount_;
|
|
continue;
|
|
}
|
|
if (currentLine[i] == ')')
|
|
{
|
|
--parenCount_;
|
|
continue;
|
|
}
|
|
if (parenCount_ > 0)
|
|
continue;
|
|
if (currentLine[i] == '{')
|
|
{
|
|
++braceCount_;
|
|
}
|
|
if (currentLine[i] == '}')
|
|
{
|
|
--braceCount_;
|
|
}
|
|
if (braceCount_ > 0)
|
|
continue;
|
|
if (currentLine[i] == ';')
|
|
{
|
|
++semiCount_;
|
|
if (semiCount_ > 1)
|
|
return true;
|
|
continue;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* get the next non-whitespace substring on following lines, bypassing all comments.
|
|
*
|
|
* @param firstLine the first line to check
|
|
* @return the next non-whitespace substring.
|
|
*/
|
|
string ASFormatter::peekNextText(const string& firstLine,
|
|
bool endOnEmptyLine /*false*/,
|
|
shared_ptr<ASPeekStream> streamArg /*nullptr*/) const
|
|
{
|
|
bool isFirstLine = true;
|
|
string nextLine_ = firstLine;
|
|
size_t firstChar = string::npos;
|
|
shared_ptr<ASPeekStream> stream = streamArg;
|
|
if (stream == nullptr) // Borland may need == 0
|
|
stream = make_shared<ASPeekStream>(sourceIterator);
|
|
|
|
// find the first non-blank text, bypassing all comments.
|
|
bool isInComment_ = false;
|
|
while (stream->hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
nextLine_ = stream->peekNextLine();
|
|
|
|
firstChar = nextLine_.find_first_not_of(" \t");
|
|
if (firstChar == string::npos)
|
|
{
|
|
if (endOnEmptyLine && !isInComment_)
|
|
break;
|
|
continue;
|
|
}
|
|
|
|
if (nextLine_.compare(firstChar, 2, "/*") == 0)
|
|
{
|
|
firstChar += 2;
|
|
isInComment_ = true;
|
|
}
|
|
|
|
if (isInComment_)
|
|
{
|
|
firstChar = nextLine_.find("*/", firstChar);
|
|
if (firstChar == string::npos)
|
|
continue;
|
|
firstChar += 2;
|
|
isInComment_ = false;
|
|
firstChar = nextLine_.find_first_not_of(" \t", firstChar);
|
|
if (firstChar == string::npos)
|
|
continue;
|
|
}
|
|
|
|
if (nextLine_.compare(firstChar, 2, "//") == 0)
|
|
continue;
|
|
|
|
// found the next text
|
|
break;
|
|
}
|
|
|
|
if (firstChar == string::npos)
|
|
nextLine_ = "";
|
|
else
|
|
nextLine_ = nextLine_.substr(firstChar);
|
|
return nextLine_;
|
|
}
|
|
|
|
/**
|
|
* adjust comment position because of adding or deleting spaces
|
|
* the spaces are added or deleted to formattedLine
|
|
* spacePadNum contains the adjustment
|
|
*/
|
|
void ASFormatter::adjustComments()
|
|
{
|
|
assert(spacePadNum != 0);
|
|
assert(isSequenceReached("//") || isSequenceReached("/*"));
|
|
|
|
// block comment must be closed on this line with nothing after it
|
|
if (isSequenceReached("/*"))
|
|
{
|
|
size_t endNum = currentLine.find("*/", charNum + 2);
|
|
if (endNum == string::npos)
|
|
return;
|
|
if (currentLine.find_first_not_of(" \t", endNum + 2) != string::npos)
|
|
return;
|
|
}
|
|
|
|
size_t len = formattedLine.length();
|
|
// don't adjust a tab
|
|
if (formattedLine[len - 1] == '\t')
|
|
return;
|
|
// if spaces were removed, need to add spaces before the comment
|
|
if (spacePadNum < 0)
|
|
{
|
|
int adjust = -spacePadNum; // make the number positive
|
|
formattedLine.append(adjust, ' ');
|
|
}
|
|
// if spaces were added, need to delete extra spaces before the comment
|
|
// if cannot be done put the comment one space after the last text
|
|
else if (spacePadNum > 0)
|
|
{
|
|
int adjust = spacePadNum;
|
|
size_t lastText = formattedLine.find_last_not_of(' ');
|
|
if (lastText != string::npos
|
|
&& lastText < len - adjust - 1)
|
|
formattedLine.resize(len - adjust);
|
|
else if (len > lastText + 2)
|
|
formattedLine.resize(lastText + 2);
|
|
else if (len < lastText + 2)
|
|
formattedLine.append(len - lastText, ' ');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* append the current brace inside the end of line comments
|
|
* currentChar contains the brace, it will be appended to formattedLine
|
|
* formattedLineCommentNum is the comment location on formattedLine
|
|
*/
|
|
void ASFormatter::appendCharInsideComments()
|
|
{
|
|
if (formattedLineCommentNum == string::npos // does the comment start on the previous line?
|
|
|| formattedLineCommentNum == 0)
|
|
{
|
|
appendCurrentChar(); // don't attach
|
|
return;
|
|
}
|
|
assert(formattedLine.compare(formattedLineCommentNum, 2, "//") == 0
|
|
|| formattedLine.compare(formattedLineCommentNum, 2, "/*") == 0);
|
|
|
|
// find the previous non space char
|
|
size_t end = formattedLineCommentNum;
|
|
size_t beg = formattedLine.find_last_not_of(" \t", end - 1);
|
|
if (beg == string::npos)
|
|
{
|
|
appendCurrentChar(); // don't attach
|
|
return;
|
|
}
|
|
beg++;
|
|
|
|
// insert the brace
|
|
if (end - beg < 3) // is there room to insert?
|
|
formattedLine.insert(beg, 3 - end + beg, ' ');
|
|
if (formattedLine[beg] == '\t') // don't pad with a tab
|
|
formattedLine.insert(beg, 1, ' ');
|
|
formattedLine[beg + 1] = currentChar;
|
|
testForTimeToSplitFormattedLine();
|
|
|
|
if (isBeforeComment())
|
|
breakLine();
|
|
else if (isCharImmediatelyPostLineComment)
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
|
|
/**
|
|
* add or remove space padding to operators
|
|
* the operators and necessary padding will be appended to formattedLine
|
|
* the calling function should have a continue statement after calling this method
|
|
*
|
|
* @param newOperator the operator to be padded
|
|
*/
|
|
void ASFormatter::padOperators(const string* newOperator)
|
|
{
|
|
assert(shouldPadOperators);
|
|
assert(newOperator != nullptr);
|
|
|
|
char nextNonWSChar = ASBase::peekNextChar(currentLine, charNum);
|
|
bool shouldPad = (newOperator != &AS_SCOPE_RESOLUTION
|
|
&& newOperator != &AS_PLUS_PLUS
|
|
&& newOperator != &AS_MINUS_MINUS
|
|
&& newOperator != &AS_NOT
|
|
&& newOperator != &AS_BIT_NOT
|
|
&& newOperator != &AS_ARROW
|
|
&& !(newOperator == &AS_COLON && !foundQuestionMark // objC methods
|
|
&& (isInObjCMethodDefinition || isInObjCInterface
|
|
|| isInObjCSelector || squareBracketCount != 0))
|
|
&& !(newOperator == &AS_MINUS && isInExponent())
|
|
&& !(newOperator == &AS_PLUS && isInExponent())
|
|
&& !((newOperator == &AS_PLUS || newOperator == &AS_MINUS) // check for unary plus or minus
|
|
&& (previousNonWSChar == '('
|
|
|| previousNonWSChar == '['
|
|
|| previousNonWSChar == '='
|
|
|| previousNonWSChar == ','
|
|
|| previousNonWSChar == ':'
|
|
|| previousNonWSChar == '{'))
|
|
//? // commented out in release 2.05.1 - doesn't seem to do anything???
|
|
//x && !((newOperator == &AS_MULT || newOperator == &AS_BIT_AND || newOperator == &AS_AND)
|
|
//x && isPointerOrReference())
|
|
&& !(newOperator == &AS_MULT
|
|
&& (previousNonWSChar == '.'
|
|
|| previousNonWSChar == '>')) // check for ->
|
|
&& !(newOperator == &AS_MULT && peekNextChar() == '>')
|
|
&& !((isInTemplate || isImmediatelyPostTemplate)
|
|
&& (newOperator == &AS_LS || newOperator == &AS_GR))
|
|
&& !(newOperator == &AS_GCC_MIN_ASSIGN
|
|
&& ASBase::peekNextChar(currentLine, charNum + 1) == '>')
|
|
&& !(newOperator == &AS_GR && previousNonWSChar == '?')
|
|
&& !(newOperator == &AS_QUESTION // check for Java wildcard
|
|
&& isJavaStyle()
|
|
&& (previousNonWSChar == '<'
|
|
|| nextNonWSChar == '>'
|
|
|| nextNonWSChar == '.'))
|
|
&& !(newOperator == &AS_QUESTION // check for C# null conditional operator
|
|
&& isSharpStyle()
|
|
&& (nextNonWSChar == '.'
|
|
|| nextNonWSChar == '['))
|
|
&& !isCharImmediatelyPostOperator
|
|
&& !isInCase
|
|
&& !isInAsm
|
|
&& !isInAsmOneLine
|
|
&& !isInAsmBlock
|
|
);
|
|
|
|
// pad before operator
|
|
if (shouldPad
|
|
&& !(newOperator == &AS_COLON
|
|
&& (!foundQuestionMark && !isInEnum) && currentHeader != &AS_FOR)
|
|
&& !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?)
|
|
&& currentLine.find(':', charNum + 1) == string::npos)
|
|
)
|
|
appendSpacePad();
|
|
appendOperator(*newOperator);
|
|
goForward(newOperator->length() - 1);
|
|
|
|
currentChar = (*newOperator)[newOperator->length() - 1];
|
|
// pad after operator
|
|
// but do not pad after a '-' that is a unary-minus.
|
|
if (shouldPad
|
|
&& !isBeforeAnyComment()
|
|
&& !(newOperator == &AS_PLUS && isUnaryOperator())
|
|
&& !(newOperator == &AS_MINUS && isUnaryOperator())
|
|
&& !(currentLine.compare(charNum + 1, 1, AS_SEMICOLON) == 0)
|
|
&& !(currentLine.compare(charNum + 1, 2, AS_SCOPE_RESOLUTION) == 0)
|
|
&& !(peekNextChar() == ',')
|
|
&& !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?)
|
|
&& peekNextChar() == '[')
|
|
)
|
|
appendSpaceAfter();
|
|
}
|
|
|
|
/**
|
|
* format pointer or reference
|
|
* currentChar contains the pointer or reference
|
|
* the symbol and necessary padding will be appended to formattedLine
|
|
* the calling function should have a continue statement after calling this method
|
|
*
|
|
* NOTE: Do NOT use appendCurrentChar() in this method. The line should not be
|
|
* broken once the calculation starts.
|
|
*/
|
|
void ASFormatter::formatPointerOrReference()
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(!isJavaStyle());
|
|
|
|
int pa = pointerAlignment;
|
|
int ra = referenceAlignment;
|
|
int itemAlignment = (currentChar == '*' || currentChar == '^') ? pa : ((ra == REF_SAME_AS_PTR) ? pa : ra);
|
|
|
|
// check for ** and &&
|
|
int ptrLength = 1;
|
|
char peekedChar = peekNextChar();
|
|
if ((currentChar == '*' && peekedChar == '*')
|
|
|| (currentChar == '&' && peekedChar == '&'))
|
|
{
|
|
ptrLength = 2;
|
|
size_t nextChar = currentLine.find_first_not_of(" \t", charNum + 2);
|
|
if (nextChar == string::npos)
|
|
peekedChar = ' ';
|
|
else
|
|
peekedChar = currentLine[nextChar];
|
|
}
|
|
// check for cast
|
|
if (peekedChar == ')' || peekedChar == '>' || peekedChar == ',')
|
|
{
|
|
formatPointerOrReferenceCast();
|
|
return;
|
|
}
|
|
|
|
// check for a padded space and remove it
|
|
if (charNum > 0
|
|
&& !isWhiteSpace(currentLine[charNum - 1])
|
|
&& formattedLine.length() > 0
|
|
&& isWhiteSpace(formattedLine[formattedLine.length() - 1]))
|
|
{
|
|
formattedLine.erase(formattedLine.length() - 1);
|
|
spacePadNum--;
|
|
}
|
|
|
|
if (itemAlignment == PTR_ALIGN_TYPE)
|
|
{
|
|
formatPointerOrReferenceToType();
|
|
}
|
|
else if (itemAlignment == PTR_ALIGN_MIDDLE)
|
|
{
|
|
formatPointerOrReferenceToMiddle();
|
|
}
|
|
else if (itemAlignment == PTR_ALIGN_NAME)
|
|
{
|
|
formatPointerOrReferenceToName();
|
|
}
|
|
else // pointerAlignment == PTR_ALIGN_NONE
|
|
{
|
|
formattedLine.append(ptrLength, currentChar);
|
|
if (ptrLength > 1)
|
|
goForward(ptrLength - 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format pointer or reference with align to type
|
|
*/
|
|
void ASFormatter::formatPointerOrReferenceToType()
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(!isJavaStyle());
|
|
|
|
// do this before bumping charNum
|
|
bool isOldPRCentered = isPointerOrReferenceCentered();
|
|
|
|
size_t prevCh = formattedLine.find_last_not_of(" \t");
|
|
if (prevCh == string::npos)
|
|
prevCh = 0;
|
|
if (formattedLine.length() == 0 || prevCh == formattedLine.length() - 1)
|
|
formattedLine.append(1, currentChar);
|
|
else
|
|
{
|
|
// exchange * or & with character following the type
|
|
// this may not work every time with a tab character
|
|
string charSave = formattedLine.substr(prevCh + 1, 1);
|
|
formattedLine[prevCh + 1] = currentChar;
|
|
formattedLine.append(charSave);
|
|
}
|
|
if (isSequenceReached("**") || isSequenceReached("&&"))
|
|
{
|
|
if (formattedLine.length() == 1)
|
|
formattedLine.append(1, currentChar);
|
|
else
|
|
formattedLine.insert(prevCh + 2, 1, currentChar);
|
|
goForward(1);
|
|
}
|
|
// if no space after then add one
|
|
if (charNum < (int) currentLine.length() - 1
|
|
&& !isWhiteSpace(currentLine[charNum + 1])
|
|
&& currentLine[charNum + 1] != ')')
|
|
appendSpacePad();
|
|
// if old pointer or reference is centered, remove a space
|
|
if (isOldPRCentered
|
|
&& isWhiteSpace(formattedLine[formattedLine.length() - 1]))
|
|
{
|
|
formattedLine.erase(formattedLine.length() - 1, 1);
|
|
spacePadNum--;
|
|
}
|
|
// update the formattedLine split point
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
size_t index = formattedLine.length() - 1;
|
|
if (isWhiteSpace(formattedLine[index]))
|
|
{
|
|
updateFormattedLineSplitPointsPointerOrReference(index);
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format pointer or reference with align in the middle
|
|
*/
|
|
void ASFormatter::formatPointerOrReferenceToMiddle()
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(!isJavaStyle());
|
|
|
|
// compute current whitespace before
|
|
size_t wsBefore = currentLine.find_last_not_of(" \t", charNum - 1);
|
|
if (wsBefore == string::npos)
|
|
wsBefore = 0;
|
|
else
|
|
wsBefore = charNum - wsBefore - 1;
|
|
string sequenceToInsert(1, currentChar);
|
|
if (isSequenceReached("**"))
|
|
{
|
|
sequenceToInsert = "**";
|
|
goForward(1);
|
|
}
|
|
else if (isSequenceReached("&&"))
|
|
{
|
|
sequenceToInsert = "&&";
|
|
goForward(1);
|
|
}
|
|
// if reference to a pointer check for conflicting alignment
|
|
else if (currentChar == '*' && peekNextChar() == '&'
|
|
&& (referenceAlignment == REF_ALIGN_TYPE
|
|
|| referenceAlignment == REF_ALIGN_MIDDLE
|
|
|| referenceAlignment == REF_SAME_AS_PTR))
|
|
{
|
|
sequenceToInsert = "*&";
|
|
goForward(1);
|
|
for (size_t i = charNum; i < currentLine.length() - 1 && isWhiteSpace(currentLine[i]); i++)
|
|
goForward(1);
|
|
}
|
|
// if a comment follows don't align, just space pad
|
|
if (isBeforeAnyComment())
|
|
{
|
|
appendSpacePad();
|
|
formattedLine.append(sequenceToInsert);
|
|
appendSpaceAfter();
|
|
return;
|
|
}
|
|
// do this before goForward()
|
|
bool isAfterScopeResolution = previousNonWSChar == ':';
|
|
size_t charNumSave = charNum;
|
|
// if this is the last thing on the line
|
|
if (currentLine.find_first_not_of(" \t", charNum + 1) == string::npos)
|
|
{
|
|
if (wsBefore == 0 && !isAfterScopeResolution)
|
|
formattedLine.append(1, ' ');
|
|
formattedLine.append(sequenceToInsert);
|
|
return;
|
|
}
|
|
// goForward() to convert tabs to spaces, if necessary,
|
|
// and move following characters to preceding characters
|
|
// this may not work every time with tab characters
|
|
for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++)
|
|
{
|
|
goForward(1);
|
|
if (formattedLine.length() > 0)
|
|
formattedLine.append(1, currentLine[i]);
|
|
else
|
|
spacePadNum--;
|
|
}
|
|
// find space padding after
|
|
size_t wsAfter = currentLine.find_first_not_of(" \t", charNumSave + 1);
|
|
if (wsAfter == string::npos || isBeforeAnyComment())
|
|
wsAfter = 0;
|
|
else
|
|
wsAfter = wsAfter - charNumSave - 1;
|
|
// don't pad before scope resolution operator, but pad after
|
|
if (isAfterScopeResolution)
|
|
{
|
|
size_t lastText = formattedLine.find_last_not_of(" \t");
|
|
formattedLine.insert(lastText + 1, sequenceToInsert);
|
|
appendSpacePad();
|
|
}
|
|
else if (formattedLine.length() > 0)
|
|
{
|
|
// whitespace should be at least 2 chars to center
|
|
if (wsBefore + wsAfter < 2)
|
|
{
|
|
size_t charsToAppend = (2 - (wsBefore + wsAfter));
|
|
formattedLine.append(charsToAppend, ' ');
|
|
spacePadNum += charsToAppend;
|
|
if (wsBefore == 0)
|
|
wsBefore++;
|
|
if (wsAfter == 0)
|
|
wsAfter++;
|
|
}
|
|
// insert the pointer or reference char
|
|
size_t padAfter = (wsBefore + wsAfter) / 2;
|
|
size_t index = formattedLine.length() - padAfter;
|
|
formattedLine.insert(index, sequenceToInsert);
|
|
}
|
|
else // formattedLine.length() == 0
|
|
{
|
|
formattedLine.append(sequenceToInsert);
|
|
if (wsAfter == 0)
|
|
wsAfter++;
|
|
formattedLine.append(wsAfter, ' ');
|
|
spacePadNum += wsAfter;
|
|
}
|
|
// update the formattedLine split point after the pointer
|
|
if (maxCodeLength != string::npos && formattedLine.length() > 0)
|
|
{
|
|
size_t index = formattedLine.find_last_not_of(" \t");
|
|
if (index != string::npos && (index < formattedLine.length() - 1))
|
|
{
|
|
index++;
|
|
updateFormattedLineSplitPointsPointerOrReference(index);
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format pointer or reference with align to name
|
|
*/
|
|
void ASFormatter::formatPointerOrReferenceToName()
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(!isJavaStyle());
|
|
|
|
// do this before bumping charNum
|
|
bool isOldPRCentered = isPointerOrReferenceCentered();
|
|
|
|
size_t startNum = formattedLine.find_last_not_of(" \t");
|
|
if (startNum == string::npos)
|
|
startNum = 0;
|
|
string sequenceToInsert(1, currentChar);
|
|
if (isSequenceReached("**"))
|
|
{
|
|
sequenceToInsert = "**";
|
|
goForward(1);
|
|
}
|
|
else if (isSequenceReached("&&"))
|
|
{
|
|
sequenceToInsert = "&&";
|
|
goForward(1);
|
|
}
|
|
// if reference to a pointer align both to name
|
|
else if (currentChar == '*' && peekNextChar() == '&')
|
|
{
|
|
sequenceToInsert = "*&";
|
|
goForward(1);
|
|
for (size_t i = charNum; i < currentLine.length() - 1 && isWhiteSpace(currentLine[i]); i++)
|
|
goForward(1);
|
|
}
|
|
char peekedChar = peekNextChar();
|
|
bool isAfterScopeResolution = previousNonWSChar == ':'; // check for ::
|
|
// if this is not the last thing on the line
|
|
if (!isBeforeAnyComment()
|
|
&& (int) currentLine.find_first_not_of(" \t", charNum + 1) > charNum)
|
|
{
|
|
// goForward() to convert tabs to spaces, if necessary,
|
|
// and move following characters to preceding characters
|
|
// this may not work every time with tab characters
|
|
for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++)
|
|
{
|
|
// if a padded paren follows don't move
|
|
if (shouldPadParensOutside && peekedChar == '(' && !isOldPRCentered)
|
|
{
|
|
// empty parens don't count
|
|
size_t start = currentLine.find_first_not_of("( \t", charNum + 1);
|
|
if (start != string::npos && currentLine[start] != ')')
|
|
break;
|
|
}
|
|
goForward(1);
|
|
if (formattedLine.length() > 0)
|
|
formattedLine.append(1, currentLine[i]);
|
|
else
|
|
spacePadNum--;
|
|
}
|
|
}
|
|
// don't pad before scope resolution operator
|
|
if (isAfterScopeResolution)
|
|
{
|
|
size_t lastText = formattedLine.find_last_not_of(" \t");
|
|
if (lastText != string::npos && lastText + 1 < formattedLine.length())
|
|
formattedLine.erase(lastText + 1);
|
|
}
|
|
// if no space before * then add one
|
|
else if (formattedLine.length() > 0
|
|
&& (formattedLine.length() <= startNum + 1
|
|
|| !isWhiteSpace(formattedLine[startNum + 1])))
|
|
{
|
|
formattedLine.insert(startNum + 1, 1, ' ');
|
|
spacePadNum++;
|
|
}
|
|
appendSequence(sequenceToInsert, false);
|
|
// if old pointer or reference is centered, remove a space
|
|
if (isOldPRCentered
|
|
&& formattedLine.length() > startNum + 1
|
|
&& isWhiteSpace(formattedLine[startNum + 1])
|
|
&& !isBeforeAnyComment())
|
|
{
|
|
formattedLine.erase(startNum + 1, 1);
|
|
spacePadNum--;
|
|
}
|
|
// don't convert to *= or &=
|
|
if (peekedChar == '=')
|
|
{
|
|
appendSpaceAfter();
|
|
// if more than one space before, delete one
|
|
if (formattedLine.length() > startNum
|
|
&& isWhiteSpace(formattedLine[startNum + 1])
|
|
&& isWhiteSpace(formattedLine[startNum + 2]))
|
|
{
|
|
formattedLine.erase(startNum + 1, 1);
|
|
spacePadNum--;
|
|
}
|
|
}
|
|
// update the formattedLine split point
|
|
if (maxCodeLength != string::npos)
|
|
{
|
|
size_t index = formattedLine.find_last_of(" \t");
|
|
if (index != string::npos
|
|
&& index < formattedLine.length() - 1
|
|
&& (formattedLine[index + 1] == '*'
|
|
|| formattedLine[index + 1] == '&'
|
|
|| formattedLine[index + 1] == '^'))
|
|
{
|
|
updateFormattedLineSplitPointsPointerOrReference(index);
|
|
testForTimeToSplitFormattedLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format pointer or reference cast
|
|
* currentChar contains the pointer or reference
|
|
* NOTE: the pointers and references in function definitions
|
|
* are processed as a cast (e.g. void foo(void*, void*))
|
|
* is processed here.
|
|
*/
|
|
void ASFormatter::formatPointerOrReferenceCast()
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(!isJavaStyle());
|
|
|
|
int pa = pointerAlignment;
|
|
int ra = referenceAlignment;
|
|
int itemAlignment = (currentChar == '*' || currentChar == '^') ? pa : ((ra == REF_SAME_AS_PTR) ? pa : ra);
|
|
|
|
string sequenceToInsert(1, currentChar);
|
|
if (isSequenceReached("**") || isSequenceReached("&&"))
|
|
{
|
|
goForward(1);
|
|
sequenceToInsert.append(1, currentLine[charNum]);
|
|
}
|
|
if (itemAlignment == PTR_ALIGN_NONE)
|
|
{
|
|
appendSequence(sequenceToInsert, false);
|
|
return;
|
|
}
|
|
// remove preceding whitespace
|
|
char prevCh = ' ';
|
|
size_t prevNum = formattedLine.find_last_not_of(" \t");
|
|
if (prevNum != string::npos)
|
|
{
|
|
prevCh = formattedLine[prevNum];
|
|
if (prevNum + 1 < formattedLine.length()
|
|
&& isWhiteSpace(formattedLine[prevNum + 1])
|
|
&& prevCh != '(')
|
|
{
|
|
spacePadNum -= (formattedLine.length() - 1 - prevNum);
|
|
formattedLine.erase(prevNum + 1);
|
|
}
|
|
}
|
|
bool isAfterScopeResolution = previousNonWSChar == ':';
|
|
if ((itemAlignment == PTR_ALIGN_MIDDLE || itemAlignment == PTR_ALIGN_NAME)
|
|
&& !isAfterScopeResolution && prevCh != '(')
|
|
{
|
|
appendSpacePad();
|
|
// in this case appendSpacePad may or may not update the split point
|
|
if (maxCodeLength != string::npos && formattedLine.length() > 0)
|
|
updateFormattedLineSplitPointsPointerOrReference(formattedLine.length() - 1);
|
|
appendSequence(sequenceToInsert, false);
|
|
}
|
|
else
|
|
appendSequence(sequenceToInsert, false);
|
|
}
|
|
|
|
/**
|
|
* add or remove space padding to parens
|
|
* currentChar contains the paren
|
|
* the parens and necessary padding will be appended to formattedLine
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::padParens()
|
|
{
|
|
assert(currentChar == '(' || currentChar == ')');
|
|
assert(shouldPadParensOutside || shouldPadParensInside || shouldUnPadParens || shouldPadFirstParen);
|
|
|
|
int spacesOutsideToDelete = 0;
|
|
int spacesInsideToDelete = 0;
|
|
|
|
if (currentChar == '(')
|
|
{
|
|
spacesOutsideToDelete = formattedLine.length() - 1;
|
|
spacesInsideToDelete = 0;
|
|
|
|
// compute spaces outside the opening paren to delete
|
|
if (shouldUnPadParens)
|
|
{
|
|
char lastChar = ' ';
|
|
bool prevIsParenHeader = false;
|
|
size_t i = formattedLine.find_last_not_of(" \t");
|
|
if (i != string::npos)
|
|
{
|
|
// if last char is a brace the previous whitespace is an indent
|
|
if (formattedLine[i] == '{')
|
|
spacesOutsideToDelete = 0;
|
|
else if (isCharImmediatelyPostPointerOrReference)
|
|
spacesOutsideToDelete = 0;
|
|
else
|
|
{
|
|
spacesOutsideToDelete -= i;
|
|
lastChar = formattedLine[i];
|
|
// if previous word is a header, it will be a paren header
|
|
string prevWord = getPreviousWord(formattedLine, formattedLine.length());
|
|
const string* prevWordH = nullptr;
|
|
if (shouldPadHeader
|
|
&& prevWord.length() > 0
|
|
&& isCharPotentialHeader(prevWord, 0))
|
|
prevWordH = ASBase::findHeader(prevWord, 0, headers);
|
|
if (prevWordH != nullptr)
|
|
prevIsParenHeader = true;
|
|
else if (prevWord == AS_RETURN) // don't unpad
|
|
prevIsParenHeader = true;
|
|
else if ((prevWord == AS_NEW || prevWord == AS_DELETE)
|
|
&& shouldPadHeader) // don't unpad
|
|
prevIsParenHeader = true;
|
|
else if (isCStyle() && prevWord == AS_THROW && shouldPadHeader) // don't unpad
|
|
prevIsParenHeader = true;
|
|
else if (prevWord == "and" || prevWord == "or" || prevWord == "in") // don't unpad
|
|
prevIsParenHeader = true;
|
|
// don't unpad variables
|
|
else if (prevWord == "bool"
|
|
|| prevWord == "int"
|
|
|| prevWord == "void"
|
|
|| prevWord == "void*"
|
|
|| prevWord == "char"
|
|
|| prevWord == "char*"
|
|
|| prevWord == "long"
|
|
|| prevWord == "double"
|
|
|| prevWord == "float"
|
|
|| (prevWord.length() >= 4 // check end of word for _t
|
|
&& prevWord.compare(prevWord.length() - 2, 2, "_t") == 0)
|
|
|| prevWord == "Int32"
|
|
|| prevWord == "UInt32"
|
|
|| prevWord == "Int64"
|
|
|| prevWord == "UInt64"
|
|
|| prevWord == "BOOL"
|
|
|| prevWord == "DWORD"
|
|
|| prevWord == "HWND"
|
|
|| prevWord == "INT"
|
|
|| prevWord == "LPSTR"
|
|
|| prevWord == "VOID"
|
|
|| prevWord == "LPVOID"
|
|
)
|
|
{
|
|
prevIsParenHeader = true;
|
|
}
|
|
}
|
|
}
|
|
// do not unpad operators, but leave them if already padded
|
|
if (shouldPadParensOutside || prevIsParenHeader)
|
|
spacesOutsideToDelete--;
|
|
else if (lastChar == '|' // check for ||
|
|
|| lastChar == '&' // check for &&
|
|
|| lastChar == ','
|
|
|| (lastChar == '(' && shouldPadParensInside)
|
|
|| (lastChar == '>' && !foundCastOperator)
|
|
|| lastChar == '<'
|
|
|| lastChar == '?'
|
|
|| lastChar == ':'
|
|
|| lastChar == ';'
|
|
|| lastChar == '='
|
|
|| lastChar == '+'
|
|
|| lastChar == '-'
|
|
|| lastChar == '*'
|
|
|| lastChar == '/'
|
|
|| lastChar == '%'
|
|
|| lastChar == '^'
|
|
)
|
|
spacesOutsideToDelete--;
|
|
|
|
if (spacesOutsideToDelete > 0)
|
|
{
|
|
formattedLine.erase(i + 1, spacesOutsideToDelete);
|
|
spacePadNum -= spacesOutsideToDelete;
|
|
}
|
|
}
|
|
|
|
// pad open paren outside
|
|
char peekedCharOutside = peekNextChar();
|
|
if (shouldPadFirstParen && previousChar != '(' && peekedCharOutside != ')')
|
|
appendSpacePad();
|
|
else if (shouldPadParensOutside)
|
|
{
|
|
if (!(currentChar == '(' && peekedCharOutside == ')'))
|
|
appendSpacePad();
|
|
}
|
|
|
|
appendCurrentChar();
|
|
|
|
// unpad open paren inside
|
|
if (shouldUnPadParens)
|
|
{
|
|
size_t j = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (j != string::npos)
|
|
spacesInsideToDelete = j - charNum - 1;
|
|
if (shouldPadParensInside)
|
|
spacesInsideToDelete--;
|
|
if (spacesInsideToDelete > 0)
|
|
{
|
|
currentLine.erase(charNum + 1, spacesInsideToDelete);
|
|
spacePadNum -= spacesInsideToDelete;
|
|
}
|
|
// convert tab to space if requested
|
|
if (shouldConvertTabs
|
|
&& (int) currentLine.length() > charNum + 1
|
|
&& currentLine[charNum + 1] == '\t')
|
|
currentLine[charNum + 1] = ' ';
|
|
}
|
|
|
|
// pad open paren inside
|
|
char peekedCharInside = peekNextChar();
|
|
if (shouldPadParensInside)
|
|
if (!(currentChar == '(' && peekedCharInside == ')'))
|
|
appendSpaceAfter();
|
|
}
|
|
else if (currentChar == ')')
|
|
{
|
|
// unpad close paren inside
|
|
if (shouldUnPadParens)
|
|
{
|
|
spacesInsideToDelete = formattedLine.length();
|
|
size_t i = formattedLine.find_last_not_of(" \t");
|
|
if (i != string::npos)
|
|
spacesInsideToDelete = formattedLine.length() - 1 - i;
|
|
if (shouldPadParensInside)
|
|
spacesInsideToDelete--;
|
|
if (spacesInsideToDelete > 0)
|
|
{
|
|
formattedLine.erase(i + 1, spacesInsideToDelete);
|
|
spacePadNum -= spacesInsideToDelete;
|
|
}
|
|
}
|
|
|
|
// pad close paren inside
|
|
if (shouldPadParensInside)
|
|
if (!(previousChar == '(' && currentChar == ')'))
|
|
appendSpacePad();
|
|
|
|
appendCurrentChar();
|
|
|
|
// unpad close paren outside
|
|
// close parens outside are left unchanged
|
|
if (shouldUnPadParens)
|
|
{
|
|
//spacesOutsideToDelete = 0;
|
|
//size_t j = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
//if (j != string::npos)
|
|
// spacesOutsideToDelete = j - charNum - 1;
|
|
//if (shouldPadParensOutside)
|
|
// spacesOutsideToDelete--;
|
|
|
|
//if (spacesOutsideToDelete > 0)
|
|
//{
|
|
// currentLine.erase(charNum + 1, spacesOutsideToDelete);
|
|
// spacePadNum -= spacesOutsideToDelete;
|
|
//}
|
|
}
|
|
|
|
// pad close paren outside
|
|
char peekedCharOutside = peekNextChar();
|
|
if (shouldPadParensOutside)
|
|
if (peekedCharOutside != ';'
|
|
&& peekedCharOutside != ','
|
|
&& peekedCharOutside != '.'
|
|
&& peekedCharOutside != '+' // check for ++
|
|
&& peekedCharOutside != '-' // check for --
|
|
&& peekedCharOutside != ']')
|
|
appendSpaceAfter();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add or remove space padding to objective-c parens
|
|
* these options have precedence over the padParens methods
|
|
* the padParens method has already been called, this method adjusts
|
|
*/
|
|
void ASFormatter::padObjCMethodPrefix()
|
|
{
|
|
assert(currentChar == '(' && isImmediatelyPostObjCMethodPrefix);
|
|
assert(shouldPadMethodPrefix || shouldUnPadMethodPrefix);
|
|
|
|
size_t prefix = formattedLine.find_first_of("+-");
|
|
if (prefix == string::npos)
|
|
return;
|
|
size_t paren = formattedLine.find_first_of('(');
|
|
if (paren == string::npos)
|
|
return;
|
|
int spaces = paren - prefix - 1;
|
|
|
|
if (shouldPadMethodPrefix)
|
|
{
|
|
if (spaces == 0)
|
|
{
|
|
formattedLine.insert(prefix + 1, 1, ' ');
|
|
spacePadNum += 1;
|
|
}
|
|
else if (spaces > 1)
|
|
{
|
|
formattedLine.erase(prefix + 1, spaces - 1);
|
|
spacePadNum -= spaces - 1;
|
|
}
|
|
}
|
|
// this option will be ignored if used with pad-method-prefix
|
|
else if (shouldUnPadMethodPrefix)
|
|
{
|
|
if (spaces > 0)
|
|
{
|
|
formattedLine.erase(prefix + 1, spaces);
|
|
spacePadNum -= spaces;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add or remove space padding to objective-c parens
|
|
* these options have precedence over the padParens methods
|
|
* the padParens method has already been called, this method adjusts
|
|
*/
|
|
void ASFormatter::padObjCReturnType()
|
|
{
|
|
assert(currentChar == ')' && isInObjCReturnType);
|
|
assert(shouldPadReturnType || shouldUnPadReturnType);
|
|
|
|
size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextText == string::npos)
|
|
return;
|
|
int spaces = nextText - charNum - 1;
|
|
|
|
if (shouldPadReturnType)
|
|
{
|
|
if (spaces == 0)
|
|
{
|
|
// this will already be padded if pad-paren is used
|
|
if (formattedLine[formattedLine.length() - 1] != ' ')
|
|
{
|
|
formattedLine.append(" ");
|
|
spacePadNum += 1;
|
|
}
|
|
}
|
|
else if (spaces > 1)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces - 1);
|
|
spacePadNum -= spaces - 1;
|
|
}
|
|
}
|
|
// this option will be ignored if used with pad-return-type
|
|
else if (shouldUnPadReturnType)
|
|
{
|
|
// this will already be padded if pad-paren is used
|
|
if (formattedLine[formattedLine.length() - 1] == ' ')
|
|
{
|
|
spacePadNum -= formattedLine.length() - 1 - nextText;
|
|
int lastText = formattedLine.find_last_not_of(" \t");
|
|
formattedLine.resize(lastText + 1);
|
|
}
|
|
if (spaces > 0)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces);
|
|
spacePadNum -= spaces;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add or remove space padding to objective-c parens
|
|
* these options have precedence over the padParens methods
|
|
* the padParens method has already been called, this method adjusts
|
|
*/
|
|
void ASFormatter::padObjCParamType()
|
|
{
|
|
assert((currentChar == '(' || currentChar == ')') && isInObjCMethodDefinition);
|
|
assert(!isImmediatelyPostObjCMethodPrefix && !isInObjCReturnType);
|
|
assert(shouldPadParamType || shouldUnPadParamType);
|
|
|
|
if (currentChar == '(')
|
|
{
|
|
// open paren has already been attached to formattedLine by padParen
|
|
size_t paramOpen = formattedLine.rfind('(');
|
|
assert(paramOpen != string::npos);
|
|
size_t prevText = formattedLine.find_last_not_of(" \t", paramOpen - 1);
|
|
if (prevText == string::npos)
|
|
return;
|
|
int spaces = paramOpen - prevText - 1;
|
|
|
|
if (shouldPadParamType
|
|
|| objCColonPadMode == COLON_PAD_ALL
|
|
|| objCColonPadMode == COLON_PAD_AFTER)
|
|
{
|
|
if (spaces == 0)
|
|
{
|
|
formattedLine.insert(paramOpen, 1, ' ');
|
|
spacePadNum += 1;
|
|
}
|
|
if (spaces > 1)
|
|
{
|
|
formattedLine.erase(prevText + 1, spaces - 1);
|
|
spacePadNum -= spaces - 1;
|
|
}
|
|
}
|
|
// this option will be ignored if used with pad-param-type
|
|
else if (shouldUnPadParamType
|
|
|| objCColonPadMode == COLON_PAD_NONE
|
|
|| objCColonPadMode == COLON_PAD_BEFORE)
|
|
{
|
|
if (spaces > 0)
|
|
{
|
|
formattedLine.erase(prevText + 1, spaces);
|
|
spacePadNum -= spaces;
|
|
}
|
|
}
|
|
}
|
|
else if (currentChar == ')')
|
|
{
|
|
size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextText == string::npos)
|
|
return;
|
|
int spaces = nextText - charNum - 1;
|
|
|
|
if (shouldPadParamType)
|
|
{
|
|
if (spaces == 0)
|
|
{
|
|
// this will already be padded if pad-paren is used
|
|
if (formattedLine[formattedLine.length() - 1] != ' ')
|
|
{
|
|
formattedLine.append(" ");
|
|
spacePadNum += 1;
|
|
}
|
|
}
|
|
else if (spaces > 1)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces - 1);
|
|
spacePadNum -= spaces - 1;
|
|
}
|
|
}
|
|
// this option will be ignored if used with pad-param-type
|
|
else if (shouldUnPadParamType)
|
|
{
|
|
// this will already be padded if pad-paren is used
|
|
if (formattedLine[formattedLine.length() - 1] == ' ')
|
|
{
|
|
spacePadNum -= 1;
|
|
int lastText = formattedLine.find_last_not_of(" \t");
|
|
formattedLine.resize(lastText + 1);
|
|
}
|
|
if (spaces > 0)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces);
|
|
spacePadNum -= spaces;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format opening brace as attached or broken
|
|
* currentChar contains the brace
|
|
* the braces will be appended to the current formattedLine or a new formattedLine as necessary
|
|
* the calling function should have a continue statement after calling this method
|
|
*
|
|
* @param braceType the type of brace to be formatted.
|
|
*/
|
|
void ASFormatter::formatOpeningBrace(BraceType braceType)
|
|
{
|
|
assert(!isBraceType(braceType, ARRAY_TYPE));
|
|
assert(currentChar == '{');
|
|
|
|
parenStack->emplace_back(0);
|
|
|
|
bool breakBrace = isCurrentBraceBroken();
|
|
|
|
if (breakBrace)
|
|
{
|
|
if (isBeforeAnyComment() && isOkToBreakBlock(braceType))
|
|
{
|
|
// if comment is at line end leave the comment on this line
|
|
if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace)
|
|
{
|
|
currentChar = ' '; // remove brace from current line
|
|
if (parenStack->size() > 1)
|
|
parenStack->pop_back();
|
|
currentLine[charNum] = currentChar;
|
|
appendOpeningBrace = true; // append brace to following line
|
|
}
|
|
// else put comment after the brace
|
|
else if (!isBeforeMultipleLineEndComments(charNum))
|
|
breakLine();
|
|
}
|
|
else if (!isBraceType(braceType, SINGLE_LINE_TYPE))
|
|
{
|
|
formattedLine = rtrim(formattedLine);
|
|
breakLine();
|
|
}
|
|
else if ((shouldBreakOneLineBlocks || isBraceType(braceType, BREAK_BLOCK_TYPE))
|
|
&& !isBraceType(braceType, EMPTY_BLOCK_TYPE))
|
|
breakLine();
|
|
else if (!isInLineBreak)
|
|
appendSpacePad();
|
|
|
|
appendCurrentChar();
|
|
|
|
// should a following comment break from the brace?
|
|
// must break the line AFTER the brace
|
|
if (isBeforeComment()
|
|
&& formattedLine.length() > 0
|
|
&& formattedLine[0] == '{'
|
|
&& isOkToBreakBlock(braceType)
|
|
&& (braceFormatMode == BREAK_MODE
|
|
|| braceFormatMode == LINUX_MODE))
|
|
{
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
}
|
|
else // attach brace
|
|
{
|
|
// are there comments before the brace?
|
|
if (isCharImmediatelyPostComment || isCharImmediatelyPostLineComment)
|
|
{
|
|
if (isOkToBreakBlock(braceType)
|
|
&& !(isCharImmediatelyPostComment && isCharImmediatelyPostLineComment) // don't attach if two comments on the line
|
|
&& !isImmediatelyPostPreprocessor
|
|
// && peekNextChar() != '}' // don't attach { } // removed release 2.03
|
|
&& previousCommandChar != '{' // don't attach { {
|
|
&& previousCommandChar != '}' // don't attach } {
|
|
&& previousCommandChar != ';') // don't attach ; {
|
|
{
|
|
appendCharInsideComments();
|
|
}
|
|
else
|
|
{
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
}
|
|
else if (previousCommandChar == '{'
|
|
|| (previousCommandChar == '}' && !isInClassInitializer)
|
|
|| previousCommandChar == ';') // '}' , ';' chars added for proper handling of '{' immediately after a '}' or ';'
|
|
{
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
else
|
|
{
|
|
// if a blank line precedes this don't attach
|
|
if (isEmptyLine(formattedLine))
|
|
appendCurrentChar(); // don't attach
|
|
else if (isOkToBreakBlock(braceType)
|
|
&& !(isImmediatelyPostPreprocessor
|
|
&& currentLineBeginsWithBrace))
|
|
{
|
|
if (!isBraceType(braceType, EMPTY_BLOCK_TYPE))
|
|
{
|
|
appendSpacePad();
|
|
appendCurrentChar(false); // OK to attach
|
|
testForTimeToSplitFormattedLine(); // line length will have changed
|
|
// should a following comment attach with the brace?
|
|
// insert spaces to reposition the comment
|
|
if (isBeforeComment()
|
|
&& !isBeforeMultipleLineEndComments(charNum)
|
|
&& (!isBeforeAnyLineEndComment(charNum) || currentLineBeginsWithBrace))
|
|
{
|
|
shouldBreakLineAtNextChar = true;
|
|
currentLine.insert(charNum + 1, charNum + 1, ' ');
|
|
}
|
|
else if (!isBeforeAnyComment()) // added in release 2.03
|
|
{
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (currentLineBeginsWithBrace && charNum == (int) currentLineFirstBraceNum)
|
|
{
|
|
appendSpacePad();
|
|
appendCurrentChar(false); // attach
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
else
|
|
{
|
|
appendSpacePad();
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!isInLineBreak)
|
|
appendSpacePad();
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format closing brace
|
|
* currentChar contains the brace
|
|
* the calling function should have a continue statement after calling this method
|
|
*
|
|
* @param braceType the type of the opening brace for this closing brace.
|
|
*/
|
|
void ASFormatter::formatClosingBrace(BraceType braceType)
|
|
{
|
|
assert(!isBraceType(braceType, ARRAY_TYPE));
|
|
assert(currentChar == '}');
|
|
|
|
// parenStack must contain one entry
|
|
if (parenStack->size() > 1)
|
|
parenStack->pop_back();
|
|
|
|
// mark state of immediately after empty block
|
|
// this state will be used for locating braces that appear immediately AFTER an empty block (e.g. '{} \n}').
|
|
if (previousCommandChar == '{')
|
|
isImmediatelyPostEmptyBlock = true;
|
|
|
|
if (attachClosingBraceMode)
|
|
{
|
|
// for now, namespaces and classes will be attached. Uncomment the lines below to break.
|
|
if ((isEmptyLine(formattedLine) // if a blank line precedes this
|
|
|| isCharImmediatelyPostLineComment
|
|
|| isCharImmediatelyPostComment
|
|
|| (isImmediatelyPostPreprocessor && (int) currentLine.find_first_not_of(" \t") == charNum)
|
|
// || (isBraceType(braceType, CLASS_TYPE) && isOkToBreakBlock(braceType) && previousNonWSChar != '{')
|
|
// || (isBraceType(braceType, NAMESPACE_TYPE) && isOkToBreakBlock(braceType) && previousNonWSChar != '{')
|
|
)
|
|
&& (!isBraceType(braceType, SINGLE_LINE_TYPE) || isOkToBreakBlock(braceType)))
|
|
{
|
|
breakLine();
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
else
|
|
{
|
|
if (previousNonWSChar != '{'
|
|
&& (!isBraceType(braceType, SINGLE_LINE_TYPE)
|
|
|| isOkToBreakBlock(braceType)))
|
|
appendSpacePad();
|
|
appendCurrentChar(false); // attach
|
|
}
|
|
}
|
|
else if (!isBraceType(braceType, EMPTY_BLOCK_TYPE)
|
|
&& (isBraceType(braceType, BREAK_BLOCK_TYPE)
|
|
|| isOkToBreakBlock(braceType)))
|
|
{
|
|
breakLine();
|
|
appendCurrentChar();
|
|
}
|
|
else
|
|
{
|
|
appendCurrentChar();
|
|
}
|
|
|
|
// if a declaration follows a definition, space pad
|
|
if (isLegalNameChar(peekNextChar()))
|
|
appendSpaceAfter();
|
|
|
|
if (shouldBreakBlocks
|
|
&& currentHeader != nullptr
|
|
&& !isHeaderInMultiStatementLine
|
|
&& parenStack->back() == 0)
|
|
{
|
|
if (currentHeader == &AS_CASE || currentHeader == &AS_DEFAULT)
|
|
{
|
|
// do not yet insert a line if "break" statement is outside the braces
|
|
string nextText = peekNextText(currentLine.substr(charNum + 1));
|
|
if (nextText.length() > 0
|
|
&& nextText.substr(0, 5) != "break")
|
|
isAppendPostBlockEmptyLineRequested = true;
|
|
}
|
|
else
|
|
isAppendPostBlockEmptyLineRequested = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format array braces as attached or broken
|
|
* determine if the braces can have an inStatement indent
|
|
* currentChar contains the brace
|
|
* the braces will be appended to the current formattedLine or a new formattedLine as necessary
|
|
* the calling function should have a continue statement after calling this method
|
|
*
|
|
* @param braceType the type of brace to be formatted, must be an ARRAY_TYPE.
|
|
* @param isOpeningArrayBrace indicates if this is the opening brace for the array block.
|
|
*/
|
|
void ASFormatter::formatArrayBraces(BraceType braceType, bool isOpeningArrayBrace)
|
|
{
|
|
assert(isBraceType(braceType, ARRAY_TYPE));
|
|
assert(currentChar == '{' || currentChar == '}');
|
|
|
|
if (currentChar == '{')
|
|
{
|
|
// is this the first opening brace in the array?
|
|
if (isOpeningArrayBrace)
|
|
{
|
|
if (braceFormatMode == ATTACH_MODE
|
|
|| braceFormatMode == LINUX_MODE)
|
|
{
|
|
// break an enum if mozilla
|
|
if (isBraceType(braceType, ENUM_TYPE)
|
|
&& formattingStyle == STYLE_MOZILLA)
|
|
{
|
|
isInLineBreak = true;
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
// don't attach to a preprocessor directive or '\' line
|
|
else if ((isImmediatelyPostPreprocessor
|
|
|| (formattedLine.length() > 0
|
|
&& formattedLine[formattedLine.length() - 1] == '\\'))
|
|
&& currentLineBeginsWithBrace)
|
|
{
|
|
isInLineBreak = true;
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
else if (isCharImmediatelyPostComment)
|
|
{
|
|
// TODO: attach brace to line-end comment
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
else if (isCharImmediatelyPostLineComment && !isBraceType(braceType, SINGLE_LINE_TYPE))
|
|
{
|
|
appendCharInsideComments();
|
|
}
|
|
else
|
|
{
|
|
// if a blank line precedes this don't attach
|
|
if (isEmptyLine(formattedLine))
|
|
appendCurrentChar(); // don't attach
|
|
else
|
|
{
|
|
// if brace is broken or not an assignment
|
|
if (currentLineBeginsWithBrace
|
|
&& !isBraceType(braceType, SINGLE_LINE_TYPE))
|
|
{
|
|
appendSpacePad();
|
|
appendCurrentChar(false); // OK to attach
|
|
// TODO: debug the following line
|
|
testForTimeToSplitFormattedLine(); // line length will have changed
|
|
|
|
if (currentLineBeginsWithBrace
|
|
&& (int) currentLineFirstBraceNum == charNum)
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
else
|
|
{
|
|
if (previousNonWSChar != '(')
|
|
{
|
|
// don't space pad C++11 uniform initialization
|
|
if (!isBraceType(braceType, INIT_TYPE))
|
|
appendSpacePad();
|
|
}
|
|
appendCurrentChar();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (braceFormatMode == BREAK_MODE)
|
|
{
|
|
if (isWhiteSpace(peekNextChar()) && !isInVirginLine)
|
|
breakLine();
|
|
else if (isBeforeAnyComment())
|
|
{
|
|
// do not break unless comment is at line end
|
|
if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace)
|
|
{
|
|
currentChar = ' '; // remove brace from current line
|
|
appendOpeningBrace = true; // append brace to following line
|
|
}
|
|
}
|
|
if (!isInLineBreak && previousNonWSChar != '(')
|
|
{
|
|
// don't space pad C++11 uniform initialization
|
|
if (!isBraceType(braceType, INIT_TYPE))
|
|
appendSpacePad();
|
|
}
|
|
appendCurrentChar();
|
|
|
|
if (currentLineBeginsWithBrace
|
|
&& (int) currentLineFirstBraceNum == charNum
|
|
&& !isBraceType(braceType, SINGLE_LINE_TYPE))
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
else if (braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
if (isWhiteSpace(peekNextChar()) && !isInVirginLine)
|
|
breakLine();
|
|
else if (isBeforeAnyComment())
|
|
{
|
|
// do not break unless comment is at line end
|
|
if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace)
|
|
{
|
|
currentChar = ' '; // remove brace from current line
|
|
appendOpeningBrace = true; // append brace to following line
|
|
}
|
|
}
|
|
if (!isInLineBreak && previousNonWSChar != '(')
|
|
{
|
|
// don't space pad C++11 uniform initialization
|
|
if (!isBraceType(braceType, INIT_TYPE))
|
|
appendSpacePad();
|
|
}
|
|
appendCurrentChar();
|
|
}
|
|
else if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (currentLineBeginsWithBrace
|
|
&& charNum == (int) currentLineFirstBraceNum)
|
|
{
|
|
appendCurrentChar(); // don't attach
|
|
}
|
|
else
|
|
{
|
|
if (previousNonWSChar != '(')
|
|
{
|
|
// don't space pad C++11 uniform initialization
|
|
if (!isBraceType(braceType, INIT_TYPE))
|
|
appendSpacePad();
|
|
}
|
|
appendCurrentChar(false); // OK to attach
|
|
}
|
|
}
|
|
}
|
|
else // not the first opening brace
|
|
{
|
|
if (braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
if (previousNonWSChar == '{'
|
|
&& braceTypeStack->size() > 2
|
|
&& !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2],
|
|
SINGLE_LINE_TYPE))
|
|
formatArrayRunIn();
|
|
}
|
|
else if (!isInLineBreak
|
|
&& !isWhiteSpace(peekNextChar())
|
|
&& previousNonWSChar == '{'
|
|
&& braceTypeStack->size() > 2
|
|
&& !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2],
|
|
SINGLE_LINE_TYPE))
|
|
formatArrayRunIn();
|
|
|
|
appendCurrentChar();
|
|
}
|
|
}
|
|
else if (currentChar == '}')
|
|
{
|
|
if (attachClosingBraceMode)
|
|
{
|
|
if (isEmptyLine(formattedLine) // if a blank line precedes this
|
|
|| isImmediatelyPostPreprocessor
|
|
|| isCharImmediatelyPostLineComment
|
|
|| isCharImmediatelyPostComment)
|
|
appendCurrentChar(); // don't attach
|
|
else
|
|
{
|
|
appendSpacePad();
|
|
appendCurrentChar(false); // attach
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// does this close the first opening brace in the array?
|
|
// must check if the block is still a single line because of anonymous statements
|
|
if (!isBraceType(braceType, INIT_TYPE)
|
|
&& (!isBraceType(braceType, SINGLE_LINE_TYPE)
|
|
|| formattedLine.find('{') == string::npos))
|
|
breakLine();
|
|
appendCurrentChar();
|
|
}
|
|
|
|
// if a declaration follows an enum definition, space pad
|
|
char peekedChar = peekNextChar();
|
|
if (isLegalNameChar(peekedChar)
|
|
|| peekedChar == '[')
|
|
appendSpaceAfter();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* determine if a run-in can be attached.
|
|
* if it can insert the indents in formattedLine and reset the current line break.
|
|
*/
|
|
void ASFormatter::formatRunIn()
|
|
{
|
|
assert(braceFormatMode == RUN_IN_MODE || braceFormatMode == NONE_MODE);
|
|
|
|
// keep one line blocks returns true without indenting the run-in
|
|
if (formattingStyle != STYLE_PICO
|
|
&& !isOkToBreakBlock(braceTypeStack->back()))
|
|
return; // true;
|
|
|
|
// make sure the line begins with a brace
|
|
size_t lastText = formattedLine.find_last_not_of(" \t");
|
|
if (lastText == string::npos || formattedLine[lastText] != '{')
|
|
return; // false;
|
|
|
|
// make sure the brace is broken
|
|
if (formattedLine.find_first_not_of(" \t{") != string::npos)
|
|
return; // false;
|
|
|
|
if (isBraceType(braceTypeStack->back(), NAMESPACE_TYPE))
|
|
return; // false;
|
|
|
|
bool extraIndent = false;
|
|
bool extraHalfIndent = false;
|
|
isInLineBreak = true;
|
|
|
|
// cannot attach a class modifier without indent-classes
|
|
if (isCStyle()
|
|
&& isCharPotentialHeader(currentLine, charNum)
|
|
&& (isBraceType(braceTypeStack->back(), CLASS_TYPE)
|
|
|| (isBraceType(braceTypeStack->back(), STRUCT_TYPE)
|
|
&& isInIndentableStruct)))
|
|
{
|
|
if (findKeyword(currentLine, charNum, AS_PUBLIC)
|
|
|| findKeyword(currentLine, charNum, AS_PRIVATE)
|
|
|| findKeyword(currentLine, charNum, AS_PROTECTED))
|
|
{
|
|
if (getModifierIndent())
|
|
extraHalfIndent = true;
|
|
else if (!getClassIndent())
|
|
return; // false;
|
|
}
|
|
else if (getClassIndent())
|
|
extraIndent = true;
|
|
}
|
|
|
|
// cannot attach a 'case' statement without indent-switches
|
|
if (!getSwitchIndent()
|
|
&& isCharPotentialHeader(currentLine, charNum)
|
|
&& (findKeyword(currentLine, charNum, AS_CASE)
|
|
|| findKeyword(currentLine, charNum, AS_DEFAULT)))
|
|
return; // false;
|
|
|
|
// extra indent for switch statements
|
|
if (getSwitchIndent()
|
|
&& !preBraceHeaderStack->empty()
|
|
&& preBraceHeaderStack->back() == &AS_SWITCH
|
|
&& ((isLegalNameChar(currentChar)
|
|
&& !findKeyword(currentLine, charNum, AS_CASE))))
|
|
extraIndent = true;
|
|
|
|
isInLineBreak = false;
|
|
// remove for extra whitespace
|
|
if (formattedLine.length() > lastText + 1
|
|
&& formattedLine.find_first_not_of(" \t", lastText + 1) == string::npos)
|
|
formattedLine.erase(lastText + 1);
|
|
|
|
if (extraHalfIndent)
|
|
{
|
|
int indentLength_ = getIndentLength();
|
|
runInIndentChars = indentLength_ / 2;
|
|
formattedLine.append(runInIndentChars - 1, ' ');
|
|
}
|
|
else if (getForceTabIndentation() && getIndentLength() != getTabLength())
|
|
{
|
|
// insert the space indents
|
|
string indent;
|
|
int indentLength_ = getIndentLength();
|
|
int tabLength_ = getTabLength();
|
|
indent.append(indentLength_, ' ');
|
|
if (extraIndent)
|
|
indent.append(indentLength_, ' ');
|
|
// replace spaces indents with tab indents
|
|
size_t tabCount = indent.length() / tabLength_; // truncate extra spaces
|
|
indent.replace(0U, tabCount * tabLength_, tabCount, '\t');
|
|
runInIndentChars = indentLength_;
|
|
if (indent[0] == ' ') // allow for brace
|
|
indent.erase(0, 1);
|
|
formattedLine.append(indent);
|
|
}
|
|
else if (getIndentString() == "\t")
|
|
{
|
|
appendChar('\t', false);
|
|
runInIndentChars = 2; // one for { and one for tab
|
|
if (extraIndent)
|
|
{
|
|
appendChar('\t', false);
|
|
runInIndentChars++;
|
|
}
|
|
}
|
|
else // spaces
|
|
{
|
|
int indentLength_ = getIndentLength();
|
|
formattedLine.append(indentLength_ - 1, ' ');
|
|
runInIndentChars = indentLength_;
|
|
if (extraIndent)
|
|
{
|
|
formattedLine.append(indentLength_, ' ');
|
|
runInIndentChars += indentLength_;
|
|
}
|
|
}
|
|
isInBraceRunIn = true;
|
|
}
|
|
|
|
/**
|
|
* remove whitespace and add indentation for an array run-in.
|
|
*/
|
|
void ASFormatter::formatArrayRunIn()
|
|
{
|
|
assert(isBraceType(braceTypeStack->back(), ARRAY_TYPE));
|
|
|
|
// make sure the brace is broken
|
|
if (formattedLine.find_first_not_of(" \t{") != string::npos)
|
|
return;
|
|
|
|
size_t lastText = formattedLine.find_last_not_of(" \t");
|
|
if (lastText == string::npos || formattedLine[lastText] != '{')
|
|
return;
|
|
|
|
// check for extra whitespace
|
|
if (formattedLine.length() > lastText + 1
|
|
&& formattedLine.find_first_not_of(" \t", lastText + 1) == string::npos)
|
|
formattedLine.erase(lastText + 1);
|
|
|
|
if (getIndentString() == "\t")
|
|
{
|
|
appendChar('\t', false);
|
|
runInIndentChars = 2; // one for { and one for tab
|
|
}
|
|
else
|
|
{
|
|
int indent = getIndentLength();
|
|
formattedLine.append(indent - 1, ' ');
|
|
runInIndentChars = indent;
|
|
}
|
|
isInBraceRunIn = true;
|
|
isInLineBreak = false;
|
|
}
|
|
|
|
/**
|
|
* delete a braceTypeStack vector object
|
|
* BraceTypeStack did not work with the DeleteContainer template
|
|
*/
|
|
void ASFormatter::deleteContainer(vector<BraceType>*& container)
|
|
{
|
|
if (container != nullptr)
|
|
{
|
|
container->clear();
|
|
delete (container);
|
|
container = nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* delete a vector object
|
|
* T is the type of vector
|
|
* used for all vectors except braceTypeStack
|
|
*/
|
|
template<typename T>
|
|
void ASFormatter::deleteContainer(T& container)
|
|
{
|
|
if (container != nullptr)
|
|
{
|
|
container->clear();
|
|
delete (container);
|
|
container = nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* initialize a braceType vector object
|
|
* braceType did not work with the DeleteContainer template
|
|
*/
|
|
void ASFormatter::initContainer(vector<BraceType>*& container, vector<BraceType>* value)
|
|
{
|
|
if (container != nullptr)
|
|
deleteContainer(container);
|
|
container = value;
|
|
}
|
|
|
|
/**
|
|
* initialize a vector object
|
|
* T is the type of vector
|
|
* used for all vectors except braceTypeStack
|
|
*/
|
|
template<typename T>
|
|
void ASFormatter::initContainer(T& container, T value)
|
|
{
|
|
// since the ASFormatter object is never deleted,
|
|
// the existing vectors must be deleted before creating new ones
|
|
if (container != nullptr)
|
|
deleteContainer(container);
|
|
container = value;
|
|
}
|
|
|
|
/**
|
|
* convert a tab to spaces.
|
|
* charNum points to the current character to convert to spaces.
|
|
* tabIncrementIn is the increment that must be added for tab indent characters
|
|
* to get the correct column for the current tab.
|
|
* replaces the tab in currentLine with the required number of spaces.
|
|
* replaces the value of currentChar.
|
|
*/
|
|
void ASFormatter::convertTabToSpaces()
|
|
{
|
|
assert(currentChar == '\t');
|
|
|
|
// do NOT replace if in quotes
|
|
if (isInQuote || isInQuoteContinuation)
|
|
return;
|
|
|
|
size_t tabSize = getTabLength();
|
|
size_t numSpaces = tabSize - ((tabIncrementIn + charNum) % tabSize);
|
|
currentLine.replace(charNum, 1, numSpaces, ' ');
|
|
currentChar = currentLine[charNum];
|
|
}
|
|
|
|
/**
|
|
* is it ok to break this block?
|
|
*/
|
|
bool ASFormatter::isOkToBreakBlock(BraceType braceType) const
|
|
{
|
|
// Actually, there should not be an ARRAY_TYPE brace here.
|
|
// But this will avoid breaking a one line block when there is.
|
|
// Otherwise they will be formatted differently on consecutive runs.
|
|
if (isBraceType(braceType, ARRAY_TYPE)
|
|
&& isBraceType(braceType, SINGLE_LINE_TYPE))
|
|
return false;
|
|
if (isBraceType(braceType, COMMAND_TYPE)
|
|
&& isBraceType(braceType, EMPTY_BLOCK_TYPE))
|
|
return false;
|
|
if (!isBraceType(braceType, SINGLE_LINE_TYPE)
|
|
|| isBraceType(braceType, BREAK_BLOCK_TYPE)
|
|
|| shouldBreakOneLineBlocks)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* check if a sharp header is a paren or non-paren header
|
|
*/
|
|
bool ASFormatter::isSharpStyleWithParen(const string* header) const
|
|
{
|
|
return (isSharpStyle() && peekNextChar() == '('
|
|
&& (header == &AS_CATCH
|
|
|| header == &AS_DELEGATE));
|
|
}
|
|
|
|
/**
|
|
* Check for a following header when a comment is reached.
|
|
* firstLine must contain the start of the comment.
|
|
* return value is a pointer to the header or nullptr.
|
|
*/
|
|
const string* ASFormatter::checkForHeaderFollowingComment(const string& firstLine) const
|
|
{
|
|
assert(isInComment || isInLineComment);
|
|
assert(shouldBreakElseIfs || shouldBreakBlocks || isInSwitchStatement());
|
|
// look ahead to find the next non-comment text
|
|
bool endOnEmptyLine = (currentHeader == nullptr);
|
|
if (isInSwitchStatement())
|
|
endOnEmptyLine = false;
|
|
string nextText = peekNextText(firstLine, endOnEmptyLine);
|
|
|
|
if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0))
|
|
return nullptr;
|
|
|
|
return ASBase::findHeader(nextText, 0, headers);
|
|
}
|
|
|
|
/**
|
|
* process preprocessor statements.
|
|
* charNum should be the index of the #.
|
|
*
|
|
* delete braceTypeStack entries added by #if if a #else is found.
|
|
* prevents double entries in the braceTypeStack.
|
|
*/
|
|
void ASFormatter::processPreprocessor()
|
|
{
|
|
assert(currentChar == '#');
|
|
|
|
const size_t preproc = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
|
|
if (preproc == string::npos)
|
|
return;
|
|
|
|
if (currentLine.compare(preproc, 2, "if") == 0)
|
|
{
|
|
preprocBraceTypeStackSize = braceTypeStack->size();
|
|
}
|
|
else if (currentLine.compare(preproc, 4, "else") == 0)
|
|
{
|
|
// delete stack entries added in #if
|
|
// should be replaced by #else
|
|
if (preprocBraceTypeStackSize > 0)
|
|
{
|
|
int addedPreproc = braceTypeStack->size() - preprocBraceTypeStackSize;
|
|
for (int i = 0; i < addedPreproc; i++)
|
|
braceTypeStack->pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* determine if the next line starts a comment
|
|
* and a header follows the comment or comments.
|
|
*/
|
|
bool ASFormatter::commentAndHeaderFollows()
|
|
{
|
|
// called ONLY IF shouldDeleteEmptyLines and shouldBreakBlocks are TRUE.
|
|
assert(shouldDeleteEmptyLines && shouldBreakBlocks);
|
|
|
|
// is the next line a comment
|
|
auto stream = make_shared<ASPeekStream>(sourceIterator);
|
|
if (!stream->hasMoreLines())
|
|
return false;
|
|
string nextLine_ = stream->peekNextLine();
|
|
size_t firstChar = nextLine_.find_first_not_of(" \t");
|
|
if (firstChar == string::npos
|
|
|| !(nextLine_.compare(firstChar, 2, "//") == 0
|
|
|| nextLine_.compare(firstChar, 2, "/*") == 0))
|
|
return false;
|
|
|
|
// find the next non-comment text, and reset
|
|
string nextText = peekNextText(nextLine_, false, stream);
|
|
if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0))
|
|
return false;
|
|
|
|
const string* newHeader = ASBase::findHeader(nextText, 0, headers);
|
|
|
|
if (newHeader == nullptr)
|
|
return false;
|
|
|
|
// if a closing header, reset break unless break is requested
|
|
if (isClosingHeader(newHeader) && !shouldBreakClosingHeaderBlocks)
|
|
{
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* determine if a brace should be attached or broken
|
|
* uses braces in the braceTypeStack
|
|
* the last brace in the braceTypeStack is the one being formatted
|
|
* returns true if the brace should be broken
|
|
*/
|
|
bool ASFormatter::isCurrentBraceBroken() const
|
|
{
|
|
assert(braceTypeStack->size() > 1);
|
|
|
|
bool breakBrace = false;
|
|
size_t stackEnd = braceTypeStack->size() - 1;
|
|
|
|
// check brace modifiers
|
|
if (shouldAttachExternC
|
|
&& isBraceType((*braceTypeStack)[stackEnd], EXTERN_TYPE))
|
|
{
|
|
return false;
|
|
}
|
|
if (shouldAttachNamespace
|
|
&& isBraceType((*braceTypeStack)[stackEnd], NAMESPACE_TYPE))
|
|
{
|
|
return false;
|
|
}
|
|
if (shouldAttachClass
|
|
&& (isBraceType((*braceTypeStack)[stackEnd], CLASS_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd], INTERFACE_TYPE)))
|
|
{
|
|
return false;
|
|
}
|
|
if (shouldAttachInline
|
|
&& isCStyle() // for C++ only
|
|
&& braceFormatMode != RUN_IN_MODE
|
|
&& !(currentLineBeginsWithBrace && peekNextChar() == '/')
|
|
&& isBraceType((*braceTypeStack)[stackEnd], COMMAND_TYPE))
|
|
{
|
|
size_t i;
|
|
for (i = 1; i < braceTypeStack->size(); i++)
|
|
if (isBraceType((*braceTypeStack)[i], CLASS_TYPE)
|
|
|| isBraceType((*braceTypeStack)[i], STRUCT_TYPE))
|
|
return false;
|
|
}
|
|
|
|
// check braces
|
|
if (isBraceType((*braceTypeStack)[stackEnd], EXTERN_TYPE))
|
|
{
|
|
if (currentLineBeginsWithBrace
|
|
|| braceFormatMode == RUN_IN_MODE)
|
|
breakBrace = true;
|
|
}
|
|
else if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (currentLineBeginsWithBrace
|
|
&& (int) currentLineFirstBraceNum == charNum)
|
|
breakBrace = true;
|
|
}
|
|
else if (braceFormatMode == BREAK_MODE || braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
breakBrace = true;
|
|
}
|
|
else if (braceFormatMode == LINUX_MODE)
|
|
{
|
|
// break a namespace if NOT stroustrup or mozilla
|
|
if (isBraceType((*braceTypeStack)[stackEnd], NAMESPACE_TYPE))
|
|
{
|
|
if (formattingStyle != STYLE_STROUSTRUP
|
|
&& formattingStyle != STYLE_MOZILLA)
|
|
breakBrace = true;
|
|
}
|
|
// break a class or interface if NOT stroustrup
|
|
else if (isBraceType((*braceTypeStack)[stackEnd], CLASS_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd], INTERFACE_TYPE))
|
|
{
|
|
if (formattingStyle != STYLE_STROUSTRUP)
|
|
breakBrace = true;
|
|
}
|
|
// break a struct if mozilla - an enum is processed as an array brace
|
|
else if (isBraceType((*braceTypeStack)[stackEnd], STRUCT_TYPE))
|
|
{
|
|
if (formattingStyle == STYLE_MOZILLA)
|
|
breakBrace = true;
|
|
}
|
|
// break the first brace if a function
|
|
else if (isBraceType((*braceTypeStack)[stackEnd], COMMAND_TYPE))
|
|
{
|
|
if (stackEnd == 1)
|
|
{
|
|
breakBrace = true;
|
|
}
|
|
else if (stackEnd > 1)
|
|
{
|
|
// break the first brace after these if a function
|
|
if (isBraceType((*braceTypeStack)[stackEnd - 1], NAMESPACE_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd - 1], CLASS_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd - 1], ARRAY_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd - 1], STRUCT_TYPE)
|
|
|| isBraceType((*braceTypeStack)[stackEnd - 1], EXTERN_TYPE))
|
|
{
|
|
breakBrace = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return breakBrace;
|
|
}
|
|
|
|
/**
|
|
* format comment body
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatCommentBody()
|
|
{
|
|
assert(isInComment);
|
|
|
|
// append the comment
|
|
while (charNum < (int) currentLine.length())
|
|
{
|
|
currentChar = currentLine[charNum];
|
|
if (isSequenceReached("*/"))
|
|
{
|
|
formatCommentCloser();
|
|
break;
|
|
}
|
|
if (currentChar == '\t' && shouldConvertTabs)
|
|
convertTabToSpaces();
|
|
appendCurrentChar();
|
|
++charNum;
|
|
}
|
|
if (shouldStripCommentPrefix)
|
|
stripCommentPrefix();
|
|
}
|
|
|
|
/**
|
|
* format a comment opener
|
|
* the comment opener will be appended to the current formattedLine or a new formattedLine as necessary
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatCommentOpener()
|
|
{
|
|
assert(isSequenceReached("/*"));
|
|
|
|
isInComment = isInCommentStartLine = true;
|
|
isImmediatelyPostLineComment = false;
|
|
if (previousNonWSChar == '}')
|
|
resetEndOfStatement();
|
|
|
|
// Check for a following header.
|
|
// For speed do not check multiple comment lines more than once.
|
|
// For speed do not check shouldBreakBlocks if previous line is empty, a comment, or a '{'.
|
|
const string* followingHeader = nullptr;
|
|
if ((doesLineStartComment
|
|
&& !isImmediatelyPostCommentOnly
|
|
&& isBraceType(braceTypeStack->back(), COMMAND_TYPE))
|
|
&& (shouldBreakElseIfs
|
|
|| isInSwitchStatement()
|
|
|| (shouldBreakBlocks
|
|
&& !isImmediatelyPostEmptyLine
|
|
&& previousCommandChar != '{')))
|
|
followingHeader = checkForHeaderFollowingComment(currentLine.substr(charNum));
|
|
|
|
if (spacePadNum != 0 && !isInLineBreak)
|
|
adjustComments();
|
|
formattedLineCommentNum = formattedLine.length();
|
|
|
|
// must be done BEFORE appendSequence
|
|
if (previousCommandChar == '{'
|
|
&& !isImmediatelyPostComment
|
|
&& !isImmediatelyPostLineComment)
|
|
{
|
|
if (isBraceType(braceTypeStack->back(), NAMESPACE_TYPE))
|
|
{
|
|
// namespace run-in is always broken.
|
|
isInLineBreak = true;
|
|
}
|
|
else if (braceFormatMode == NONE_MODE)
|
|
{
|
|
// should a run-in statement be attached?
|
|
if (currentLineBeginsWithBrace)
|
|
formatRunIn();
|
|
}
|
|
else if (braceFormatMode == ATTACH_MODE)
|
|
{
|
|
// if the brace was not attached?
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{'
|
|
&& !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE))
|
|
isInLineBreak = true;
|
|
}
|
|
else if (braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
// should a run-in statement be attached?
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{')
|
|
formatRunIn();
|
|
}
|
|
}
|
|
else if (!doesLineStartComment)
|
|
noTrimCommentContinuation = true;
|
|
|
|
// ASBeautifier needs to know the following statements
|
|
if (shouldBreakElseIfs && followingHeader == &AS_ELSE)
|
|
elseHeaderFollowsComments = true;
|
|
if (followingHeader == &AS_CASE || followingHeader == &AS_DEFAULT)
|
|
caseHeaderFollowsComments = true;
|
|
|
|
// appendSequence will write the previous line
|
|
appendSequence(AS_OPEN_COMMENT);
|
|
goForward(1);
|
|
|
|
// must be done AFTER appendSequence
|
|
|
|
// Break before the comment if a header follows the line comment.
|
|
// But not break if previous line is empty, a comment, or a '{'.
|
|
if (shouldBreakBlocks
|
|
&& followingHeader != nullptr
|
|
&& !isImmediatelyPostEmptyLine
|
|
&& previousCommandChar != '{')
|
|
{
|
|
if (isClosingHeader(followingHeader))
|
|
{
|
|
if (!shouldBreakClosingHeaderBlocks)
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
}
|
|
// if an opening header, break before the comment
|
|
else
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
|
|
if (previousCommandChar == '}')
|
|
currentHeader = nullptr;
|
|
}
|
|
|
|
/**
|
|
* format a comment closer
|
|
* the comment closer will be appended to the current formattedLine
|
|
*/
|
|
void ASFormatter::formatCommentCloser()
|
|
{
|
|
assert(isSequenceReached("*/"));
|
|
isInComment = false;
|
|
noTrimCommentContinuation = false;
|
|
isImmediatelyPostComment = true;
|
|
appendSequence(AS_CLOSE_COMMENT);
|
|
goForward(1);
|
|
if (doesLineStartComment
|
|
&& (currentLine.find_first_not_of(" \t", charNum + 1) == string::npos))
|
|
lineEndsInCommentOnly = true;
|
|
if (peekNextChar() == '}'
|
|
&& previousCommandChar != ';'
|
|
&& !isBraceType(braceTypeStack->back(), ARRAY_TYPE)
|
|
&& !isInPreprocessor
|
|
&& isOkToBreakBlock(braceTypeStack->back()))
|
|
{
|
|
isInLineBreak = true;
|
|
shouldBreakLineAtNextChar = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format a line comment body
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatLineCommentBody()
|
|
{
|
|
assert(isInLineComment);
|
|
|
|
// append the comment
|
|
while (charNum < (int) currentLine.length())
|
|
// && !isLineReady // commented out in release 2.04, unnecessary
|
|
{
|
|
currentChar = currentLine[charNum];
|
|
if (currentChar == '\t' && shouldConvertTabs)
|
|
convertTabToSpaces();
|
|
appendCurrentChar();
|
|
++charNum;
|
|
}
|
|
|
|
// explicitly break a line when a line comment's end is found.
|
|
if (charNum == (int) currentLine.length())
|
|
{
|
|
isInLineBreak = true;
|
|
isInLineComment = false;
|
|
isImmediatelyPostLineComment = true;
|
|
currentChar = 0; //make sure it is a neutral char.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format a line comment opener
|
|
* the line comment opener will be appended to the current formattedLine or a new formattedLine as necessary
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatLineCommentOpener()
|
|
{
|
|
assert(isSequenceReached("//"));
|
|
|
|
if ((int) currentLine.length() > charNum + 2
|
|
&& currentLine[charNum + 2] == '\xf2') // check for windows line marker
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
|
|
isInLineComment = true;
|
|
isCharImmediatelyPostComment = false;
|
|
if (previousNonWSChar == '}')
|
|
resetEndOfStatement();
|
|
|
|
// Check for a following header.
|
|
// For speed do not check multiple comment lines more than once.
|
|
// For speed do not check shouldBreakBlocks if previous line is empty, a comment, or a '{'.
|
|
const string* followingHeader = nullptr;
|
|
if ((lineIsLineCommentOnly
|
|
&& !isImmediatelyPostCommentOnly
|
|
&& isBraceType(braceTypeStack->back(), COMMAND_TYPE))
|
|
&& (shouldBreakElseIfs
|
|
|| isInSwitchStatement()
|
|
|| (shouldBreakBlocks
|
|
&& !isImmediatelyPostEmptyLine
|
|
&& previousCommandChar != '{')))
|
|
followingHeader = checkForHeaderFollowingComment(currentLine.substr(charNum));
|
|
|
|
// do not indent if in column 1 or 2
|
|
// or in a namespace before the opening brace
|
|
if ((!shouldIndentCol1Comments && !lineCommentNoIndent)
|
|
|| foundNamespaceHeader)
|
|
{
|
|
if (charNum == 0)
|
|
lineCommentNoIndent = true;
|
|
else if (charNum == 1 && currentLine[0] == ' ')
|
|
lineCommentNoIndent = true;
|
|
}
|
|
// move comment if spaces were added or deleted
|
|
if (!lineCommentNoIndent && spacePadNum != 0 && !isInLineBreak)
|
|
adjustComments();
|
|
formattedLineCommentNum = formattedLine.length();
|
|
|
|
// must be done BEFORE appendSequence
|
|
// check for run-in statement
|
|
if (previousCommandChar == '{'
|
|
&& !isImmediatelyPostComment
|
|
&& !isImmediatelyPostLineComment)
|
|
{
|
|
if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (currentLineBeginsWithBrace)
|
|
formatRunIn();
|
|
}
|
|
else if (braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
if (!lineCommentNoIndent)
|
|
formatRunIn();
|
|
else
|
|
isInLineBreak = true;
|
|
}
|
|
else if (braceFormatMode == BREAK_MODE)
|
|
{
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{')
|
|
isInLineBreak = true;
|
|
}
|
|
else
|
|
{
|
|
if (currentLineBeginsWithBrace)
|
|
isInLineBreak = true;
|
|
}
|
|
}
|
|
|
|
// ASBeautifier needs to know the following statements
|
|
if (shouldBreakElseIfs && followingHeader == &AS_ELSE)
|
|
elseHeaderFollowsComments = true;
|
|
if (followingHeader == &AS_CASE || followingHeader == &AS_DEFAULT)
|
|
caseHeaderFollowsComments = true;
|
|
|
|
// appendSequence will write the previous line
|
|
appendSequence(AS_OPEN_LINE_COMMENT);
|
|
goForward(1);
|
|
|
|
// must be done AFTER appendSequence
|
|
|
|
// Break before the comment if a header follows the line comment.
|
|
// But do not break if previous line is empty, a comment, or a '{'.
|
|
if (shouldBreakBlocks
|
|
&& followingHeader != nullptr
|
|
&& !isImmediatelyPostEmptyLine
|
|
&& previousCommandChar != '{')
|
|
{
|
|
if (isClosingHeader(followingHeader))
|
|
{
|
|
if (!shouldBreakClosingHeaderBlocks)
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
}
|
|
// if an opening header, break before the comment
|
|
else
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
|
|
if (previousCommandChar == '}')
|
|
currentHeader = nullptr;
|
|
|
|
// if tabbed input don't convert the immediately following tabs to spaces
|
|
if (getIndentString() == "\t" && lineCommentNoIndent)
|
|
{
|
|
while (charNum + 1 < (int) currentLine.length()
|
|
&& currentLine[charNum + 1] == '\t')
|
|
{
|
|
currentChar = currentLine[++charNum];
|
|
appendCurrentChar();
|
|
}
|
|
}
|
|
|
|
// explicitly break a line when a line comment's end is found.
|
|
if (charNum + 1 == (int) currentLine.length())
|
|
{
|
|
isInLineBreak = true;
|
|
isInLineComment = false;
|
|
isImmediatelyPostLineComment = true;
|
|
currentChar = 0; //make sure it is a neutral char.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* format quote body
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatQuoteBody()
|
|
{
|
|
assert(isInQuote);
|
|
|
|
if (isSpecialChar)
|
|
{
|
|
isSpecialChar = false;
|
|
}
|
|
else if (currentChar == '\\' && !isInVerbatimQuote)
|
|
{
|
|
if (peekNextChar() == ' ') // is this '\' at end of line
|
|
haveLineContinuationChar = true;
|
|
else
|
|
isSpecialChar = true;
|
|
}
|
|
else if (isInVerbatimQuote && currentChar == '"')
|
|
{
|
|
if (isCStyle())
|
|
{
|
|
string delim = ')' + verbatimDelimiter;
|
|
int delimStart = charNum - delim.length();
|
|
if (delimStart > 0 && currentLine.substr(delimStart, delim.length()) == delim)
|
|
{
|
|
isInQuote = false;
|
|
isInVerbatimQuote = false;
|
|
}
|
|
}
|
|
else if (isSharpStyle())
|
|
{
|
|
if ((int) currentLine.length() > charNum + 1
|
|
&& currentLine[charNum + 1] == '"') // check consecutive quotes
|
|
{
|
|
appendSequence("\"\"");
|
|
goForward(1);
|
|
return;
|
|
}
|
|
isInQuote = false;
|
|
isInVerbatimQuote = false;
|
|
}
|
|
}
|
|
else if (quoteChar == currentChar)
|
|
{
|
|
isInQuote = false;
|
|
}
|
|
|
|
appendCurrentChar();
|
|
|
|
// append the text to the ending quoteChar or an escape sequence
|
|
// tabs in quotes are NOT changed by convert-tabs
|
|
if (isInQuote && currentChar != '\\')
|
|
{
|
|
while (charNum + 1 < (int) currentLine.length()
|
|
&& currentLine[charNum + 1] != quoteChar
|
|
&& currentLine[charNum + 1] != '\\')
|
|
{
|
|
currentChar = currentLine[++charNum];
|
|
appendCurrentChar();
|
|
}
|
|
}
|
|
if (charNum + 1 >= (int) currentLine.length()
|
|
&& currentChar != '\\'
|
|
&& !isInVerbatimQuote)
|
|
isInQuote = false; // missing closing quote
|
|
}
|
|
|
|
/**
|
|
* format a quote opener
|
|
* the quote opener will be appended to the current formattedLine or a new formattedLine as necessary
|
|
* the calling function should have a continue statement after calling this method
|
|
*/
|
|
void ASFormatter::formatQuoteOpener()
|
|
{
|
|
assert(currentChar == '"'
|
|
|| (currentChar == '\'' && !isDigitSeparator(currentLine, charNum)));
|
|
|
|
isInQuote = true;
|
|
quoteChar = currentChar;
|
|
if (isCStyle() && previousChar == 'R')
|
|
{
|
|
int parenPos = currentLine.find('(', charNum);
|
|
if (parenPos != -1)
|
|
{
|
|
isInVerbatimQuote = true;
|
|
verbatimDelimiter = currentLine.substr(charNum + 1, parenPos - charNum - 1);
|
|
}
|
|
}
|
|
else if (isSharpStyle() && previousChar == '@')
|
|
isInVerbatimQuote = true;
|
|
|
|
// a quote following a brace is an array
|
|
if (previousCommandChar == '{'
|
|
&& !isImmediatelyPostComment
|
|
&& !isImmediatelyPostLineComment
|
|
&& isNonInStatementArray
|
|
&& !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)
|
|
&& !isWhiteSpace(peekNextChar()))
|
|
{
|
|
if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (currentLineBeginsWithBrace)
|
|
formatRunIn();
|
|
}
|
|
else if (braceFormatMode == RUN_IN_MODE)
|
|
{
|
|
formatRunIn();
|
|
}
|
|
else if (braceFormatMode == BREAK_MODE)
|
|
{
|
|
if (formattedLine.length() > 0 && formattedLine[0] == '{')
|
|
isInLineBreak = true;
|
|
}
|
|
else
|
|
{
|
|
if (currentLineBeginsWithBrace)
|
|
isInLineBreak = true;
|
|
}
|
|
}
|
|
previousCommandChar = ' ';
|
|
appendCurrentChar();
|
|
}
|
|
|
|
/**
|
|
* get the next line comment adjustment that results from breaking a closing brace.
|
|
* the brace must be on the same line as the closing header.
|
|
* i.e "} else" changed to "} <NL> else".
|
|
*/
|
|
int ASFormatter::getNextLineCommentAdjustment()
|
|
{
|
|
assert(foundClosingHeader && previousNonWSChar == '}');
|
|
if (charNum < 1) // "else" is in column 1
|
|
return 0;
|
|
size_t lastBrace = currentLine.rfind('}', charNum - 1);
|
|
if (lastBrace != string::npos)
|
|
return (lastBrace - charNum); // return a negative number
|
|
return 0;
|
|
}
|
|
|
|
// for console build only
|
|
LineEndFormat ASFormatter::getLineEndFormat() const
|
|
{
|
|
return lineEnd;
|
|
}
|
|
|
|
/**
|
|
* get the current line comment adjustment that results from attaching
|
|
* a closing header to a closing brace.
|
|
* the brace must be on the line previous to the closing header.
|
|
* the adjustment is 2 chars, one for the brace and one for the space.
|
|
* i.e "} <NL> else" changed to "} else".
|
|
*/
|
|
int ASFormatter::getCurrentLineCommentAdjustment()
|
|
{
|
|
assert(foundClosingHeader && previousNonWSChar == '}');
|
|
if (charNum < 1)
|
|
return 2;
|
|
size_t lastBrace = currentLine.rfind('}', charNum - 1);
|
|
if (lastBrace == string::npos)
|
|
return 2;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* get the previous word on a line
|
|
* the argument 'currPos' must point to the current position.
|
|
*
|
|
* @return is the previous word or an empty string if none found.
|
|
*/
|
|
string ASFormatter::getPreviousWord(const string& line, int currPos) const
|
|
{
|
|
// get the last legal word (may be a number)
|
|
if (currPos == 0)
|
|
return string();
|
|
|
|
size_t end = line.find_last_not_of(" \t", currPos - 1);
|
|
if (end == string::npos || !isLegalNameChar(line[end]))
|
|
return string();
|
|
|
|
int start; // start of the previous word
|
|
for (start = end; start > -1; start--)
|
|
{
|
|
if (!isLegalNameChar(line[start]) || line[start] == '.')
|
|
break;
|
|
}
|
|
start++;
|
|
|
|
return (line.substr(start, end - start + 1));
|
|
}
|
|
|
|
/**
|
|
* check if a line break is needed when a closing brace
|
|
* is followed by a closing header.
|
|
* the break depends on the braceFormatMode and other factors.
|
|
*/
|
|
void ASFormatter::isLineBreakBeforeClosingHeader()
|
|
{
|
|
assert(foundClosingHeader && previousNonWSChar == '}');
|
|
|
|
if (currentHeader == &AS_WHILE && shouldAttachClosingWhile)
|
|
{
|
|
appendClosingHeader();
|
|
return;
|
|
}
|
|
|
|
if (braceFormatMode == BREAK_MODE
|
|
|| braceFormatMode == RUN_IN_MODE
|
|
|| attachClosingBraceMode)
|
|
{
|
|
isInLineBreak = true;
|
|
}
|
|
else if (braceFormatMode == NONE_MODE)
|
|
{
|
|
if (shouldBreakClosingHeaderBraces
|
|
|| getBraceIndent() || getBlockIndent())
|
|
{
|
|
isInLineBreak = true;
|
|
}
|
|
else
|
|
{
|
|
appendSpacePad();
|
|
// is closing brace broken?
|
|
size_t i = currentLine.find_first_not_of(" \t");
|
|
if (i != string::npos && currentLine[i] == '}')
|
|
isInLineBreak = false;
|
|
|
|
if (shouldBreakBlocks)
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
}
|
|
}
|
|
// braceFormatMode == ATTACH_MODE, LINUX_MODE
|
|
else
|
|
{
|
|
if (shouldBreakClosingHeaderBraces
|
|
|| getBraceIndent() || getBlockIndent())
|
|
{
|
|
isInLineBreak = true;
|
|
}
|
|
else
|
|
{
|
|
appendClosingHeader();
|
|
if (shouldBreakBlocks)
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a closing header to the previous closing brace, if possible
|
|
*/
|
|
void ASFormatter::appendClosingHeader()
|
|
{
|
|
// if a blank line does not precede this
|
|
// or last line is not a one line block, attach header
|
|
bool previousLineIsEmpty = isEmptyLine(formattedLine);
|
|
int previousLineIsOneLineBlock = 0;
|
|
size_t firstBrace = findNextChar(formattedLine, '{');
|
|
if (firstBrace != string::npos)
|
|
previousLineIsOneLineBlock = isOneLineBlockReached(formattedLine, firstBrace);
|
|
if (!previousLineIsEmpty
|
|
&& previousLineIsOneLineBlock == 0)
|
|
{
|
|
isInLineBreak = false;
|
|
appendSpacePad();
|
|
spacePadNum = 0; // don't count as comment padding
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add braces to a single line statement following a header.
|
|
* braces are not added if the proper conditions are not met.
|
|
* braces are added to the currentLine.
|
|
*/
|
|
bool ASFormatter::addBracesToStatement()
|
|
{
|
|
assert(isImmediatelyPostHeader);
|
|
|
|
if (currentHeader != &AS_IF
|
|
&& currentHeader != &AS_ELSE
|
|
&& currentHeader != &AS_FOR
|
|
&& currentHeader != &AS_WHILE
|
|
&& currentHeader != &AS_DO
|
|
&& currentHeader != &AS_FOREACH
|
|
&& currentHeader != &AS_QFOREACH
|
|
&& currentHeader != &AS_QFOREVER
|
|
&& currentHeader != &AS_FOREVER)
|
|
return false;
|
|
|
|
if (currentHeader == &AS_WHILE && foundClosingHeader) // do-while
|
|
return false;
|
|
|
|
// do not brace an empty statement
|
|
if (currentChar == ';')
|
|
return false;
|
|
|
|
// do not add if a header follows
|
|
if (isCharPotentialHeader(currentLine, charNum))
|
|
if (findHeader(headers) != nullptr)
|
|
return false;
|
|
|
|
// find the next semi-colon
|
|
size_t nextSemiColon = charNum;
|
|
if (currentChar != ';')
|
|
nextSemiColon = findNextChar(currentLine, ';', charNum + 1);
|
|
if (nextSemiColon == string::npos)
|
|
return false;
|
|
|
|
// add closing brace before changing the line length
|
|
if (nextSemiColon == currentLine.length() - 1)
|
|
currentLine.append(" }");
|
|
else
|
|
currentLine.insert(nextSemiColon + 1, " }");
|
|
// add opening brace
|
|
currentLine.insert(charNum, "{ ");
|
|
assert(computeChecksumIn("{}"));
|
|
currentChar = '{';
|
|
if ((int) currentLine.find_first_not_of(" \t") == charNum)
|
|
currentLineBeginsWithBrace = true;
|
|
// remove extra spaces
|
|
if (!shouldAddOneLineBraces)
|
|
{
|
|
size_t lastText = formattedLine.find_last_not_of(" \t");
|
|
if ((formattedLine.length() - 1) - lastText > 1)
|
|
formattedLine.erase(lastText + 1);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove braces from a single line statement following a header.
|
|
* braces are not removed if the proper conditions are not met.
|
|
* The first brace is replaced by a space.
|
|
*/
|
|
bool ASFormatter::removeBracesFromStatement()
|
|
{
|
|
assert(isImmediatelyPostHeader);
|
|
assert(currentChar == '{');
|
|
|
|
if (currentHeader != &AS_IF
|
|
&& currentHeader != &AS_ELSE
|
|
&& currentHeader != &AS_FOR
|
|
&& currentHeader != &AS_WHILE
|
|
&& currentHeader != &AS_FOREACH)
|
|
return false;
|
|
|
|
if (currentHeader == &AS_WHILE && foundClosingHeader) // do-while
|
|
return false;
|
|
|
|
bool isFirstLine = true;
|
|
string nextLine_;
|
|
// leave nextLine_ empty if end of line comment follows
|
|
if (!isBeforeAnyLineEndComment(charNum) || currentLineBeginsWithBrace)
|
|
nextLine_ = currentLine.substr(charNum + 1);
|
|
size_t nextChar = 0;
|
|
|
|
// find the first non-blank text
|
|
ASPeekStream stream(sourceIterator);
|
|
while (stream.hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
{
|
|
nextLine_ = stream.peekNextLine();
|
|
nextChar = 0;
|
|
}
|
|
|
|
nextChar = nextLine_.find_first_not_of(" \t", nextChar);
|
|
if (nextChar != string::npos)
|
|
break;
|
|
}
|
|
|
|
// don't remove if comments or a header follow the brace
|
|
if ((nextLine_.compare(nextChar, 2, "/*") == 0)
|
|
|| (nextLine_.compare(nextChar, 2, "//") == 0)
|
|
|| (isCharPotentialHeader(nextLine_, nextChar)
|
|
&& ASBase::findHeader(nextLine_, nextChar, headers) != nullptr))
|
|
return false;
|
|
|
|
// find the next semi-colon
|
|
size_t nextSemiColon = nextChar;
|
|
if (nextLine_[nextChar] != ';')
|
|
nextSemiColon = findNextChar(nextLine_, ';', nextChar + 1);
|
|
if (nextSemiColon == string::npos)
|
|
return false;
|
|
|
|
// find the closing brace
|
|
isFirstLine = true;
|
|
nextChar = nextSemiColon + 1;
|
|
while (stream.hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
{
|
|
nextLine_ = stream.peekNextLine();
|
|
nextChar = 0;
|
|
}
|
|
nextChar = nextLine_.find_first_not_of(" \t", nextChar);
|
|
if (nextChar != string::npos)
|
|
break;
|
|
}
|
|
if (nextLine_.length() == 0 || nextLine_[nextChar] != '}')
|
|
return false;
|
|
|
|
// remove opening brace
|
|
currentLine[charNum] = currentChar = ' ';
|
|
assert(adjustChecksumIn(-'{'));
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Find the next character that is not in quotes or a comment.
|
|
*
|
|
* @param line the line to be searched.
|
|
* @param searchChar the char to find.
|
|
* @param searchStart the start position on the line (default is 0).
|
|
* @return the position on the line or string::npos if not found.
|
|
*/
|
|
size_t ASFormatter::findNextChar(const string& line, char searchChar, int searchStart /*0*/) const
|
|
{
|
|
// find the next searchChar
|
|
size_t i;
|
|
for (i = searchStart; i < line.length(); i++)
|
|
{
|
|
if (line.compare(i, 2, "//") == 0)
|
|
return string::npos;
|
|
if (line.compare(i, 2, "/*") == 0)
|
|
{
|
|
size_t endComment = line.find("*/", i + 2);
|
|
if (endComment == string::npos)
|
|
return string::npos;
|
|
i = endComment + 2;
|
|
if (i >= line.length())
|
|
return string::npos;
|
|
}
|
|
if (line[i] == '"'
|
|
|| (line[i] == '\'' && !isDigitSeparator(line, i)))
|
|
{
|
|
char quote = line[i];
|
|
while (i < line.length())
|
|
{
|
|
size_t endQuote = line.find(quote, i + 1);
|
|
if (endQuote == string::npos)
|
|
return string::npos;
|
|
i = endQuote;
|
|
if (line[endQuote - 1] != '\\') // check for '\"'
|
|
break;
|
|
if (line[endQuote - 2] == '\\') // check for '\\'
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (line[i] == searchChar)
|
|
break;
|
|
|
|
// for now don't process C# 'delegate' braces
|
|
// do this last in case the search char is a '{'
|
|
if (line[i] == '{')
|
|
return string::npos;
|
|
}
|
|
if (i >= line.length()) // didn't find searchChar
|
|
return string::npos;
|
|
|
|
return i;
|
|
}
|
|
|
|
/**
|
|
* Look ahead in the file to see if a struct has access modifiers.
|
|
*
|
|
* @param firstLine a reference to the line to indent.
|
|
* @param index the current line index.
|
|
* @return true if the struct has access modifiers.
|
|
*/
|
|
bool ASFormatter::isStructAccessModified(const string& firstLine, size_t index) const
|
|
{
|
|
assert(firstLine[index] == '{');
|
|
assert(isCStyle());
|
|
|
|
bool isFirstLine = true;
|
|
size_t braceCount = 1;
|
|
string nextLine_ = firstLine.substr(index + 1);
|
|
ASPeekStream stream(sourceIterator);
|
|
|
|
// find the first non-blank text, bypassing all comments and quotes.
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
char quoteChar_ = ' ';
|
|
while (stream.hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
nextLine_ = stream.peekNextLine();
|
|
// parse the line
|
|
for (size_t i = 0; i < nextLine_.length(); i++)
|
|
{
|
|
if (isWhiteSpace(nextLine_[i]))
|
|
continue;
|
|
if (nextLine_.compare(i, 2, "/*") == 0)
|
|
isInComment_ = true;
|
|
if (isInComment_)
|
|
{
|
|
if (nextLine_.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
++i;
|
|
}
|
|
continue;
|
|
}
|
|
if (nextLine_[i] == '\\')
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
if (isInQuote_)
|
|
{
|
|
if (nextLine_[i] == quoteChar_)
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
|
|
if (nextLine_[i] == '"'
|
|
|| (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i)))
|
|
{
|
|
isInQuote_ = true;
|
|
quoteChar_ = nextLine_[i];
|
|
continue;
|
|
}
|
|
if (nextLine_.compare(i, 2, "//") == 0)
|
|
{
|
|
i = nextLine_.length();
|
|
continue;
|
|
}
|
|
// handle braces
|
|
if (nextLine_[i] == '{')
|
|
++braceCount;
|
|
if (nextLine_[i] == '}')
|
|
--braceCount;
|
|
if (braceCount == 0)
|
|
return false;
|
|
// check for access modifiers
|
|
if (isCharPotentialHeader(nextLine_, i))
|
|
{
|
|
if (findKeyword(nextLine_, i, AS_PUBLIC)
|
|
|| findKeyword(nextLine_, i, AS_PRIVATE)
|
|
|| findKeyword(nextLine_, i, AS_PROTECTED))
|
|
return true;
|
|
string name = getCurrentWord(nextLine_, i);
|
|
i += name.length() - 1;
|
|
}
|
|
} // end of for loop
|
|
} // end of while loop
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Look ahead in the file to see if a preprocessor block is indentable.
|
|
*
|
|
* @param firstLine a reference to the line to indent.
|
|
* @param index the current line index.
|
|
* @return true if the block is indentable.
|
|
*/
|
|
bool ASFormatter::isIndentablePreprocessorBlock(const string& firstLine, size_t index)
|
|
{
|
|
assert(firstLine[index] == '#');
|
|
|
|
bool isFirstLine = true;
|
|
bool isInIndentableBlock = false;
|
|
bool blockContainsBraces = false;
|
|
bool blockContainsDefineContinuation = false;
|
|
bool isInClassConstructor = false;
|
|
bool isPotentialHeaderGuard = false; // ifndef is first preproc statement
|
|
bool isPotentialHeaderGuard2 = false; // define is within the first proproc
|
|
int numBlockIndents = 0;
|
|
int lineParenCount = 0;
|
|
string nextLine_ = firstLine.substr(index);
|
|
auto stream = make_shared<ASPeekStream>(sourceIterator);
|
|
|
|
// find end of the block, bypassing all comments and quotes.
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
char quoteChar_ = ' ';
|
|
while (stream->hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
nextLine_ = stream->peekNextLine();
|
|
// parse the line
|
|
for (size_t i = 0; i < nextLine_.length(); i++)
|
|
{
|
|
if (isWhiteSpace(nextLine_[i]))
|
|
continue;
|
|
if (nextLine_.compare(i, 2, "/*") == 0)
|
|
isInComment_ = true;
|
|
if (isInComment_)
|
|
{
|
|
if (nextLine_.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
++i;
|
|
}
|
|
continue;
|
|
}
|
|
if (nextLine_[i] == '\\')
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
if (isInQuote_)
|
|
{
|
|
if (nextLine_[i] == quoteChar_)
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
|
|
if (nextLine_[i] == '"'
|
|
|| (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i)))
|
|
{
|
|
isInQuote_ = true;
|
|
quoteChar_ = nextLine_[i];
|
|
continue;
|
|
}
|
|
if (nextLine_.compare(i, 2, "//") == 0)
|
|
{
|
|
i = nextLine_.length();
|
|
continue;
|
|
}
|
|
// handle preprocessor statement
|
|
if (nextLine_[i] == '#')
|
|
{
|
|
string preproc = ASBeautifier::extractPreprocessorStatement(nextLine_);
|
|
if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef
|
|
{
|
|
numBlockIndents += 1;
|
|
isInIndentableBlock = true;
|
|
// flag first preprocessor conditional for header include guard check
|
|
if (!processedFirstConditional)
|
|
{
|
|
processedFirstConditional = true;
|
|
isFirstPreprocConditional = true;
|
|
if (isNDefPreprocStatement(nextLine_, preproc))
|
|
isPotentialHeaderGuard = true;
|
|
}
|
|
}
|
|
else if (preproc == "endif")
|
|
{
|
|
if (numBlockIndents > 0)
|
|
numBlockIndents -= 1;
|
|
// must exit BOTH loops
|
|
if (numBlockIndents == 0)
|
|
goto EndOfWhileLoop;
|
|
}
|
|
else if (preproc == "define")
|
|
{
|
|
if (nextLine_[nextLine_.length() - 1] == '\\')
|
|
blockContainsDefineContinuation = true;
|
|
// check for potential header include guards
|
|
else if (isPotentialHeaderGuard && numBlockIndents == 1)
|
|
isPotentialHeaderGuard2 = true;
|
|
}
|
|
i = nextLine_.length();
|
|
continue;
|
|
}
|
|
// handle exceptions
|
|
if (nextLine_[i] == '{' || nextLine_[i] == '}')
|
|
blockContainsBraces = true;
|
|
else if (nextLine_[i] == '(')
|
|
++lineParenCount;
|
|
else if (nextLine_[i] == ')')
|
|
--lineParenCount;
|
|
else if (nextLine_[i] == ':')
|
|
{
|
|
// check for '::'
|
|
if (nextLine_.length() > i && nextLine_[i + 1] == ':')
|
|
++i;
|
|
else
|
|
isInClassConstructor = true;
|
|
}
|
|
// bypass unnecessary parsing - must exit BOTH loops
|
|
if (blockContainsBraces || isInClassConstructor || blockContainsDefineContinuation)
|
|
goto EndOfWhileLoop;
|
|
} // end of for loop, end of line
|
|
if (lineParenCount != 0)
|
|
break;
|
|
} // end of while loop
|
|
EndOfWhileLoop:
|
|
preprocBlockEnd = sourceIterator->tellg();
|
|
if (preprocBlockEnd < 0)
|
|
preprocBlockEnd = sourceIterator->getStreamLength();
|
|
if (blockContainsBraces
|
|
|| isInClassConstructor
|
|
|| blockContainsDefineContinuation
|
|
|| lineParenCount != 0
|
|
|| numBlockIndents != 0)
|
|
isInIndentableBlock = false;
|
|
// find next executable instruction
|
|
// this WILL RESET the get pointer
|
|
string nextText = peekNextText("", false, stream);
|
|
// bypass header include guards
|
|
if (isFirstPreprocConditional)
|
|
{
|
|
isFirstPreprocConditional = false;
|
|
if (nextText.empty() && isPotentialHeaderGuard2)
|
|
{
|
|
isInIndentableBlock = false;
|
|
preprocBlockEnd = 0;
|
|
}
|
|
}
|
|
// this allows preprocessor blocks within this block to be indented
|
|
if (!isInIndentableBlock)
|
|
preprocBlockEnd = 0;
|
|
// peekReset() is done by previous peekNextText()
|
|
return isInIndentableBlock;
|
|
}
|
|
|
|
bool ASFormatter::isNDefPreprocStatement(const string& nextLine_, const string& preproc) const
|
|
{
|
|
if (preproc == "ifndef")
|
|
return true;
|
|
// check for '!defined'
|
|
if (preproc == "if")
|
|
{
|
|
size_t i = nextLine_.find('!');
|
|
if (i == string::npos)
|
|
return false;
|
|
i = nextLine_.find_first_not_of(" \t", ++i);
|
|
if (i != string::npos && nextLine_.compare(i, 7, "defined") == 0)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check to see if this is an EXEC SQL statement.
|
|
*
|
|
* @param line a reference to the line to indent.
|
|
* @param index the current line index.
|
|
* @return true if the statement is EXEC SQL.
|
|
*/
|
|
bool ASFormatter::isExecSQL(const string& line, size_t index) const
|
|
{
|
|
if (line[index] != 'e' && line[index] != 'E') // quick check to reject most
|
|
return false;
|
|
string word;
|
|
if (isCharPotentialHeader(line, index))
|
|
word = getCurrentWord(line, index);
|
|
for (size_t i = 0; i < word.length(); i++)
|
|
word[i] = (char) toupper(word[i]);
|
|
if (word != "EXEC")
|
|
return false;
|
|
size_t index2 = index + word.length();
|
|
index2 = line.find_first_not_of(" \t", index2);
|
|
if (index2 == string::npos)
|
|
return false;
|
|
word.erase();
|
|
if (isCharPotentialHeader(line, index2))
|
|
word = getCurrentWord(line, index2);
|
|
for (size_t i = 0; i < word.length(); i++)
|
|
word[i] = (char) toupper(word[i]);
|
|
if (word != "SQL")
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* The continuation lines must be adjusted so the leading spaces
|
|
* is equivalent to the text on the opening line.
|
|
*
|
|
* Updates currentLine and charNum.
|
|
*/
|
|
void ASFormatter::trimContinuationLine()
|
|
{
|
|
size_t len = currentLine.length();
|
|
size_t tabSize = getTabLength();
|
|
charNum = 0;
|
|
|
|
if (leadingSpaces > 0 && len > 0)
|
|
{
|
|
size_t i;
|
|
size_t continuationIncrementIn = 0;
|
|
for (i = 0; (i < len) && (i + continuationIncrementIn < leadingSpaces); i++)
|
|
{
|
|
if (!isWhiteSpace(currentLine[i])) // don't delete any text
|
|
{
|
|
if (i < continuationIncrementIn)
|
|
leadingSpaces = i + tabIncrementIn;
|
|
continuationIncrementIn = tabIncrementIn;
|
|
break;
|
|
}
|
|
if (currentLine[i] == '\t')
|
|
continuationIncrementIn += tabSize - 1 - ((continuationIncrementIn + i) % tabSize);
|
|
}
|
|
|
|
if ((int) continuationIncrementIn == tabIncrementIn)
|
|
charNum = i;
|
|
else
|
|
{
|
|
// build a new line with the equivalent leading chars
|
|
string newLine;
|
|
int leadingChars = 0;
|
|
if ((int) leadingSpaces > tabIncrementIn)
|
|
leadingChars = leadingSpaces - tabIncrementIn;
|
|
newLine.append(leadingChars, ' ');
|
|
newLine.append(currentLine, i, len - i);
|
|
currentLine = newLine;
|
|
charNum = leadingChars;
|
|
if (currentLine.length() == 0)
|
|
currentLine = string(" "); // a null is inserted if this is not done
|
|
}
|
|
if (i >= len)
|
|
charNum = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if a header is a closing header
|
|
*
|
|
* @return true if the header is a closing header.
|
|
*/
|
|
bool ASFormatter::isClosingHeader(const string* header) const
|
|
{
|
|
return (header == &AS_ELSE
|
|
|| header == &AS_CATCH
|
|
|| header == &AS_FINALLY);
|
|
}
|
|
|
|
/**
|
|
* Determine if a * following a closing paren is immediately.
|
|
* after a cast. If so it is a deference and not a multiply.
|
|
* e.g. "(int*) *ptr" is a deference.
|
|
*/
|
|
bool ASFormatter::isImmediatelyPostCast() const
|
|
{
|
|
assert(previousNonWSChar == ')' && currentChar == '*');
|
|
// find preceding closing paren on currentLine or readyFormattedLine
|
|
string line; // currentLine or readyFormattedLine
|
|
size_t paren = currentLine.rfind(')', charNum);
|
|
if (paren != string::npos)
|
|
line = currentLine;
|
|
// if not on currentLine it must be on the previous line
|
|
else
|
|
{
|
|
line = readyFormattedLine;
|
|
paren = line.rfind(')');
|
|
if (paren == string::npos)
|
|
return false;
|
|
}
|
|
if (paren == 0)
|
|
return false;
|
|
|
|
// find character preceding the closing paren
|
|
size_t lastChar = line.find_last_not_of(" \t", paren - 1);
|
|
if (lastChar == string::npos)
|
|
return false;
|
|
// check for pointer cast
|
|
if (line[lastChar] == '*')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine if a < is a template definition or instantiation.
|
|
* Sets the class variables isInTemplate and templateDepth.
|
|
*/
|
|
void ASFormatter::checkIfTemplateOpener()
|
|
{
|
|
assert(!isInTemplate && currentChar == '<');
|
|
|
|
// find first char after the '<' operators
|
|
size_t firstChar = currentLine.find_first_not_of("< \t", charNum);
|
|
if (firstChar == string::npos
|
|
|| currentLine[firstChar] == '=')
|
|
{
|
|
// this is not a template -> leave...
|
|
isInTemplate = false;
|
|
return;
|
|
}
|
|
|
|
bool isFirstLine = true;
|
|
int parenDepth_ = 0;
|
|
int maxTemplateDepth = 0;
|
|
templateDepth = 0;
|
|
string nextLine_ = currentLine.substr(charNum);
|
|
ASPeekStream stream(sourceIterator);
|
|
|
|
// find the angle braces, bypassing all comments and quotes.
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
char quoteChar_ = ' ';
|
|
while (stream.hasMoreLines() || isFirstLine)
|
|
{
|
|
if (isFirstLine)
|
|
isFirstLine = false;
|
|
else
|
|
nextLine_ = stream.peekNextLine();
|
|
// parse the line
|
|
for (size_t i = 0; i < nextLine_.length(); i++)
|
|
{
|
|
char currentChar_ = nextLine_[i];
|
|
if (isWhiteSpace(currentChar_))
|
|
continue;
|
|
if (nextLine_.compare(i, 2, "/*") == 0)
|
|
isInComment_ = true;
|
|
if (isInComment_)
|
|
{
|
|
if (nextLine_.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
++i;
|
|
}
|
|
continue;
|
|
}
|
|
if (currentChar_ == '\\')
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
if (isInQuote_)
|
|
{
|
|
if (currentChar_ == quoteChar_)
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
|
|
if (currentChar_ == '"'
|
|
|| (currentChar_ == '\'' && !isDigitSeparator(nextLine_, i)))
|
|
{
|
|
isInQuote_ = true;
|
|
quoteChar_ = currentChar_;
|
|
continue;
|
|
}
|
|
if (nextLine_.compare(i, 2, "//") == 0)
|
|
{
|
|
i = nextLine_.length();
|
|
continue;
|
|
}
|
|
|
|
// not in a comment or quote
|
|
if (currentChar_ == '<')
|
|
{
|
|
++templateDepth;
|
|
++maxTemplateDepth;
|
|
continue;
|
|
}
|
|
else if (currentChar_ == '>')
|
|
{
|
|
--templateDepth;
|
|
if (templateDepth == 0)
|
|
{
|
|
if (parenDepth_ == 0)
|
|
{
|
|
// this is a template!
|
|
isInTemplate = true;
|
|
templateDepth = maxTemplateDepth;
|
|
}
|
|
return;
|
|
}
|
|
continue;
|
|
}
|
|
else if (currentChar_ == '(' || currentChar_ == ')')
|
|
{
|
|
if (currentChar_ == '(')
|
|
++parenDepth_;
|
|
else
|
|
--parenDepth_;
|
|
if (parenDepth_ >= 0)
|
|
continue;
|
|
// this is not a template -> leave...
|
|
isInTemplate = false;
|
|
templateDepth = 0;
|
|
return;
|
|
}
|
|
else if (nextLine_.compare(i, 2, AS_AND) == 0
|
|
|| nextLine_.compare(i, 2, AS_OR) == 0)
|
|
{
|
|
// this is not a template -> leave...
|
|
isInTemplate = false;
|
|
templateDepth = 0;
|
|
return;
|
|
}
|
|
else if (currentChar_ == ',' // comma, e.g. A<int, char>
|
|
|| currentChar_ == '&' // reference, e.g. A<int&>
|
|
|| currentChar_ == '*' // pointer, e.g. A<int*>
|
|
|| currentChar_ == '^' // C++/CLI managed pointer, e.g. A<int^>
|
|
|| currentChar_ == ':' // ::, e.g. std::string
|
|
|| currentChar_ == '=' // assign e.g. default parameter
|
|
|| currentChar_ == '[' // [] e.g. string[]
|
|
|| currentChar_ == ']' // [] e.g. string[]
|
|
|| currentChar_ == '(' // (...) e.g. function definition
|
|
|| currentChar_ == ')' // (...) e.g. function definition
|
|
|| (isJavaStyle() && currentChar_ == '?') // Java wildcard
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
else if (!isLegalNameChar(currentChar_))
|
|
{
|
|
// this is not a template -> leave...
|
|
isInTemplate = false;
|
|
templateDepth = 0;
|
|
return;
|
|
}
|
|
string name = getCurrentWord(nextLine_, i);
|
|
i += name.length() - 1;
|
|
} // end for loop
|
|
} // end while loop
|
|
}
|
|
|
|
void ASFormatter::updateFormattedLineSplitPoints(char appendedChar)
|
|
{
|
|
assert(maxCodeLength != string::npos);
|
|
assert(formattedLine.length() > 0);
|
|
|
|
if (!isOkToSplitFormattedLine())
|
|
return;
|
|
|
|
char nextChar = peekNextChar();
|
|
|
|
// don't split before an end of line comment
|
|
if (nextChar == '/')
|
|
return;
|
|
|
|
// don't split before or after a brace
|
|
if (appendedChar == '{' || appendedChar == '}'
|
|
|| previousNonWSChar == '{' || previousNonWSChar == '}'
|
|
|| nextChar == '{' || nextChar == '}'
|
|
|| currentChar == '{' || currentChar == '}') // currentChar tests for an appended brace
|
|
return;
|
|
|
|
// don't split before or after a block paren
|
|
if (appendedChar == '[' || appendedChar == ']'
|
|
|| previousNonWSChar == '['
|
|
|| nextChar == '[' || nextChar == ']')
|
|
return;
|
|
|
|
if (isWhiteSpace(appendedChar))
|
|
{
|
|
if (nextChar != ')' // space before a closing paren
|
|
&& nextChar != '(' // space before an opening paren
|
|
&& nextChar != '/' // space before a comment
|
|
&& nextChar != ':' // space before a colon
|
|
&& currentChar != ')' // appended space before and after a closing paren
|
|
&& currentChar != '(' // appended space before and after a opening paren
|
|
&& previousNonWSChar != '(' // decided at the '('
|
|
// don't break before a pointer or reference aligned to type
|
|
&& !(nextChar == '*'
|
|
&& !isCharPotentialOperator(previousNonWSChar)
|
|
&& pointerAlignment == PTR_ALIGN_TYPE)
|
|
&& !(nextChar == '&'
|
|
&& !isCharPotentialOperator(previousNonWSChar)
|
|
&& (referenceAlignment == REF_ALIGN_TYPE
|
|
|| (referenceAlignment == REF_SAME_AS_PTR && pointerAlignment == PTR_ALIGN_TYPE)))
|
|
)
|
|
{
|
|
if (formattedLine.length() - 1 <= maxCodeLength)
|
|
maxWhiteSpace = formattedLine.length() - 1;
|
|
else
|
|
maxWhiteSpacePending = formattedLine.length() - 1;
|
|
}
|
|
}
|
|
// unpadded closing parens may split after the paren (counts as whitespace)
|
|
else if (appendedChar == ')')
|
|
{
|
|
if (nextChar != ')'
|
|
&& nextChar != ' '
|
|
&& nextChar != ';'
|
|
&& nextChar != ','
|
|
&& nextChar != '.'
|
|
&& !(nextChar == '-' && pointerSymbolFollows())) // check for ->
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxWhiteSpace = formattedLine.length();
|
|
else
|
|
maxWhiteSpacePending = formattedLine.length();
|
|
}
|
|
}
|
|
// unpadded commas may split after the comma
|
|
else if (appendedChar == ',')
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxComma = formattedLine.length();
|
|
else
|
|
maxCommaPending = formattedLine.length();
|
|
}
|
|
else if (appendedChar == '(')
|
|
{
|
|
if (nextChar != ')' && nextChar != '(' && nextChar != '"' && nextChar != '\'')
|
|
{
|
|
// if follows an operator break before
|
|
size_t parenNum;
|
|
if (isCharPotentialOperator(previousNonWSChar))
|
|
parenNum = formattedLine.length() - 1;
|
|
else
|
|
parenNum = formattedLine.length();
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxParen = parenNum;
|
|
else
|
|
maxParenPending = parenNum;
|
|
}
|
|
}
|
|
else if (appendedChar == ';')
|
|
{
|
|
if (nextChar != ' ' && nextChar != '}' && nextChar != '/') // check for following comment
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxSemi = formattedLine.length();
|
|
else
|
|
maxSemiPending = formattedLine.length();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ASFormatter::updateFormattedLineSplitPointsOperator(const string& sequence)
|
|
{
|
|
assert(maxCodeLength != string::npos);
|
|
assert(formattedLine.length() > 0);
|
|
|
|
if (!isOkToSplitFormattedLine())
|
|
return;
|
|
|
|
char nextChar = peekNextChar();
|
|
|
|
// don't split before an end of line comment
|
|
if (nextChar == '/')
|
|
return;
|
|
|
|
// check for logical conditional
|
|
if (sequence == "||" || sequence == "&&" || sequence == "or" || sequence == "and")
|
|
{
|
|
if (shouldBreakLineAfterLogical)
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxAndOr = formattedLine.length();
|
|
else
|
|
maxAndOrPending = formattedLine.length();
|
|
}
|
|
else
|
|
{
|
|
// adjust for leading space in the sequence
|
|
size_t sequenceLength = sequence.length();
|
|
if (formattedLine.length() > sequenceLength
|
|
&& isWhiteSpace(formattedLine[formattedLine.length() - sequenceLength - 1]))
|
|
sequenceLength++;
|
|
if (formattedLine.length() - sequenceLength <= maxCodeLength)
|
|
maxAndOr = formattedLine.length() - sequenceLength;
|
|
else
|
|
maxAndOrPending = formattedLine.length() - sequenceLength;
|
|
}
|
|
}
|
|
// comparison operators will split after the operator (counts as whitespace)
|
|
else if (sequence == "==" || sequence == "!=" || sequence == ">=" || sequence == "<=")
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxWhiteSpace = formattedLine.length();
|
|
else
|
|
maxWhiteSpacePending = formattedLine.length();
|
|
}
|
|
// unpadded operators that will split BEFORE the operator (counts as whitespace)
|
|
else if (sequence == "+" || sequence == "-" || sequence == "?")
|
|
{
|
|
if (charNum > 0
|
|
&& !(sequence == "+" && isInExponent())
|
|
&& !(sequence == "-" && isInExponent())
|
|
&& (isLegalNameChar(currentLine[charNum - 1])
|
|
|| currentLine[charNum - 1] == ')'
|
|
|| currentLine[charNum - 1] == ']'
|
|
|| currentLine[charNum - 1] == '\"'))
|
|
{
|
|
if (formattedLine.length() - 1 <= maxCodeLength)
|
|
maxWhiteSpace = formattedLine.length() - 1;
|
|
else
|
|
maxWhiteSpacePending = formattedLine.length() - 1;
|
|
}
|
|
}
|
|
// unpadded operators that will USUALLY split AFTER the operator (counts as whitespace)
|
|
else if (sequence == "=" || sequence == ":")
|
|
{
|
|
// split BEFORE if the line is too long
|
|
// do NOT use <= here, must allow for a brace attached to an array
|
|
size_t splitPoint = 0;
|
|
if (formattedLine.length() < maxCodeLength)
|
|
splitPoint = formattedLine.length();
|
|
else
|
|
splitPoint = formattedLine.length() - 1;
|
|
// padded or unpadded arrays
|
|
if (previousNonWSChar == ']')
|
|
{
|
|
if (formattedLine.length() - 1 <= maxCodeLength)
|
|
maxWhiteSpace = splitPoint;
|
|
else
|
|
maxWhiteSpacePending = splitPoint;
|
|
}
|
|
else if (charNum > 0
|
|
&& (isLegalNameChar(currentLine[charNum - 1])
|
|
|| currentLine[charNum - 1] == ')'
|
|
|| currentLine[charNum - 1] == ']'))
|
|
{
|
|
if (formattedLine.length() <= maxCodeLength)
|
|
maxWhiteSpace = splitPoint;
|
|
else
|
|
maxWhiteSpacePending = splitPoint;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update the split point when a pointer or reference is formatted.
|
|
* The argument is the maximum index of the last whitespace character.
|
|
*/
|
|
void ASFormatter::updateFormattedLineSplitPointsPointerOrReference(size_t index)
|
|
{
|
|
assert(maxCodeLength != string::npos);
|
|
assert(formattedLine.length() > 0);
|
|
assert(index < formattedLine.length());
|
|
|
|
if (!isOkToSplitFormattedLine())
|
|
return;
|
|
|
|
if (index < maxWhiteSpace) // just in case
|
|
return;
|
|
|
|
if (index <= maxCodeLength)
|
|
maxWhiteSpace = index;
|
|
else
|
|
maxWhiteSpacePending = index;
|
|
}
|
|
|
|
bool ASFormatter::isOkToSplitFormattedLine()
|
|
{
|
|
assert(maxCodeLength != string::npos);
|
|
// Is it OK to split the line?
|
|
if (shouldKeepLineUnbroken
|
|
|| isInLineComment
|
|
|| isInComment
|
|
|| isInQuote
|
|
|| isInCase
|
|
|| isInPreprocessor
|
|
|| isInExecSQL
|
|
|| isInAsm || isInAsmOneLine || isInAsmBlock
|
|
|| isInTemplate)
|
|
return false;
|
|
|
|
if (!isOkToBreakBlock(braceTypeStack->back()) && currentChar != '{')
|
|
{
|
|
shouldKeepLineUnbroken = true;
|
|
clearFormattedLineSplitPoints();
|
|
return false;
|
|
}
|
|
if (isBraceType(braceTypeStack->back(), ARRAY_TYPE))
|
|
{
|
|
shouldKeepLineUnbroken = true;
|
|
if (!isBraceType(braceTypeStack->back(), ARRAY_NIS_TYPE))
|
|
clearFormattedLineSplitPoints();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* This is called if the option maxCodeLength is set.
|
|
*/
|
|
void ASFormatter::testForTimeToSplitFormattedLine()
|
|
{
|
|
// DO NOT ASSERT maxCodeLength HERE
|
|
// should the line be split
|
|
if (formattedLine.length() > maxCodeLength && !isLineReady)
|
|
{
|
|
size_t splitPoint = findFormattedLineSplitPoint();
|
|
if (splitPoint > 0 && splitPoint < formattedLine.length())
|
|
{
|
|
string splitLine = formattedLine.substr(splitPoint);
|
|
formattedLine = formattedLine.substr(0, splitPoint);
|
|
breakLine(true);
|
|
formattedLine = splitLine;
|
|
// if break-blocks is requested and this is a one-line statement
|
|
string nextWord = ASBeautifier::getNextWord(currentLine, charNum - 1);
|
|
if (isAppendPostBlockEmptyLineRequested
|
|
&& (nextWord == "break" || nextWord == "continue"))
|
|
{
|
|
isAppendPostBlockEmptyLineRequested = false;
|
|
isPrependPostBlockEmptyLineRequested = true;
|
|
}
|
|
else
|
|
isPrependPostBlockEmptyLineRequested = false;
|
|
// adjust max split points
|
|
maxAndOr = (maxAndOr > splitPoint) ? (maxAndOr - splitPoint) : 0;
|
|
maxSemi = (maxSemi > splitPoint) ? (maxSemi - splitPoint) : 0;
|
|
maxComma = (maxComma > splitPoint) ? (maxComma - splitPoint) : 0;
|
|
maxParen = (maxParen > splitPoint) ? (maxParen - splitPoint) : 0;
|
|
maxWhiteSpace = (maxWhiteSpace > splitPoint) ? (maxWhiteSpace - splitPoint) : 0;
|
|
if (maxSemiPending > 0)
|
|
{
|
|
maxSemi = (maxSemiPending > splitPoint) ? (maxSemiPending - splitPoint) : 0;
|
|
maxSemiPending = 0;
|
|
}
|
|
if (maxAndOrPending > 0)
|
|
{
|
|
maxAndOr = (maxAndOrPending > splitPoint) ? (maxAndOrPending - splitPoint) : 0;
|
|
maxAndOrPending = 0;
|
|
}
|
|
if (maxCommaPending > 0)
|
|
{
|
|
maxComma = (maxCommaPending > splitPoint) ? (maxCommaPending - splitPoint) : 0;
|
|
maxCommaPending = 0;
|
|
}
|
|
if (maxParenPending > 0)
|
|
{
|
|
maxParen = (maxParenPending > splitPoint) ? (maxParenPending - splitPoint) : 0;
|
|
maxParenPending = 0;
|
|
}
|
|
if (maxWhiteSpacePending > 0)
|
|
{
|
|
maxWhiteSpace = (maxWhiteSpacePending > splitPoint) ? (maxWhiteSpacePending - splitPoint) : 0;
|
|
maxWhiteSpacePending = 0;
|
|
}
|
|
// don't allow an empty formatted line
|
|
size_t firstText = formattedLine.find_first_not_of(" \t");
|
|
if (firstText == string::npos && formattedLine.length() > 0)
|
|
{
|
|
formattedLine.erase();
|
|
clearFormattedLineSplitPoints();
|
|
if (isWhiteSpace(currentChar))
|
|
for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++)
|
|
goForward(1);
|
|
}
|
|
else if (firstText > 0)
|
|
{
|
|
formattedLine.erase(0, firstText);
|
|
maxSemi = (maxSemi > firstText) ? (maxSemi - firstText) : 0;
|
|
maxAndOr = (maxAndOr > firstText) ? (maxAndOr - firstText) : 0;
|
|
maxComma = (maxComma > firstText) ? (maxComma - firstText) : 0;
|
|
maxParen = (maxParen > firstText) ? (maxParen - firstText) : 0;
|
|
maxWhiteSpace = (maxWhiteSpace > firstText) ? (maxWhiteSpace - firstText) : 0;
|
|
}
|
|
// reset formattedLineCommentNum
|
|
if (formattedLineCommentNum != string::npos)
|
|
{
|
|
formattedLineCommentNum = formattedLine.find("//");
|
|
if (formattedLineCommentNum == string::npos)
|
|
formattedLineCommentNum = formattedLine.find("/*");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t ASFormatter::findFormattedLineSplitPoint() const
|
|
{
|
|
assert(maxCodeLength != string::npos);
|
|
// determine where to split
|
|
size_t minCodeLength = 10;
|
|
size_t splitPoint = 0;
|
|
splitPoint = maxSemi;
|
|
if (maxAndOr >= minCodeLength)
|
|
splitPoint = maxAndOr;
|
|
if (splitPoint < minCodeLength)
|
|
{
|
|
splitPoint = maxWhiteSpace;
|
|
// use maxParen instead if it is long enough
|
|
if (maxParen > splitPoint
|
|
|| maxParen >= maxCodeLength * .7)
|
|
splitPoint = maxParen;
|
|
// use maxComma instead if it is long enough
|
|
// increasing the multiplier causes more splits at whitespace
|
|
if (maxComma > splitPoint
|
|
|| maxComma >= maxCodeLength * .3)
|
|
splitPoint = maxComma;
|
|
}
|
|
// replace split point with first available break point
|
|
if (splitPoint < minCodeLength)
|
|
{
|
|
splitPoint = string::npos;
|
|
if (maxSemiPending > 0 && maxSemiPending < splitPoint)
|
|
splitPoint = maxSemiPending;
|
|
if (maxAndOrPending > 0 && maxAndOrPending < splitPoint)
|
|
splitPoint = maxAndOrPending;
|
|
if (maxCommaPending > 0 && maxCommaPending < splitPoint)
|
|
splitPoint = maxCommaPending;
|
|
if (maxParenPending > 0 && maxParenPending < splitPoint)
|
|
splitPoint = maxParenPending;
|
|
if (maxWhiteSpacePending > 0 && maxWhiteSpacePending < splitPoint)
|
|
splitPoint = maxWhiteSpacePending;
|
|
if (splitPoint == string::npos)
|
|
splitPoint = 0;
|
|
}
|
|
// if remaining line after split is too long
|
|
else if (formattedLine.length() - splitPoint > maxCodeLength)
|
|
{
|
|
// if end of the currentLine, find a new split point
|
|
size_t newCharNum;
|
|
if (isCharPotentialHeader(currentLine, charNum))
|
|
newCharNum = getCurrentWord(currentLine, charNum).length() + charNum;
|
|
else
|
|
newCharNum = charNum + 2;
|
|
if (newCharNum + 1 > currentLine.length())
|
|
{
|
|
// don't move splitPoint from before a conditional to after
|
|
if (maxWhiteSpace > splitPoint + 3)
|
|
splitPoint = maxWhiteSpace;
|
|
if (maxParen > splitPoint)
|
|
splitPoint = maxParen;
|
|
}
|
|
}
|
|
|
|
return splitPoint;
|
|
}
|
|
|
|
void ASFormatter::clearFormattedLineSplitPoints()
|
|
{
|
|
maxSemi = 0;
|
|
maxAndOr = 0;
|
|
maxComma = 0;
|
|
maxParen = 0;
|
|
maxWhiteSpace = 0;
|
|
maxSemiPending = 0;
|
|
maxAndOrPending = 0;
|
|
maxCommaPending = 0;
|
|
maxParenPending = 0;
|
|
maxWhiteSpacePending = 0;
|
|
}
|
|
|
|
/**
|
|
* Check if a pointer symbol (->) follows on the currentLine.
|
|
*/
|
|
bool ASFormatter::pointerSymbolFollows() const
|
|
{
|
|
size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (peekNum == string::npos || currentLine.compare(peekNum, 2, "->") != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Compute the input checksum.
|
|
* This is called as an assert so it for is debug config only
|
|
*/
|
|
bool ASFormatter::computeChecksumIn(const string& currentLine_)
|
|
{
|
|
for (size_t i = 0; i < currentLine_.length(); i++)
|
|
if (!isWhiteSpace(currentLine_[i]))
|
|
checksumIn += currentLine_[i];
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Adjust the input checksum for deleted chars.
|
|
* This is called as an assert so it for is debug config only
|
|
*/
|
|
bool ASFormatter::adjustChecksumIn(int adjustment)
|
|
{
|
|
checksumIn += adjustment;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* get the value of checksumIn for unit testing
|
|
*
|
|
* @return checksumIn.
|
|
*/
|
|
size_t ASFormatter::getChecksumIn() const
|
|
{
|
|
return checksumIn;
|
|
}
|
|
|
|
/**
|
|
* Compute the output checksum.
|
|
* This is called as an assert so it is for debug config only
|
|
*/
|
|
bool ASFormatter::computeChecksumOut(const string& beautifiedLine)
|
|
{
|
|
for (size_t i = 0; i < beautifiedLine.length(); i++)
|
|
if (!isWhiteSpace(beautifiedLine[i]))
|
|
checksumOut += beautifiedLine[i];
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Return isLineReady for the final check at end of file.
|
|
*/
|
|
bool ASFormatter::getIsLineReady() const
|
|
{
|
|
return isLineReady;
|
|
}
|
|
|
|
/**
|
|
* get the value of checksumOut for unit testing
|
|
*
|
|
* @return checksumOut.
|
|
*/
|
|
size_t ASFormatter::getChecksumOut() const
|
|
{
|
|
return checksumOut;
|
|
}
|
|
|
|
/**
|
|
* Return the difference in checksums.
|
|
* If zero all is okay.
|
|
*/
|
|
int ASFormatter::getChecksumDiff() const
|
|
{
|
|
return checksumOut - checksumIn;
|
|
}
|
|
|
|
// for unit testing
|
|
int ASFormatter::getFormatterFileType() const
|
|
{
|
|
return formatterFileType;
|
|
}
|
|
|
|
// Check if an operator follows the next word.
|
|
// The next word must be a legal name.
|
|
const string* ASFormatter::getFollowingOperator() const
|
|
{
|
|
// find next word
|
|
size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextNum == string::npos)
|
|
return nullptr;
|
|
|
|
if (!isLegalNameChar(currentLine[nextNum]))
|
|
return nullptr;
|
|
|
|
// bypass next word and following spaces
|
|
while (nextNum < currentLine.length())
|
|
{
|
|
if (!isLegalNameChar(currentLine[nextNum])
|
|
&& !isWhiteSpace(currentLine[nextNum]))
|
|
break;
|
|
nextNum++;
|
|
}
|
|
|
|
if (nextNum >= currentLine.length()
|
|
|| !isCharPotentialOperator(currentLine[nextNum])
|
|
|| currentLine[nextNum] == '/') // comment
|
|
return nullptr;
|
|
|
|
const string* newOperator = ASBase::findOperator(currentLine, nextNum, operators);
|
|
return newOperator;
|
|
}
|
|
|
|
// Check following data to determine if the current character is an array operator.
|
|
bool ASFormatter::isArrayOperator() const
|
|
{
|
|
assert(currentChar == '*' || currentChar == '&' || currentChar == '^');
|
|
assert(isBraceType(braceTypeStack->back(), ARRAY_TYPE));
|
|
|
|
// find next word
|
|
size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextNum == string::npos)
|
|
return false;
|
|
|
|
if (!isLegalNameChar(currentLine[nextNum]))
|
|
return false;
|
|
|
|
// bypass next word and following spaces
|
|
while (nextNum < currentLine.length())
|
|
{
|
|
if (!isLegalNameChar(currentLine[nextNum])
|
|
&& !isWhiteSpace(currentLine[nextNum]))
|
|
break;
|
|
nextNum++;
|
|
}
|
|
|
|
// check for characters that indicate an operator
|
|
if (currentLine[nextNum] == ','
|
|
|| currentLine[nextNum] == '}'
|
|
|| currentLine[nextNum] == ')'
|
|
|| currentLine[nextNum] == '(')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Reset the flags that indicate various statement information.
|
|
void ASFormatter::resetEndOfStatement()
|
|
{
|
|
foundQuestionMark = false;
|
|
foundNamespaceHeader = false;
|
|
foundClassHeader = false;
|
|
foundStructHeader = false;
|
|
foundInterfaceHeader = false;
|
|
foundPreDefinitionHeader = false;
|
|
foundPreCommandHeader = false;
|
|
foundPreCommandMacro = false;
|
|
foundTrailingReturnType = false;
|
|
foundCastOperator = false;
|
|
isInPotentialCalculation = false;
|
|
isSharpAccessor = false;
|
|
isSharpDelegate = false;
|
|
isInObjCMethodDefinition = false;
|
|
isInObjCInterface = false;
|
|
isInObjCSelector = false;
|
|
isInEnum = false;
|
|
isInExternC = false;
|
|
elseHeaderFollowsComments = false;
|
|
nonInStatementBrace = 0;
|
|
while (!questionMarkStack->empty())
|
|
questionMarkStack->pop_back();
|
|
}
|
|
|
|
// Find the colon alignment for Objective-C method definitions and method calls.
|
|
int ASFormatter::findObjCColonAlignment() const
|
|
{
|
|
assert(currentChar == '+' || currentChar == '-' || currentChar == '[');
|
|
assert(getAlignMethodColon());
|
|
|
|
bool isFirstLine = true;
|
|
bool haveFirstColon = false;
|
|
bool foundMethodColon = false;
|
|
bool isInComment_ = false;
|
|
bool isInQuote_ = false;
|
|
char quoteChar_ = ' ';
|
|
int sqBracketCount = 0;
|
|
int colonAdjust = 0;
|
|
int colonAlign = 0;
|
|
string nextLine_ = currentLine;
|
|
ASPeekStream stream(sourceIterator);
|
|
|
|
// peek next line
|
|
while (sourceIterator->hasMoreLines() || isFirstLine)
|
|
{
|
|
if (!isFirstLine)
|
|
nextLine_ = stream.peekNextLine();
|
|
// parse the line
|
|
haveFirstColon = false;
|
|
nextLine_ = ASBeautifier::trim(nextLine_);
|
|
for (size_t i = 0; i < nextLine_.length(); i++)
|
|
{
|
|
if (isWhiteSpace(nextLine_[i]))
|
|
continue;
|
|
if (nextLine_.compare(i, 2, "/*") == 0)
|
|
isInComment_ = true;
|
|
if (isInComment_)
|
|
{
|
|
if (nextLine_.compare(i, 2, "*/") == 0)
|
|
{
|
|
isInComment_ = false;
|
|
++i;
|
|
}
|
|
continue;
|
|
}
|
|
if (nextLine_[i] == '\\')
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
if (isInQuote_)
|
|
{
|
|
if (nextLine_[i] == quoteChar_)
|
|
isInQuote_ = false;
|
|
continue;
|
|
}
|
|
|
|
if (nextLine_[i] == '"'
|
|
|| (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i)))
|
|
{
|
|
isInQuote_ = true;
|
|
quoteChar_ = nextLine_[i];
|
|
continue;
|
|
}
|
|
if (nextLine_.compare(i, 2, "//") == 0)
|
|
{
|
|
i = nextLine_.length();
|
|
continue;
|
|
}
|
|
// process the current char
|
|
if ((nextLine_[i] == '{' && (currentChar == '-' || currentChar == '+'))
|
|
|| nextLine_[i] == ';')
|
|
goto EndOfWhileLoop; // end of method definition
|
|
if (nextLine_[i] == ']')
|
|
{
|
|
--sqBracketCount;
|
|
if (sqBracketCount == 0)
|
|
goto EndOfWhileLoop; // end of method call
|
|
}
|
|
if (nextLine_[i] == '[')
|
|
++sqBracketCount;
|
|
if (isFirstLine) // colon align does not include the first line
|
|
continue;
|
|
if (sqBracketCount > 1)
|
|
continue;
|
|
if (haveFirstColon) // multiple colons per line
|
|
continue;
|
|
// compute colon adjustment
|
|
if (nextLine_[i] == ':')
|
|
{
|
|
haveFirstColon = true;
|
|
foundMethodColon = true;
|
|
if (shouldPadMethodColon)
|
|
{
|
|
int spacesStart;
|
|
for (spacesStart = i; spacesStart > 0; spacesStart--)
|
|
if (!isWhiteSpace(nextLine_[spacesStart - 1]))
|
|
break;
|
|
int spaces = i - spacesStart;
|
|
if (objCColonPadMode == COLON_PAD_ALL || objCColonPadMode == COLON_PAD_BEFORE)
|
|
colonAdjust = 1 - spaces;
|
|
else if (objCColonPadMode == COLON_PAD_NONE || objCColonPadMode == COLON_PAD_AFTER)
|
|
colonAdjust = 0 - spaces;
|
|
}
|
|
// compute alignment
|
|
int colonPosition = i + colonAdjust;
|
|
if (colonPosition > colonAlign)
|
|
colonAlign = colonPosition;
|
|
}
|
|
} // end of for loop
|
|
isFirstLine = false;
|
|
} // end of while loop
|
|
EndOfWhileLoop:
|
|
if (!foundMethodColon)
|
|
colonAlign = -1;
|
|
return colonAlign;
|
|
}
|
|
|
|
// pad an Objective-C method colon
|
|
void ASFormatter::padObjCMethodColon()
|
|
{
|
|
assert(currentChar == ':');
|
|
int commentAdjust = 0;
|
|
char nextChar = peekNextChar();
|
|
if (objCColonPadMode == COLON_PAD_NONE
|
|
|| objCColonPadMode == COLON_PAD_AFTER
|
|
|| nextChar == ')')
|
|
{
|
|
// remove spaces before
|
|
for (int i = formattedLine.length() - 1; (i > -1) && isWhiteSpace(formattedLine[i]); i--)
|
|
{
|
|
formattedLine.erase(i);
|
|
--commentAdjust;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pad space before
|
|
for (int i = formattedLine.length() - 1; (i > 0) && isWhiteSpace(formattedLine[i]); i--)
|
|
if (isWhiteSpace(formattedLine[i - 1]))
|
|
{
|
|
formattedLine.erase(i);
|
|
--commentAdjust;
|
|
}
|
|
appendSpacePad();
|
|
}
|
|
if (objCColonPadMode == COLON_PAD_NONE
|
|
|| objCColonPadMode == COLON_PAD_BEFORE
|
|
|| nextChar == ')')
|
|
{
|
|
// remove spaces after
|
|
int nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextText == (int)string::npos)
|
|
nextText = currentLine.length();
|
|
int spaces = nextText - charNum - 1;
|
|
if (spaces > 0)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces);
|
|
spacePadNum -= spaces;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pad space after
|
|
int nextText = currentLine.find_first_not_of(" \t", charNum + 1);
|
|
if (nextText == (int)string::npos)
|
|
nextText = currentLine.length();
|
|
int spaces = nextText - charNum - 1;
|
|
if (spaces == 0)
|
|
{
|
|
currentLine.insert(charNum + 1, 1, ' ');
|
|
spacePadNum += 1;
|
|
}
|
|
else if (spaces > 1)
|
|
{
|
|
// do not use goForward here
|
|
currentLine.erase(charNum + 1, spaces - 1);
|
|
spacePadNum -= spaces - 1;
|
|
}
|
|
}
|
|
spacePadNum += commentAdjust;
|
|
}
|
|
|
|
// Remove the leading '*' from a comment line and indent to the next tab.
|
|
void ASFormatter::stripCommentPrefix()
|
|
{
|
|
int firstChar = formattedLine.find_first_not_of(" \t");
|
|
if (firstChar < 0)
|
|
return;
|
|
|
|
if (isInCommentStartLine)
|
|
{
|
|
// comment opener must begin the line
|
|
if (formattedLine.compare(firstChar, 2, "/*") != 0)
|
|
return;
|
|
int commentOpener = firstChar;
|
|
// ignore single line comments
|
|
int commentEnd = formattedLine.find("*/", firstChar + 2);
|
|
if (commentEnd != -1)
|
|
return;
|
|
// first char after the comment opener must be at least one indent
|
|
int followingText = formattedLine.find_first_not_of(" \t", commentOpener + 2);
|
|
if (followingText < 0)
|
|
return;
|
|
if (formattedLine[followingText] == '*' || formattedLine[followingText] == '!')
|
|
followingText = formattedLine.find_first_not_of(" \t", followingText + 1);
|
|
if (followingText < 0)
|
|
return;
|
|
if (formattedLine[followingText] == '*')
|
|
return;
|
|
int indentLen = getIndentLength();
|
|
int followingTextIndent = followingText - commentOpener;
|
|
if (followingTextIndent < indentLen)
|
|
{
|
|
string stringToInsert(indentLen - followingTextIndent, ' ');
|
|
formattedLine.insert(followingText, stringToInsert);
|
|
}
|
|
return;
|
|
}
|
|
// comment body including the closer
|
|
if (formattedLine[firstChar] == '*')
|
|
{
|
|
if (formattedLine.compare(firstChar, 2, "*/") == 0)
|
|
{
|
|
// line starts with an end comment
|
|
formattedLine = "*/";
|
|
}
|
|
else
|
|
{
|
|
// build a new line with one indent
|
|
int secondChar = formattedLine.find_first_not_of(" \t", firstChar + 1);
|
|
if (secondChar < 0)
|
|
{
|
|
adjustChecksumIn(-'*');
|
|
formattedLine.erase();
|
|
return;
|
|
}
|
|
if (formattedLine[secondChar] == '*')
|
|
return;
|
|
// replace the leading '*'
|
|
int indentLen = getIndentLength();
|
|
adjustChecksumIn(-'*');
|
|
// second char must be at least one indent
|
|
if (formattedLine.substr(0, secondChar).find('\t') != string::npos)
|
|
{
|
|
formattedLine.erase(firstChar, 1);
|
|
}
|
|
else
|
|
{
|
|
int spacesToInsert = 0;
|
|
if (secondChar >= indentLen)
|
|
spacesToInsert = secondChar;
|
|
else
|
|
spacesToInsert = indentLen;
|
|
formattedLine = string(spacesToInsert, ' ') + formattedLine.substr(secondChar);
|
|
}
|
|
// remove a trailing '*'
|
|
int lastChar = formattedLine.find_last_not_of(" \t");
|
|
if (lastChar > -1 && formattedLine[lastChar] == '*')
|
|
{
|
|
adjustChecksumIn(-'*');
|
|
formattedLine[lastChar] = ' ';
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// first char not a '*'
|
|
// first char must be at least one indent
|
|
if (formattedLine.substr(0, firstChar).find('\t') == string::npos)
|
|
{
|
|
int indentLen = getIndentLength();
|
|
if (firstChar < indentLen)
|
|
{
|
|
string stringToInsert(indentLen, ' ');
|
|
formattedLine = stringToInsert + formattedLine.substr(firstChar);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // end namespace astyle
|