mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-28 00:17:30 -05:00
fa5bd491fc
instead of adding an extra CMakeLists in .ci/travis/code_layout to build API doc, astyle and run tests (indentation, spelling, sip, doc coverage), the top CMakeLists has been adapted to allow not building core libraries and possibly just the static code layout * astyle has been moved from /src/astyle to /lib/astyle (I would propose to move all external libraries, and possibly add git submodules)
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
|