Add mechanisms to reformant and check code style (#128)

Use an internal version of astyle (astyle 3.0). Scripts taken from QGIS.
astyle.options from https://github.com/uclouvain/openjpeg/issues/128

scripts/prepare-commit.sh can be used locally to automatically reformat
edited files.

Travis-CI will run scripts/verify-indentation.sh to verify committed files.

1 files changed, 7714 insertions, 0 deletions

diff --git a/thirdparty/astyle/ASFormatter.cpp b/thirdparty/astyle/ASFormatter.cpp
new file mode 100755
index 00000000..b292305b
--- /dev/null
+++ b/thirdparty/astyle/ASFormatter.cpp
@@ -0,0 +1,7714 @@
+// 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