File indexing completed on 2024-04-28 08:27:16

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *
  *   Copyright (C) 2006-2010 by Jim Pattee <jimp03@email.com>
  *   Copyright (C) 1998-2002 by Tal Davidson
  *   <http://www.gnu.org/licenses/lgpl-3.0.html>
  *
  *   This file is a part of Artistic Style - an indentation and
  *   reformatting tool for C, C++, C# and Java source files.
  *   <http://astyle.sourceforge.net>
  *
  *   Artistic Style is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Lesser General Public License as published
  *   by the Free Software Foundation, either version 3 of the License, or
  *   (at your option) any later version.
  *
  *   Artistic Style is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU Lesser General Public License for more details.
  *
  *   You should have received a copy of the GNU Lesser General Public License
  *   along with Artistic Style.  If not, see <http://www.gnu.org/licenses/>.
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  */
 
 #include "astyle.h"
 
 #include <algorithm>
 #include <fstream>
 #include <iostream>
 
 
 namespace astyle
 {
 // static member variables
 int ASFormatter::formatterFileType = 9;     // initialized with an invalid type
 vector<const string*>* ASFormatter::headers = NULL;
 vector<const string*>* ASFormatter::nonParenHeaders = NULL;
 vector<const string*>* ASFormatter::preDefinitionHeaders = NULL;
 vector<const string*>* ASFormatter::preCommandHeaders = NULL;
 vector<const string*>* ASFormatter::operators = NULL;
 vector<const string*>* ASFormatter::assignmentOperators = NULL;
 vector<const string*>* ASFormatter::castOperators = NULL;
 
 /**
  * Constructor of ASFormatter
  */
 ASFormatter::ASFormatter()
 {
     sourceIterator = NULL;
     enhancer = new ASEnhancer;
     preBracketHeaderStack = NULL;
     bracketTypeStack = NULL;
     parenStack = NULL;
     structStack = NULL;
     lineCommentNoIndent = false;
     formattingStyle = STYLE_NONE;
     bracketFormatMode = NONE_MODE;
     pointerAlignment = ALIGN_NONE;
     lineEnd = LINEEND_DEFAULT;
     shouldPadOperators = false;
     shouldPadParensOutside = false;
     shouldPadParensInside = false;
     shouldPadHeader = false;
     shouldUnPadParens = false;
     shouldBreakOneLineBlocks = true;
     shouldBreakOneLineStatements = true;
     shouldConvertTabs = false;
     shouldIndentCol1Comments = false;
     shouldBreakBlocks = false;
     shouldBreakClosingHeaderBlocks = false;
     shouldBreakClosingHeaderBrackets = false;
     shouldDeleteEmptyLines = false;
     shouldBreakElseIfs = false;
     shouldAddBrackets = false;
     shouldAddOneLineBrackets = false;
 
     // initialize ASFormatter static member vectors
     formatterFileType = 9;      // reset to an invalid type
     initVector(headers);
     initVector(nonParenHeaders);
     initVector(preDefinitionHeaders);
     initVector(preCommandHeaders);
     initVector(operators);
     initVector(assignmentOperators);
     initVector(castOperators);
 
     // the following prevents warning messages with cppcheck
     // it will NOT compile if activated
 //  init();
 }
 
 /**
  * Destructor of ASFormatter
  */
 ASFormatter::~ASFormatter()
 {
     // delete ASFormatter stack vectors
     deleteContainer(preBracketHeaderStack);
     deleteContainer(bracketTypeStack);
     deleteContainer(parenStack);
     deleteContainer(structStack);
 
     // delete static member vectors using swap to eliminate memory leak reporting
     // delete ASFormatter static member vectors
     formatterFileType = 9;      // reset to an invalid type
     deleteVector(headers);
     deleteVector(nonParenHeaders);
     deleteVector(preDefinitionHeaders);
     deleteVector(preCommandHeaders);
     deleteVector(operators);
     deleteVector(assignmentOperators);
     deleteVector(castOperators);
 
     // delete ASBeautifier static member vectors
     // must be done when the ASFormatter object is deleted (not ASBeautifier)
     ASBeautifier::deleteStaticVectors();
 
     delete enhancer;
 }
 
 /**
  * initialize the ASFormatter.
  *
  * init() should be called every time a ASFormatter object is to start
  * formatting a NEW source file.
  * init() recieves a pointer to a ASSourceIterator object that will be
  * used to iterate through the source code.
  *
  * @param sourceIterator     a pointer to the ASSourceIterator or ASStreamIterator object.
  */
 void ASFormatter::init(ASSourceIterator *si)
 {
     buildLanguageVectors();
     fixOptionVariableConflicts();
 
     ASBeautifier::init(si);
     enhancer->init(getFileType(),
                    getIndentLength(),
                    getIndentString(),
                    getCaseIndent(),
                    getEmptyLineFill());
     sourceIterator = si;
 
     initContainer(preBracketHeaderStack, new vector<const string*>);
     initContainer(parenStack, new vector<int>);
     initContainer(structStack, new vector<bool>);
     parenStack->push_back(0);               // parenStack must contain this default entry
     initContainer(bracketTypeStack, new vector<BracketType>);
     bracketTypeStack->push_back(NULL_TYPE);
 
     currentHeader = NULL;
     currentLine = "";
     readyFormattedLine = "";
     formattedLine = "";
     currentChar = ' ';
     previousChar = ' ';
     previousCommandChar = ' ';
     previousNonWSChar = ' ';
     quoteChar = '"';
     charNum = 0;
     leadingSpaces = 0;
     formattedLineCommentNum = 0;
     preprocBracketTypeStackSize = 0;
     spacePadNum = 0;
     nextLineSpacePadNum = 0;
     currentLineFirstBracketNum = string::npos;
     previousReadyFormattedLineLength = string::npos;
     templateDepth = 0;
     traceLineNumber = 0;
     horstmannIndentChars = 0;
     tabIncrementIn = 0;
     previousBracketType = NULL_TYPE;
     previousOperator = NULL;
 
     isVirgin = true;
     isInLineComment = false;
     isInComment = false;
     noTrimCommentContinuation = false;
     isInPreprocessor = false;
     doesLineStartComment = false;
     lineEndsInCommentOnly = false;
     lineIsLineCommentOnly = false;
     lineIsEmpty = false;
     isImmediatelyPostCommentOnly = false;
     isImmediatelyPostEmptyLine = false;
     isInQuote = false;
     isInVerbatimQuote = false;
     haveLineContinuationChar = false;
     isInQuoteContinuation = false;
     isSpecialChar = false;
     isNonParenHeader = false;
     foundNamespaceHeader = false;
     foundClassHeader = false;
     foundStructHeader = false;
     foundInterfaceHeader = false;
     foundPreDefinitionHeader = false;
     foundPreCommandHeader = false;
     foundCastOperator = false;
     foundQuestionMark = false;
     isInLineBreak = false;
     endOfCodeReached = false;
     isInExecSQL = false;
     isInAsm = false;
     isInAsmOneLine = false;
     isInAsmBlock = false;
     isLineReady = false;
     isPreviousBracketBlockRelated = false;
     isInPotentialCalculation = false;
     shouldReparseCurrentChar = false;
     needHeaderOpeningBracket = false;
     shouldBreakLineAtNextChar = false;
     passedSemicolon = false;
     passedColon = false;
     clearNonInStatement = false;
     isInTemplate = false;
     isInBlParen = false;
     isImmediatelyPostComment = false;
     isImmediatelyPostLineComment = false;
     isImmediatelyPostEmptyBlock = false;
     isImmediatelyPostPreprocessor = false;
     isImmediatelyPostReturn = false;
     isImmediatelyPostOperator = false;
     isCharImmediatelyPostReturn = false;
     isCharImmediatelyPostOperator = false;
     isCharImmediatelyPostComment = false;
     isPreviousCharPostComment = false;
     isCharImmediatelyPostLineComment = false;
     isCharImmediatelyPostOpenBlock = false;
     isCharImmediatelyPostCloseBlock = false;
     isCharImmediatelyPostTemplate = false;
     breakCurrentOneLineBlock = false;
     isInHorstmannRunIn = false;
     currentLineBeginsWithBracket = false;
     isPrependPostBlockEmptyLineRequested = false;
     isAppendPostBlockEmptyLineRequested = false;
     prependEmptyLine = false;
     appendOpeningBracket = false;
     foundClosingHeader = false;
     isImmediatelyPostHeader = false;
     isInHeader = false;
     isInCase = 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();
 
     ASResource::buildHeaders(headers, getFileType());
     ASResource::buildNonParenHeaders(nonParenHeaders, getFileType());
     ASResource::buildPreDefinitionHeaders(preDefinitionHeaders, getFileType());
     ASResource::buildPreCommandHeaders(preCommandHeaders, getFileType());
     if (operators->size() == 0)
         ASResource::buildOperators(operators);
     if (assignmentOperators->size() == 0)
         ASResource::buildAssignmentOperators(assignmentOperators);
     if (castOperators->size() == 0)
         ASResource::buildCastOperators(castOperators);
 }
 
 /**
  * set the variables for each preefined style.
  * this will override any previous settings.
  */
 void ASFormatter::fixOptionVariableConflicts()
 {
     if (formattingStyle == STYLE_ALLMAN)
     {
         setBracketFormatMode(BREAK_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
     }
     else if (formattingStyle == STYLE_JAVA)
     {
         setBracketFormatMode(ATTACH_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
     }
     else if (formattingStyle == STYLE_KandR)
     {
         setBracketFormatMode(LINUX_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
     }
     else if (formattingStyle == STYLE_STROUSTRUP)
     {
         setBracketFormatMode(STROUSTRUP_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         if (!getIndentManuallySet())
         {
             if (getIndentString() == "\t")
                 setTabIndentation(5, getForceTabIndentation());
             else
                 setSpaceIndentation(5);
         }
     }
     else if (formattingStyle == STYLE_WHITESMITH)
     {
         setBracketFormatMode(BREAK_MODE);
         setBlockIndent(false);
         setBracketIndent(true);
         setClassIndent(true);
         setSwitchIndent(true);
     }
     else if (formattingStyle == STYLE_BANNER)
     {
         setBracketFormatMode(ATTACH_MODE);
         setBlockIndent(false);
         setBracketIndent(true);
         setClassIndent(true);
         setSwitchIndent(true);
     }
     else if (formattingStyle == STYLE_GNU)
     {
         setBracketFormatMode(BREAK_MODE);
         setBlockIndent(true);
         setBracketIndent(false);
         if (!getIndentManuallySet())
         {
             if (getIndentString() == "\t")
                 setTabIndentation(2, getForceTabIndentation());
             else
                 setSpaceIndentation(2);
         }
     }
     else if (formattingStyle == STYLE_LINUX)
     {
         setBracketFormatMode(LINUX_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         if (!getIndentManuallySet())
         {
             if (getIndentString() == "\t")
                 setTabIndentation(8, getForceTabIndentation());
             else
                 setSpaceIndentation(8);
         }
         if (!getMinConditionalManuallySet())
             setMinConditionalIndentLength(getIndentLength() / 2);
     }
     else if (formattingStyle == STYLE_HORSTMANN)
     {
         setBracketFormatMode(HORSTMANN_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         setSwitchIndent(true);
         if (!getIndentManuallySet())
         {
             if (getIndentString() == "\t")
                 setTabIndentation(3, getForceTabIndentation());
             else
                 setSpaceIndentation(3);
         }
     }
     else if (formattingStyle == STYLE_1TBS)
     {
         setBracketFormatMode(LINUX_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         setAddBracketsMode(true);
     }
 
     // add-one-line-brackets implies keep-one-line-blocks
     if (shouldAddOneLineBrackets)
         setBreakOneLineBlocksMode(false);
     // cannot have both indent-blocks and indent-brackets, default to indent-blocks
     if (getBlockIndent())
         setBracketIndent(false);
 }
 
 /**
  * get the next formatted line.
  *
  * @return    formatted line.
  */
 
 string ASFormatter::nextLine()
 {
     const string *newHeader;
     bool isInVirginLine = isVirgin;
     isCharImmediatelyPostComment = false;
     isPreviousCharPostComment = false;
     isCharImmediatelyPostLineComment = false;
     isCharImmediatelyPostOpenBlock = false;
     isCharImmediatelyPostCloseBlock = false;
     isCharImmediatelyPostTemplate = false;
     traceLineNumber++;
 
     while (!isLineReady)
     {
         if (shouldReparseCurrentChar)
             shouldReparseCurrentChar = false;
         else if (!getNextChar())
         {
             breakLine();
             return beautify(readyFormattedLine);
         }
         else // stuff to do when reading a new character...
         {
             // make sure that a virgin '{' at the begining of the file will be treated as a block...
             if (isInVirginLine && currentChar == '{'
                     && currentLineBeginsWithBracket // lineBeginsWith('{')
                     && previousCommandChar == ' ')
                 previousCommandChar = '{';
             if (clearNonInStatement)
             {
                 isNonInStatementArray = false;
                 clearNonInStatement = false;
             }
             if (isInHorstmannRunIn)
                 isInLineBreak = false;
             if (!isWhiteSpace(currentChar))
                 isInHorstmannRunIn = false;
             isPreviousCharPostComment = isCharImmediatelyPostComment;
             isCharImmediatelyPostComment = false;
             isCharImmediatelyPostTemplate = false;
             isCharImmediatelyPostReturn = false;
             isCharImmediatelyPostOperator = false;
             isCharImmediatelyPostOpenBlock = false;
             isCharImmediatelyPostCloseBlock = false;
         }
 
 //      if (inLineNumber >= 7)
 //          int x = 1;
 
         if (shouldBreakLineAtNextChar && !isWhiteSpace(currentChar))
         {
             isInLineBreak = true;
             shouldBreakLineAtNextChar = false;
         }
 
         if (isInExecSQL && !passedSemicolon)
         {
             if (currentChar == ';')
                 passedSemicolon = true;
             appendCurrentChar();
             continue;
         }
 
         if (isInLineComment)
         {
             formatLineCommentBody();
             continue;
         }
         else if (isInComment)
         {
             formatCommentBody();
             continue;
         }
 
         // not in line comment or comment
 
         else if (isInQuote)
         {
             formatQuoteBody();
             continue;
         }
 
         if (isSequenceReached("//"))
         {
             formatLineCommentOpener();
             continue;
         }
         else if (isSequenceReached("/*"))
         {
             formatCommentOpener();
             continue;
         }
         else if (currentChar == '"' || currentChar == '\'')
         {
             formatQuoteOpener();
             continue;
         }
         // treat these preprocessor statements as a line comment
         else if (currentChar =='#')
         {
             if (isSequenceReached("#region")
                     || isSequenceReached("#endregion")
                     || isSequenceReached("#error")
                     || isSequenceReached("#warning"))
             {
                 // check for horstmann run-in
                 if (formattedLine[0] == '{')
                 {
                     isInLineBreak = true;
                     isInHorstmannRunIn = false;
                 }
                 isInLineComment = true;
                 appendCurrentChar();
                 continue;
             }
         }
 
         if (isInPreprocessor)
         {
             appendCurrentChar();
             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 begining
         //    of a new line in getnextChar()
         if (currentChar == '#')
         {
             isInPreprocessor = true;
             // check for horstmann run-in
             if (formattedLine[0] == '{')
             {
                 isInLineBreak = true;
                 isInHorstmannRunIn = false;
             }
             processPreprocessor();
             //  need to fall thru here to reset the variables
         }
 
         /* not in preprocessor ... */
 
         if (isImmediatelyPostComment)
         {
             isImmediatelyPostComment = false;
             isCharImmediatelyPostComment = true;
         }
 
         if (isImmediatelyPostLineComment)
         {
             isImmediatelyPostLineComment = false;
             isCharImmediatelyPostLineComment = true;
         }
 
         if (isImmediatelyPostReturn)
         {
             isImmediatelyPostReturn = false;
             isCharImmediatelyPostReturn = true;
         }
 
         if (isImmediatelyPostOperator)
         {
             isImmediatelyPostOperator = false;
             isCharImmediatelyPostOperator = true;
         }
 
         // reset isImmediatelyPostHeader information
         if (isImmediatelyPostHeader)
         {
             // should brackets be added
             if (currentChar != '{' && shouldAddBrackets)
             {
                 bool bracketsAdded = addBracketsToStatement();
                 if (bracketsAdded && !shouldAddOneLineBrackets)
                 {
                     size_t firstText = currentLine.find_first_not_of(" \t");
                     assert(firstText != string::npos);
                     if ((int) firstText == charNum)
                         breakCurrentOneLineBlock = true;
                 }
             }
 
             // Make sure headers are broken from their succeeding blocks
             // (e.g.
             //     if (isFoo) DoBar();
             //  should become
             //     if (isFoo)
             //         DoBar;
             // )
             // But treat else if() as a special case which should not be broken!
             if (shouldBreakOneLineStatements
                     && isOkToBreakBlock(bracketTypeStack->back()))
             {
                 // if may break 'else if()'s, then simply break the line
                 if (shouldBreakElseIfs)
                     isInLineBreak = true;
             }
 
             isImmediatelyPostHeader = false;
         }
 
         if (passedSemicolon)    // need to break the formattedLine
         {
             passedSemicolon = false;
             if (parenStack->back() == 0 && currentChar != ';') // allow ;;
             {
                 // does a one-line statement have ending comments?
                 if (isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE))
                 {
                     size_t blockEnd = currentLine.rfind(AS_CLOSE_BRACKET);
                     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));
                         size_t commentLength = currentLine.length() - commentStart;
                         formattedLine.append(getIndentLength() - 1, ' ');
                         formattedLine.append(currentLine, commentStart, commentLength);
                         currentLine.erase(commentStart, commentLength);
                     }
                 }
                 isInExecSQL = false;
                 shouldReparseCurrentChar = true;
                 isInLineBreak = true;
                 if (needHeaderOpeningBracket)
                 {
                     isCharImmediatelyPostCloseBlock = true;
                     needHeaderOpeningBracket = false;
                 }
                 continue;
             }
         }
 
         if (passedColon)
         {
             passedColon = false;
             if (parenStack->back() == 0 && !isBeforeAnyComment())
             {
                 shouldReparseCurrentChar = true;
                 isInLineBreak = true;
                 continue;
             }
         }
 
         // Check if in template declaration, e.g. foo<bar> or foo<bar,fig>
         // If so, set isInTemplate to true
         if (!isInTemplate && currentChar == '<')
         {
             int maxTemplateDepth = 0;
             templateDepth = 0;
             for (size_t i = charNum;
                     i < currentLine.length();
                     i++)
             {
                 char currentChar = currentLine[i];
 
                 if (currentChar == '<')
                 {
                     templateDepth++;
                     maxTemplateDepth++;
                 }
                 else if (currentChar == '>')
                 {
                     templateDepth--;
                     if (templateDepth == 0)
                     {
                         // this is a template!
                         isInTemplate = true;
                         templateDepth = maxTemplateDepth;
                         break;
                     }
                 }
                 else if (currentLine.compare(i, 2, "&&") == 0
                          || currentLine.compare(i, 2, "||") == 0)
                 {
                     // this is not a template -> leave...
                     isInTemplate = false;
                     break;
                 }
                 else if (currentChar == ','       // comma,     e.g. A<int, char>
                          || currentChar == '&'    // reference, e.g. A<int&>
                          || currentChar == '*'    // pointer,   e.g. A<int*>
                          || currentChar == ':'    // ::,        e.g. std::string
                          || currentChar == '['    // []         e.g. string[]
                          || currentChar == ']'    // []         e.g. string[]
                          || currentChar == '('    // (...)      e.g. function definition
                          || currentChar == ')')   // (...)      e.g. function definition
                 {
                     continue;
                 }
                 else if (!isLegalNameChar(currentChar) && !isWhiteSpace(currentChar))
                 {
                     // this is not a template -> leave...
                     isInTemplate = false;
                     break;
                 }
             }
         }
 
         // handle parenthesies
         if (currentChar == '(' || currentChar == '[' || (isInTemplate && currentChar == '<'))
         {
             parenStack->back()++;
             if (currentChar == '[')
                 isInBlParen = true;
         }
         else if (currentChar == ')' || currentChar == ']' || (isInTemplate && currentChar == '>'))
         {
             parenStack->back()--;
             if (isInTemplate && currentChar == '>')
             {
                 templateDepth--;
                 if (templateDepth == 0)
                 {
                     isInTemplate = false;
                     isCharImmediatelyPostTemplate = true;
                 }
             }
 
             // check if this parenthesis closes a header, e.g. if (...), while (...)
             if (isInHeader && parenStack->back() == 0)
             {
                 isInHeader = false;
                 isImmediatelyPostHeader = true;
             }
             if (currentChar == ']')
                 isInBlParen = false;
             if (currentChar == ')')
             {
                 foundCastOperator = false;
                 if (parenStack->back() == 0)
                     isInAsm = false;
             }
         }
 
         // handle brackets
         if (currentChar == '{' || currentChar == '}')
         {
             // if appendOpeningBracket this was already done for the original bracket
             if (currentChar == '{' && !appendOpeningBracket)
             {
                 BracketType newBracketType = getBracketType();
                 foundNamespaceHeader = false;
                 foundClassHeader = false;
                 foundStructHeader = false;
                 foundInterfaceHeader = false;
                 foundPreDefinitionHeader = false;
                 foundPreCommandHeader = false;
                 isInPotentialCalculation = false;
                 isJavaStaticConstructor = false;
                 needHeaderOpeningBracket = false;
 
                 isPreviousBracketBlockRelated = !isBracketType(newBracketType, ARRAY_TYPE);
                 bracketTypeStack->push_back(newBracketType);
                 preBracketHeaderStack->push_back(currentHeader);
                 currentHeader = NULL;
                 structStack->push_back(isInIndentableStruct);
                 if (isBracketType(newBracketType, STRUCT_TYPE) && isCStyle())
                     isInIndentableStruct = isStructAccessModified(currentLine, charNum);
                 else
                     isInIndentableStruct = false;
             }
 
             // this must be done before the bracketTypeStack is popped
             BracketType bracketType = bracketTypeStack->back();
             bool isOpeningArrayBracket = (isBracketType(bracketType, ARRAY_TYPE)
                                           && bracketTypeStack->size() >= 2
                                           && !isBracketType((*bracketTypeStack)[bracketTypeStack->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 bracket,
                 // then there is no need for the post block empty line.
                 isAppendPostBlockEmptyLineRequested = false;
                 breakCurrentOneLineBlock = false;
                 isInAsmBlock = false;
 
                 // added for release 1.24
                 // TODO: remove at the appropriate time
                 assert(isInAsm == false);
                 assert(isInAsmOneLine == false);
                 assert(isInQuote == false);
                 isInAsm = isInAsmOneLine = isInQuote = false;
                 // end remove
 
                 if (bracketTypeStack->size() > 1)
                 {
                     previousBracketType = bracketTypeStack->back();
                     bracketTypeStack->pop_back();
                     isPreviousBracketBlockRelated = !isBracketType(bracketType, ARRAY_TYPE);
                 }
                 else
                 {
                     previousBracketType = NULL_TYPE;
                     isPreviousBracketBlockRelated = false;
                 }
 
                 if (!preBracketHeaderStack->empty())
                 {
                     currentHeader = preBracketHeaderStack->back();
                     preBracketHeaderStack->pop_back();
                 }
                 else
                     currentHeader = NULL;
 
                 if (!structStack->empty())
                 {
                     isInIndentableStruct = structStack->back();
                     structStack->pop_back();
                 }
                 else
                     isInIndentableStruct = false;
 
                 if (isBracketType(bracketType, ARRAY_NIS_TYPE) && !isBracketType(bracketType, SINGLE_LINE_TYPE))
                     clearNonInStatement = true;
             }
 
             // format brackets
             appendOpeningBracket = false;
             if (isBracketType(bracketType, ARRAY_TYPE))
             {
                 formatArrayBrackets(bracketType, isOpeningArrayBracket);
             }
             else
             {
                 if (currentChar == '{')
                     formatOpeningBracket(bracketType);
                 else
                     formatClosingBracket(bracketType);
             }
             continue;
         }
 
         if ((((previousCommandChar == '{' && isPreviousBracketBlockRelated)
                 || ((previousCommandChar == '}'
                      && !isImmediatelyPostEmptyBlock
                      && isPreviousBracketBlockRelated
                      && !isPreviousCharPostComment       // Fixes wrongly appended newlines after '}' immediately after comments
                      && peekNextChar() != ' '
                      && !isBracketType(previousBracketType,  DEFINITION_TYPE))
                     && !isBracketType(bracketTypeStack->back(),  DEFINITION_TYPE)))
                 && isOkToBreakBlock(bracketTypeStack->back()))
                 // check for array
                 || (isBracketType(bracketTypeStack->back(), ARRAY_TYPE)
                     && !isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE)
                     && isNonInStatementArray))
         {
             isCharImmediatelyPostOpenBlock = (previousCommandChar == '{');
             isCharImmediatelyPostCloseBlock = (previousCommandChar == '}');
 
             if (isCharImmediatelyPostOpenBlock
                     && !isCharImmediatelyPostComment
                     && !isCharImmediatelyPostLineComment)
             {
                 previousCommandChar = ' ';
 
                 if (bracketFormatMode == NONE_MODE)
                 {
                     if (shouldBreakOneLineBlocks
                             && isBracketType(bracketTypeStack->back(),  SINGLE_LINE_TYPE))
                         isInLineBreak = true;
                     else if (currentLineBeginsWithBracket)
                         formatRunIn();
                     else
                         breakLine();
                 }
                 else if (bracketFormatMode == HORSTMANN_MODE
                          && currentChar != '#')
                     formatRunIn();
                 else
                     isInLineBreak = true;
             }
             else if (isCharImmediatelyPostCloseBlock
                      && shouldBreakOneLineStatements
                      && (isLegalNameChar(currentChar) && currentChar != '.')
                      && !isCharImmediatelyPostComment)
             {
                 previousCommandChar = ' ';
                 isInLineBreak = true;
             }
         }
 
         // reset block handling flags
         isImmediatelyPostEmptyBlock = false;
 
         // look for headers
         bool isPotentialHeader = isCharPotentialHeader(currentLine, charNum);
 
         if (isPotentialHeader && !isInTemplate)
         {
             isNonParenHeader = false;
             foundClosingHeader = false;
             newHeader = findHeader(headers);
 
             if (newHeader != NULL)
             {
                 char peekChar = ASBase::peekNextChar(currentLine, charNum + newHeader->length() - 1);
 
                 // is not a header if part of a definition
                 if (peekChar == ',' || peekChar == ')')
                     newHeader = NULL;
                 // the following accessor definitions are NOT headers
                 // goto default; is NOT a header
                 else if ((newHeader == &AS_GET || newHeader == &AS_SET || newHeader == &AS_DEFAULT)
                          && peekChar == ';')
                 {
                     newHeader = NULL;
                 }
             }
 
             if (newHeader != NULL)
             {
                 const string *previousHeader;
 
                 // recognize closing headers of do..while, if..else, try..catch..finally
                 if ((newHeader == &AS_ELSE && currentHeader == &AS_IF)
                         || (newHeader == &AS_WHILE && currentHeader == &AS_DO)
                         || (newHeader == &AS_CATCH && currentHeader == &AS_TRY)
                         || (newHeader == &AS_CATCH && currentHeader == &AS_CATCH)
                         || (newHeader == &AS_FINALLY && currentHeader == &AS_TRY)
                         || (newHeader == &AS_FINALLY && currentHeader == &AS_CATCH)
                         || (newHeader == &AS_SET && currentHeader == &AS_GET)
                         || (newHeader == &AS_REMOVE && currentHeader == &AS_ADD))
                     foundClosingHeader = true;
 
                 previousHeader = currentHeader;
                 currentHeader = newHeader;
                 needHeaderOpeningBracket = true;
 
                 if (foundClosingHeader && previousNonWSChar == '}')
                 {
                     if (isOkToBreakBlock(bracketTypeStack->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) != NULL;
 
                 // join 'else if' statements
                 if (currentHeader == &AS_IF && previousHeader == &AS_ELSE && isInLineBreak
                         && !shouldBreakElseIfs && !isCharImmediatelyPostLineComment)
                 {
                     // 'else' must be last thing on the line, but must not be #else
                     size_t start = formattedLine.length() >= 6 ? formattedLine.length()-6 : 0;
                     if (formattedLine.find("else", start) != string::npos
                             && formattedLine.find("#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 C# 'catch' can be either a paren or non-paren header
                 if (shouldPadHeader
                         && (!isNonParenHeader || (currentHeader == &AS_CATCH && peekNextChar() == '('))
                         && charNum < (int) currentLine.length() && !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 (!(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(bracketTypeStack->back()))
                 {
                     if (previousHeader == NULL
                             && !foundClosingHeader
                             && !isCharImmediatelyPostOpenBlock
                             && !isImmediatelyPostCommentOnly)
                     {
                         isPrependPostBlockEmptyLineRequested = true;
                     }
 
                     if (currentHeader == &AS_ELSE
                             || currentHeader == &AS_CATCH
                             || currentHeader == &AS_FINALLY
                             || foundClosingHeader)
                     {
                         isPrependPostBlockEmptyLineRequested = false;
                     }
 
                     if (shouldBreakClosingHeaderBlocks
                             && isCharImmediatelyPostCloseBlock
                             && !isImmediatelyPostCommentOnly
                             && currentHeader != &AS_WHILE)    // closing do-while block
                     {
                         isPrependPostBlockEmptyLineRequested = true;
                     }
 
                 }
 
                 continue;
             }
             else if ((newHeader = findHeader(preDefinitionHeaders)) != NULL
                      && parenStack->back() == 0)
             {
                 if (newHeader == &AS_NAMESPACE)
                     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)) != NULL)
             {
                 if (!(*newHeader == AS_CONST && previousCommandChar != ')')) // 'const' member functions is a command bracket
                     foundPreCommandHeader = true;
                 appendSequence(*newHeader);
                 goForward(newHeader->length() - 1);
 
                 continue;
             }
             else if ((newHeader = findHeader(castOperators)) != NULL)
             {
                 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 (previousNonWSChar == '}' || currentChar == ';')
         {
             if (currentChar == ';')
             {
                 if ((shouldBreakOneLineStatements
                         || isBracketType(bracketTypeStack->back(),  SINGLE_LINE_TYPE))
                         && isOkToBreakBlock(bracketTypeStack->back()))
                 {
                     passedSemicolon = true;
                 }
 
                 // append post block empty line for unbracketed header
                 if (shouldBreakBlocks && currentHeader != NULL && parenStack->back() == 0)
                 {
                     isAppendPostBlockEmptyLineRequested = true;
                 }
             }
 
             // end of block if a closing bracket was found
             // or an opening bracket was not found (';' closes)
             if (currentChar != ';'
                     || (needHeaderOpeningBracket && parenStack->back() == 0))
                 currentHeader = NULL;
 
             foundQuestionMark = false;
             foundNamespaceHeader = false;
             foundClassHeader = false;
             foundStructHeader = false;
             foundInterfaceHeader = false;
             foundPreDefinitionHeader = false;
             foundPreCommandHeader = false;
             foundCastOperator = false;
             isInPotentialCalculation = false;
             isSharpAccessor = false;
             isSharpDelegate = false;
             isInExtern = false;
             nonInStatementBracket = 0;
         }
 
         if (currentChar == ':' && shouldBreakOneLineStatements)
         {
             if (isInCase
                     && previousChar != ':'          // not part of '::'
                     && peekNextChar() != ':')       // not part of '::'
             {
                 isInCase = false;
                 passedColon = true;
             }
             else if (isCStyle()                     // for C/C++ only
                      && !foundQuestionMark          // not in a ... ? ... : ... sequence
                      && !foundPreDefinitionHeader   // not in a definition block (e.g. class foo : public bar
                      && previousCommandChar != ')'  // not immediately after closing paren of a method header, e.g. ASFormatter::ASFormatter(...) : ASBeautifier(...)
                      && previousChar != ':'         // not part of '::'
                      && peekNextChar() != ':'       // not part of '::'
                      && !isdigit(peekNextChar())    // not a bit field
                      && !isInAsm                    // not in extended assembler
                      && !isInAsmOneLine             // not in extended assembler
                      && !isInAsmBlock)              // not in extended assembler
             {
                 passedColon = true;
             }
         }
 
         if (currentChar == '?')
             foundQuestionMark = true;
 
         if (isPotentialHeader &&  !isInTemplate)
         {
             if (findKeyword(currentLine, charNum, AS_CASE)
                     || findKeyword(currentLine, charNum, AS_DEFAULT))
                 isInCase = true;
 
             if (findKeyword(currentLine, charNum, AS_NEW))
                 isInPotentialCalculation = false;
 
             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 (isCStyle() && findKeyword(currentLine, charNum, AS_EXTERN))
                 isInExtern = 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)
                         && isNextCharOpeningBracket(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);
             appendSequence(name);
             goForward(name.length() - 1);
 
             continue;
 
         }   // (isPotentialHeader &&  !isInTemplate)
 
         // determine if this is a potential calculation
 
         bool isPotentialOperator = isCharPotentialOperator(currentChar);
         newHeader = NULL;
 
         if (isPotentialOperator)
         {
             newHeader = findOperator(operators);
 
             if (newHeader != NULL)
             {
                 // 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!!!
                     if (find(assignmentOperators->begin(), assignmentOperators->end(), newHeader)
                             != assignmentOperators->end())
                     {
                         char peekedChar = peekNextChar();
                         isInPotentialCalculation = (!(newHeader == &AS_EQUAL && peekedChar == '*')
                                                     && !(newHeader == &AS_EQUAL && peekedChar == '&'));
                     }
                 }
             }
         }
 
         // process pointers and references
         // check new header to elimnate things like '&&' sequence
         if (isCStyle()
                 && (newHeader == &AS_MULT || newHeader == &AS_BIT_AND)
                 && isPointerOrReference()
                 && !isDereferenceOrAddressOf())
         {
             formatPointerOrReference();
             continue;
         }
 
         if (shouldPadOperators && newHeader != NULL)
         {
             padOperators(newHeader);
             continue;
         }
 
         // pad commas and semi-colons
         if (currentChar == ';'
                 || (currentChar == ',' && shouldPadOperators))
         {
             char nextChar = ' ';
             if (charNum + 1 < (int) currentLine.length())
                 nextChar = currentLine[charNum+1];
             if (!isWhiteSpace(nextChar)
                     && nextChar != '}'
                     && nextChar != ')'
                     && nextChar != ']'
                     && nextChar != '>'
                     && nextChar != ';'
                     && !isBeforeAnyComment()
                     /* && !(isBracketType(bracketTypeStack->back(), ARRAY_TYPE)) */
                )
             {
                 appendCurrentChar();
                 appendSpaceAfter();
                 continue;
             }
         }
 
         if ((shouldPadParensOutside || shouldPadParensInside || shouldUnPadParens)
                 && (currentChar == '(' || currentChar == ')'))
         {
             padParens();
             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();
 
     if (prependEmptyLine                // prepend a blank line before this formatted line
             && readyFormattedLineLength > 0
             && previousReadyFormattedLineLength > 0)
     {
         isLineReady = true;             // signal a waiting readyFormattedLine
         beautifiedLine = beautify("");
         previousReadyFormattedLineLength = 0;
     }
     else                                // format the current formatted line
     {
         isLineReady = false;
         horstmannIndentInStatement = horstmannIndentChars;
         beautifiedLine = beautify(readyFormattedLine);
         previousReadyFormattedLineLength = readyFormattedLineLength;
         // the enhancer is not called for new empty lines
         // or no-indent line comments
         if (!lineCommentNoBeautify)
             enhancer->enhance(beautifiedLine, isInBeautifySQL);
         horstmannIndentChars = 0;
         lineCommentNoBeautify = lineCommentNoIndent;
         lineCommentNoIndent = false;
         isInBeautifySQL = isInExecSQL;
     }
 
     prependEmptyLine = false;
     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 BracketType enum
  */
 bool ASFormatter::isBracketType(BracketType a, BracketType b) const
 {
     return ((a & b) == b);
 }
 
 /**
  * set the formatting style.
  *
  * @param mode         the formatting style.
  */
 void ASFormatter::setFormattingStyle(FormatStyle style)
 {
     formattingStyle = style;
 }
 
 /**
  * set the add brackets mode.
  * options:
  *    true     brackets added to headers for single line statements.
  *    false    brackets NOT added to headers for single line statements.
  *
  * @param mode         the bracket formatting mode.
  */
 void ASFormatter::setAddBracketsMode(bool state)
 {
     shouldAddBrackets = state;
 }
 
 /**
  * set the add one line brackets mode.
  * options:
  *    true     one line brackets added to headers for single line statements.
  *    false    one line brackets NOT added to headers for single line statements.
  *
  * @param mode         the bracket formatting mode.
  */
 void ASFormatter::setAddOneLineBracketsMode(bool state)
 {
     shouldAddBrackets = state;
     shouldAddOneLineBrackets = state;
 }
 
 /**
  * set the bracket formatting mode.
  * options:
  *
  * @param mode         the bracket formatting mode.
  */
 void ASFormatter::setBracketFormatMode(BracketMode mode)
 {
     bracketFormatMode = mode;
 }
 
 /**
  * set closing header bracket breaking mode
  * options:
  *    true     brackets just before closing headers (e.g. 'else', 'catch')
  *             will be broken, even if standard brackets are attached.
  *    false    closing header brackets will be treated as standard brackets.
  *
  * @param state         the closing header bracket breaking mode.
  */
 void ASFormatter::setBreakClosingHeaderBracketsMode(bool state)
 {
     shouldBreakClosingHeaderBrackets = 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 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 parenthesiss will be padded with spaces around them.
  *    false    statement parenthesiss 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 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 option to break/not break one-line blocks
  *
  * @param state        true = break, false = don't break.
  */
 void ASFormatter::setBreakOneLineBlocksMode(bool state)
 {
     shouldBreakOneLineBlocks = state;
 }
 
 /**
  * set option to break/not break lines consisting of multiple statements.
  *
  * @param state        true = break, false = don't break.
  */
 void ASFormatter::setSingleStatementsMode(bool state)
 {
     shouldBreakOneLineStatements = 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.
  * options:
  *
  * @param alignment    the pointer alignment.
  */
 void ASFormatter::setPointerAlignment(PointerAlign alignment)
 {
     pointerAlignment = 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 succeded to recieve 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 (shouldConvertTabs && currentChar == '\t')
             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 sequence         the sequence to append.
  * @return   whether succeded in reading the next line.
  */
 bool ASFormatter::getNextLine(bool emptyLineWasDeleted /*false*/)
 {
     if (sourceIterator->hasMoreLines())
     {
         if (appendOpeningBracket)
             currentLine = "{";      // append bracket that was removed from the previous line
         else
             currentLine = sourceIterator->nextLine(emptyLineWasDeleted);
         // reset variables for new line
         inLineNumber++;
         isInCase = false;
         isInAsmOneLine = 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;
 
         // check if is in preprocessor before line trimming
         // a blank line after a \ will remove the flag
         isImmediatelyPostPreprocessor = isInPreprocessor;
         if (previousNonWSChar != '\\'
                 || isEmptyLine(currentLine))
             isInPreprocessor = false;
 
         if (passedSemicolon)
             isInExecSQL = false;
         initNewLine();
         currentChar = currentLine[charNum];
         if (isInHorstmannRunIn && previousNonWSChar == '{')
             isInLineBreak = false;
         isInHorstmannRunIn = false;
 
         if (shouldConvertTabs && currentChar == '\t')
             convertTabToSpaces();
 
         // check for an empty line inside a command bracket.
         // if yes then read the next line (calls getNextLine recursively).
         // must be after initNewLine.
         if (shouldDeleteEmptyLines
                 && lineIsEmpty
                 && isBracketType((*bracketTypeStack)[bracketTypeStack->size()-1], COMMAND_TYPE))
         {
             // but do NOT delete an empty line between comments if blocks are being broken
             if (!(shouldBreakBlocks || shouldBreakClosingHeaderBlocks)
                     || !isImmediatelyPostCommentOnly
                     || !commentAndHeaderFollows())
             {
                 isInPreprocessor = isImmediatelyPostPreprocessor;       // restore
                 lineIsEmpty = false;
                 return getNextLine(true);
             }
         }
 
         return true;
     }
     else
     {
         endOfCodeReached = true;
         return false;
     }
 }
 
 /**
  * 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 indent = getIndentLength();
     charNum = 0;
 
     if (isInPreprocessor || isInQuoteContinuation)
         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 = indent - ((tabCount + i) % indent);
                 currentLine.replace(i, 1, numSpaces, ' ');
                 tabCount++;
                 i += indent - 1;
             }
         }
         // correct the format if EXEC SQL is not a hanging indent
         if (i < leadingSpaces)
             currentLine.insert((size_t)0, leadingSpaces - i, ' ');
         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;
     lineIsLineCommentOnly = false;
     lineEndsInCommentOnly = false;
     doesLineStartComment = false;
     currentLineBeginsWithBracket = false;
     lineIsEmpty = false;
     currentLineFirstBracketNum = string::npos;
     tabIncrementIn = 0;
 
     for (charNum = 0; isWhiteSpace(currentLine[charNum]) && charNum + 1 < (int) len; charNum++)
     {
         if (currentLine[charNum] == '\t')
             tabIncrementIn += indent - 1 - ((tabIncrementIn + charNum) % indent);
     }
     leadingSpaces = charNum + tabIncrementIn;
 
     if (isSequenceReached("/*"))
     {
         doesLineStartComment = true;
     }
     else if (isSequenceReached("//"))
     {
         lineIsLineCommentOnly = true;
     }
     else if (isSequenceReached("{"))
     {
         currentLineBeginsWithBracket = true;
         currentLineFirstBracketNum = 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; isWhiteSpace(currentLine[j]) && j < firstText; j++)
                 {
                     if (currentLine[j] == '\t')
                         tabIncrementIn += indent - 1 - ((tabIncrementIn + j) % indent);
                 }
                 leadingSpaces = j + tabIncrementIn;
                 if (currentLine.compare(firstText, 2, "/*") == 0)
                     doesLineStartComment = true;
             }
         }
     }
     else if (isWhiteSpace(currentLine[charNum]) && !(charNum + 1 < (int) currentLine.length()))
     {
         lineIsEmpty = true;
     }
 }
 
 /**
  * append a string sequence to the current formatted line.
  * Unless disabled (via canBreakLine == false), first check if a
  * line-break has been registered, and if so break the
  * formatted line, and only then append the sequence into
  * the next formatted line.
  *
  * @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);
 }
 
 /**
  * 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++;
     }
 }
 
 /**
  * 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++;
     }
 }
 
 /**
  * register a line break for the formatted line.
  */
 void ASFormatter::breakLine()
 {
     isLineReady = true;
     isInLineBreak = false;
     spacePadNum = nextLineSpacePadNum;
     nextLineSpacePadNum = 0;
     formattedLineCommentNum = string::npos;
 
     // queue an empty line prepend request if one exists
     prependEmptyLine = isPrependPostBlockEmptyLineRequested;
 
     readyFormattedLine =  formattedLine;
     if (isAppendPostBlockEmptyLineRequested)
     {
         isAppendPostBlockEmptyLineRequested = false;
         isPrependPostBlockEmptyLineRequested = true;
     }
     else
     {
         isPrependPostBlockEmptyLineRequested = false;
     }
 
     formattedLine = "";
 }
 
 /**
  * check if the currently reached open-bracket (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 bracket.
  *
  * @return    the type of the opened block.
  */
 BracketType ASFormatter::getBracketType()
 {
     assert(currentChar == '{');
 
     BracketType returnVal;
 
     if ((previousNonWSChar == '='
             || isBracketType(bracketTypeStack->back(),  ARRAY_TYPE))
             && previousCommandChar != ')')
         returnVal = ARRAY_TYPE;
     else if (foundPreDefinitionHeader)
     {
         returnVal = DEFINITION_TYPE;
         if (foundNamespaceHeader)
             returnVal = (BracketType)(returnVal | NAMESPACE_TYPE);
         else if (foundClassHeader)
             returnVal = (BracketType)(returnVal | CLASS_TYPE);
         else if (foundStructHeader)
             returnVal = (BracketType)(returnVal | STRUCT_TYPE);
         else if (foundInterfaceHeader)
             returnVal = (BracketType)(returnVal | INTERFACE_TYPE);
     }
     else
     {
         bool isCommandType = (foundPreCommandHeader
                               || (currentHeader != NULL && isNonParenHeader)
                               || (previousCommandChar == ')')
                               || (previousCommandChar == ':' && !foundQuestionMark)
                               || (previousCommandChar == ';')
                               || ((previousCommandChar == '{' ||  previousCommandChar == '}')
                                   && isPreviousBracketBlockRelated)
                               || 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 (!isCommandType && isInExtern)
             returnVal = EXTERN_TYPE;
         else
             returnVal = (isCommandType ? COMMAND_TYPE : ARRAY_TYPE);
     }
 
     if (isOneLineBlockReached(currentLine, charNum))
         returnVal = (BracketType)(returnVal | SINGLE_LINE_TYPE);
 
     if (isBracketType(returnVal, ARRAY_TYPE) && isNonInStatementArrayBracket())
     {
         returnVal = (BracketType)(returnVal | ARRAY_NIS_TYPE);
         isNonInStatementArray = true;
         nonInStatementBracket = formattedLine.length() - 1;
     }
 
     return returnVal;
 }
 
 /**
  * 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 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 == '&');
 
     if (!isCStyle())
         return false;
 
     if (currentChar == '&' && previousChar == '&')
         return false;
 
     if (previousNonWSChar == '=' || isCharImmediatelyPostReturn)
         return true;
 
     if (currentHeader == &AS_CATCH)
         return true;
 
     // get the last legal word (may be a number)
     string lastWord = getPreviousWord(currentLine, charNum);
     if (lastWord.empty())
         lastWord[0] = ' ';
     char nextChar = peekNextChar();
 
     // check for preceding or following numeric values
     if (isdigit(lastWord[0])
             || isdigit(nextChar))
         return false;
 
     // checks on other chars
     if (isLegalNameChar(lastWord[0])
             && isLegalNameChar(nextChar)
             && parenStack->back() > 0)
     {
         // if followed by an assignment it is a pointer or reference
         size_t nextNum = currentLine.find_first_of("=;)", charNum + 1);
         if (nextNum != string::npos && currentLine[nextNum] == '=')
             return true;
 
         // if a function definition it is a pointer or reference
         // otherwise it is an arithmetic operator
         if (!isBracketType(bracketTypeStack->back(), COMMAND_TYPE))
             return true;
         else
             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
                  || isBracketType(bracketTypeStack->back(), DEFINITION_TYPE)
                  || (!isLegalNameChar(previousNonWSChar)
                      && !(previousNonWSChar == ')' && nextChar == '(')
                      && !(previousNonWSChar == ')' && currentChar == '*')
                      && previousNonWSChar != ']')
                 );
 
     if (!isPR)
     {
         isPR |= (!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(isPointerOrReference());
 
     if (previousNonWSChar == '='
             || previousNonWSChar == ','
             || previousNonWSChar == '.'
             || previousNonWSChar == '>'
             || previousNonWSChar == '<'
             || isCharImmediatelyPostReturn)
         return true;
 
     // check for **
     if (currentChar == '*'
             && (int) currentLine.length() > charNum
             && currentLine[charNum+1] == '*')
     {
         if (previousNonWSChar == '(')
             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"))
         return true;
 
     size_t nextChar = currentLine.find_first_not_of(" \t", charNum+1);
     if (nextChar != string::npos
             && (currentLine[nextChar] == ')'
                 || currentLine[nextChar] == '>'
                 || currentLine[nextChar] == ','))
         return false;
 
     string lastWord = getPreviousWord(currentLine, charNum);
     if (lastWord == "else" || lastWord == "delete")
         return true;
 
     bool isDA = (!(isLegalNameChar(previousNonWSChar) || previousNonWSChar == '>')
                  || !isLegalNameChar(peekNextChar())
                  || (ispunct(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 wil be deleted on the output.
  *
  * @return        whether current character is centered.
  */
 bool ASFormatter::isPointerOrReferenceCentered() const
 {
     assert(currentLine[charNum] == '*' || currentLine[charNum] == '&');
 
     int prNum = charNum;
     int lineLength = (int) currentLine.length();
     // 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 **
     if (prNum + 1 < lineLength
             && 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 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 '+' or '-' character is
  * part of an exponent, i.e. 0.2E-5.
  *
  * this method takes for granted that the current character
  * is a '+' or '-'.
  *
  * @return        whether the current '+' or '-' is in an exponent.
  */
 bool ASFormatter::isInExponent() const
 {
     assert(currentChar == '+' || currentChar == '-');
 
     int formattedLineLength = formattedLine.length();
     if (formattedLineLength >= 2)
     {
         char prevPrevFormattedChar = formattedLine[formattedLineLength - 2];
         char prevFormattedChar = formattedLine[formattedLineLength - 1];
 
         return ((prevFormattedChar == 'e' || prevFormattedChar == 'E')
                 && (prevPrevFormattedChar == '.' || isdigit(prevPrevFormattedChar)));
     }
     else
         return false;
 }
 
 /**
  * check if an array bracket should NOT have an in-statement indent
  *
  * @return        the array is non in-statement
  */
 bool ASFormatter::isNonInStatementArrayBracket() const
 {
     bool returnVal = false;
     char nextChar = peekNextChar();
     // if this opening bracket begins the line there will be no inStatement indent
     if (currentLineBeginsWithBracket
             && charNum == (int) currentLineFirstBracketNum
             && nextChar != '}')
         returnVal = true;
     // if an opening bracket 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;
 
     // trace
     //if (isNonInStatementArray)
     //  cout << traceLineNumber << " " << 'x' << endl;
     //else
     //  cout << traceLineNumber << " " << ' ' << endl
 
     return returnVal;
 }
 
 /**
  * check if a one-line bracket has been reached,
  * i.e. if the currently reached '{' character is closed
  * with a complimentry '}' elsewhere on the current line,
  *.
  * @return        has a one-line bracket been reached?
  */
 bool ASFormatter::isOneLineBlockReached(string& line, int startChar) const
 {
     assert(line[startChar] == '{');
 
     bool isInComment = false;
     bool isInQuote = false;
     int bracketCount = 1;
     int lineLength = line.length();
     char quoteChar = ' ';
 
     for (int i = startChar + 1; i < lineLength; ++i)
     {
         char 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 == '\'')
         {
             isInQuote = true;
             quoteChar = ch;
             continue;
         }
 
         if (line.compare(i, 2, "//") == 0)
             break;
 
         if (line.compare(i, 2, "/*") == 0)
         {
             isInComment = true;
             ++i;
             continue;
         }
 
         if (ch == '{')
             ++bracketCount;
         else if (ch == '}')
             --bracketCount;
 
         if (bracketCount == 0)
             return true;
     }
 
     return false;
 }
 
 /**
  * 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       char 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 bracket.
  * will look ahead in the input file if necessary.
  * this determines a java static constructor.
  *
  * @param       char position on currentLine to start the search
  * @return      true if the next word is an opening bracket.
  */
 bool ASFormatter::isNextCharOpeningBracket(int startChar) const
 {
     bool retVal = false;
     string nextText = peekNextText(currentLine.substr(startChar));
     if (nextText.compare(0, 1, "{") == 0)
         retVal = true;
     return retVal;
 }
 
 /**
  * get the next non-whitespace substring on following lines, bypassing all comments.
  *
  * @param   the first line to check
  * @return  the next non-whitespace substring.
  */
 string ASFormatter::peekNextText(const string& firstLine, bool endOnEmptyLine /*false*/) const
 {
     bool isFirstLine = true;
     bool needReset = false;
     string nextLine = firstLine;
     size_t firstChar= string::npos;
 
     // find the first non-blank text, bypassing all comments.
     bool isInComment = false;
     while (sourceIterator->hasMoreLines())
     {
         if (isFirstLine)
             isFirstLine = false;
         else
         {
             nextLine = sourceIterator->peekNextLine();
             needReset = true;
         }
 
         firstChar = nextLine.find_first_not_of(" \t");
         if (firstChar == string::npos)
         {
             if (endOnEmptyLine && !isInComment)
                 break;
             continue;
         }
 
         if (nextLine.compare(firstChar, 2, "/*") == 0)
             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 (needReset)
         sourceIterator->peekReset();
     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(void)
 {
     assert(spacePadNum != 0);
     assert(currentLine.compare(charNum, 2, "//") == 0
            || currentLine.compare(charNum, 2, "/*") == 0);
 
 
     // block comment must be closed on this line with nothing after it
     if (currentLine.compare(charNum, 2, "/*") == 0)
     {
         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 bracket inside the end of line comments
  * currentChar contains the bracket, it will be appended to formattedLine
  * formattedLineCommentNum is the comment location on formattedLine
  * returns true f appended, false if not
  */
 void ASFormatter::appendCharInsideComments(void)
 {
     if (formattedLineCommentNum == string::npos)    // does the comment start on the previous line?
     {
         appendCurrentChar();                        // don't attach
         return; // false;
     }
     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)                // is the previous line comment only?
     {
         appendCurrentChar();                // don't attach
         return; // false;
     }
     beg++;
 
     // insert the bracket
     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;
 
     if (isBeforeComment())
         breakLine();
     else if (isCharImmediatelyPostLineComment)
         shouldBreakLineAtNextChar = true;
     return; // true;
 }
 
 /**
  * add or remove space padding to operators
  * currentChar contains the paren
  * 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(newOperator != NULL);
 
     bool shouldPad = (newOperator != &AS_COLON_COLON
                       && newOperator != &AS_PAREN_PAREN
                       && newOperator != &AS_BLPAREN_BLPAREN
                       && newOperator != &AS_PLUS_PLUS
                       && newOperator != &AS_MINUS_MINUS
                       && newOperator != &AS_NOT
                       && newOperator != &AS_BIT_NOT
                       && newOperator != &AS_ARROW
                       && !(newOperator == &AS_MINUS && isInExponent())
                       && !((newOperator == &AS_PLUS || newOperator == &AS_MINUS)  // check for unary plus or minus
                            && (previousNonWSChar == '('
                                || previousNonWSChar == '='
                                || previousNonWSChar == ','))
                       && !(newOperator == &AS_PLUS && isInExponent())
                       && !isCharImmediatelyPostOperator
                       && !((newOperator == &AS_MULT || newOperator == &AS_BIT_AND)
                            && isPointerOrReference())
                       && !(newOperator == &AS_MULT
                            && (previousNonWSChar == '.'
                                || previousNonWSChar == '>'))    // check for ->
                       && !((isInTemplate || isCharImmediatelyPostTemplate)
                            && (newOperator == &AS_LS || newOperator == &AS_GR))
                       && !(newOperator == &AS_GCC_MIN_ASSIGN
                            && ASBase::peekNextChar(currentLine, charNum+1) == '>')
                       && !(newOperator == &AS_GR && previousNonWSChar == '?')
                       && !isInCase
                       && !isInAsm
                       && !isInAsmOneLine
                       && !isInAsmBlock
                      );
 
     // pad before operator
     if (shouldPad
             && !isInBlParen
             && !(newOperator == &AS_COLON && !foundQuestionMark)
             && !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?)
                  && currentLine.find(':', charNum+1) == string::npos)
        )
         appendSpacePad();
     appendSequence(*newOperator);
     goForward(newOperator->length() - 1);
 
     // since this block handles '()' and '[]',
     // the parenStack must be updated here accordingly!
     if (newOperator == &AS_PAREN_PAREN
             || newOperator == &AS_BLPAREN_BLPAREN)
         parenStack->back()--;
 
     currentChar = (*newOperator)[newOperator->length() - 1];
     // pad after operator
     // but do not pad after a '-' that is a unary-minus.
     if (shouldPad
             && !isInBlParen
             && !isBeforeAnyComment()
             && !(newOperator == &AS_PLUS && isUnaryOperator())
             && !(newOperator == &AS_MINUS && isUnaryOperator())
             && !(currentLine.compare(charNum + 1, 1,  ";") == 0)
             && !(currentLine.compare(charNum + 1, 2, "::") == 0)
             && !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?)
                  && currentLine[charNum+1] == '[')
        )
         appendSpaceAfter();
 
     previousOperator = newOperator;
     return;
 }
 
 /**
  * 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
  */
 void ASFormatter::formatPointerOrReference(void)
 {
     assert(currentChar == '*' || currentChar == '&');
     assert(isCStyle());
 
     // check for cast
     char peekedChar = peekNextChar();
     if (currentChar == '*'
             && (int) currentLine.length() > charNum
             && currentLine[charNum+1] == '*')
     {
         size_t nextChar = currentLine.find_first_not_of(" \t", charNum+2);
         if (nextChar == string::npos)
             peekedChar = ' ';
         else
             peekedChar = currentLine[nextChar];
     }
     if (peekedChar == ')' || peekedChar =='>' || peekedChar ==',')
     {
         formatPointerOrReferenceCast();
         return;
     }
 
     // do this before bumping charNum
     bool isOldPRCentered = isPointerOrReferenceCentered();
 
     if (pointerAlignment == ALIGN_TYPE)
     {
         size_t prevCh = formattedLine.find_last_not_of(" \t");
         if (prevCh == string::npos)
             prevCh = 0;
         if (formattedLine.length() == 0 || prevCh == formattedLine.length() - 1)
             appendCurrentChar();
         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("**"))
         {
             formattedLine.insert(prevCh+2, "*");
             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--;
         }
     }
     else if (pointerAlignment == ALIGN_MIDDLE)
     {
         // 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;
         // adjust for **
         string sequenceToInsert = currentChar == '*' ? "*" : "&";
         if (isSequenceReached("**"))
         {
             sequenceToInsert = "**";
             goForward(1);
         }
         size_t charNumSave = 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++)
         {
             goForward(1);
             formattedLine.append(1, currentLine[i]);
         }
         // whitespace should be at least 2 chars
         size_t wsAfter = currentLine.find_first_not_of(" \t", charNumSave + 1);
         if (wsAfter == string::npos)
             wsAfter = 0;
         else
             wsAfter = wsAfter - charNumSave - 1;
         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;
         formattedLine.insert(formattedLine.length() - padAfter, sequenceToInsert);
     }
     else if (pointerAlignment == ALIGN_NAME)
     {
         size_t startNum = formattedLine.find_last_not_of(" \t");
         string sequenceToInsert = currentChar == '*' ? "*" : "&";
         if (isSequenceReached("**"))
         {
             sequenceToInsert = "**";
             goForward(1);
         }
         // 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);
             formattedLine.append(1, currentLine[i]);
         }
         appendSequence(sequenceToInsert, false);
         // if no space before * then add one
         if (startNum != string::npos
                 && !isWhiteSpace(formattedLine[startNum+1]))
         {
             formattedLine.insert(startNum+1 , 1, ' ');
             spacePadNum++;
         }
         // if old pointer or reference is centered, remove a space
         if (isOldPRCentered
                 && formattedLine.length() > startNum+1
                 && isWhiteSpace(formattedLine[startNum+1]))
         {
             formattedLine.erase(startNum+1, 1);
             spacePadNum--;
         }
     }
     else    // pointerAlignment == ALIGN_NONE
     {
         appendCurrentChar();
     }
     return;
 }
 
 /**
  * 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(void)
 {
     assert(currentChar == '*' || currentChar == '&');
     assert(isCStyle());
 
     string sequenceToInsert = currentChar == '*' ? "*" : "&";
     if (isSequenceReached("**"))
     {
         sequenceToInsert = "**";
         goForward(1);
     }
     if (pointerAlignment == ALIGN_NONE)
     {
         appendSequence(sequenceToInsert, false);
         return;
     }
     // remove trailing whitespace
     size_t prevCh = formattedLine.find_last_not_of(" \t");
     if (prevCh == string::npos)
         prevCh = 0;
     if (formattedLine.length() > 0 && isWhiteSpace(formattedLine[prevCh+1]))
     {
         spacePadNum -= (formattedLine.length() - 1 - prevCh);
         formattedLine.erase(prevCh+1);
     }
     if (pointerAlignment == ALIGN_TYPE)
     {
         appendSequence(sequenceToInsert, false);
     }
     else if (pointerAlignment == ALIGN_MIDDLE
              || pointerAlignment == ALIGN_NAME)
     {
         appendSpacePad();
         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(void)
 {
     assert(currentChar == '(' || currentChar == ')');
 
     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 bracket the previous whitespace is an indent
                 if (formattedLine[i] == '{')
                     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 = NULL;
                     if (shouldPadHeader
                             && prevWord.length() > 0
                             && isCharPotentialHeader(prevWord, 0))
                         prevWordH = ASBeautifier::findHeader(prevWord, 0, headers);
                     if (prevWordH != NULL)
                     {
                         prevIsParenHeader = true;
                         // trace
                         //cout << traceLineNumber << " " << *prevWordH << endl;
                     }
                     else if (prevWord == "return"   // don't unpad return statements
                              || prevWord == "*")    // don't unpad multiply or pointer
                     {
                         prevIsParenHeader = true;
                         // trace
                         //cout << traceLineNumber << " " << prevWord << endl;
                     }
                     // don't unpad variables
                     else if (prevWord == "bool"
                              || prevWord ==  "int"
                              || prevWord ==  "void"
                              || prevWord ==  "void*"
                              || (prevWord.length() >= 6     // check end of word for _t
                                  && prevWord.compare(prevWord.length()-2, 2, "_t") == 0)
                              || prevWord ==  "BOOL"
                              || prevWord ==  "DWORD"
                              || prevWord ==  "HWND"
                              || prevWord ==  "INT"
                              || prevWord ==  "LPSTR"
                              || prevWord ==  "VOID"
                              || prevWord ==  "LPVOID"
                             )
                     {
                         prevIsParenHeader = true;
                         // trace
                         //cout << traceLineNumber << " " << prevWord << endl;
                     }
                 }
             }
             // do not unpad operators, but leave them if already padded
             if (shouldPadParensOutside || prevIsParenHeader)
                 spacesOutsideToDelete--;
             else if (lastChar == '|'          // check for ||
                      || lastChar == '&'      // check for &&
                      || lastChar == ','
                      || (lastChar == '>' && !foundCastOperator)
                      || lastChar == '<'
                      || lastChar == '?'
                      || lastChar == ':'
                      || lastChar == ';'
                      || lastChar == '='
                      || lastChar == '+'
                      || lastChar == '-'
                      || (lastChar == '*' && isInPotentialCalculation)
                      || lastChar == '/'
                      || lastChar == '%')
                 spacesOutsideToDelete--;
 
             if (spacesOutsideToDelete > 0)
             {
                 formattedLine.erase(i + 1, spacesOutsideToDelete);
                 spacePadNum -= spacesOutsideToDelete;
             }
         }
 
         // pad open paren outside
         char peekedCharOutside = peekNextChar();
         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
                     && currentLine[charNum+1] == '\t')
                 currentLine[charNum+1] = ' ';
 
         }
 
         // pad open paren inside
         char peekedCharInside = peekNextChar();
         if (shouldPadParensInside)
             if (!(currentChar == '(' && peekedCharInside == ')'))
                 appendSpaceAfter();
         // trace
         //if(spacesOutsideToDelete > 0 || spacesInsideToDelete > 0)
         //    cout << traceLineNumber << " " << spacesOutsideToDelete << '(' << spacesInsideToDelete << endl;
     }
     else if (currentChar == ')' /*|| currentChar == ']'*/)
     {
         spacesOutsideToDelete = 0;
         spacesInsideToDelete = formattedLine.length();
 
         // unpad close paren inside
         if (shouldUnPadParens)
         {
             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
         if (shouldUnPadParens)
         {
             // may have end of line comments
             size_t j = currentLine.find_first_not_of(" \t", charNum + 1);
             if (j != string::npos)
                 if (currentLine[j] == '[' || currentLine[j] == ']')
                     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 ->
                 appendSpaceAfter();
 
         // trace
         //if(spacesInsideToDelete > 0)
         //  cout << traceLineNumber << " " << spacesInsideToDelete << ')' << 0 << endl;
     }
     return;
 }
 
 /**
  * format opening bracket as attached or broken
  * currentChar contains the bracket
  * the brackets 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 bracketType    the type of bracket to be formatted.
  */
 void ASFormatter::formatOpeningBracket(BracketType bracketType)
 {
     assert(!isBracketType(bracketType, ARRAY_TYPE));
     assert(currentChar == '{');
 
     parenStack->push_back(0);
 
     bool breakBracket = isCurrentBracketBroken();
 
     if (breakBracket)
     {
         if (isBeforeAnyComment() && isOkToBreakBlock(bracketType))
         {
             // if comment is at line end leave the comment on this line
             if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBracket)    // lineBeginsWith('{')
             {
                 currentChar = ' ';              // remove bracket from current line
                 currentLine[charNum] = currentChar;
                 appendOpeningBracket = true;    // append bracket to following line
             }
             // else put comment after the bracket
             else if (!isBeforeMultipleLineEndComments(charNum))
                 breakLine();
         }
         else if (!isBracketType(bracketType, SINGLE_LINE_TYPE))
             breakLine();
         else if (shouldBreakOneLineBlocks && peekNextChar() != '}')
             breakLine();
         else if (!isInLineBreak)
             appendSpacePad();
 
         appendCurrentChar();
 
         // should a following comment break from the bracket?
         // must break the line AFTER the bracket
         if (isBeforeComment()
                 && formattedLine[0] == '{'
                 && isOkToBreakBlock(bracketType)
                 && (bracketFormatMode == BREAK_MODE
                     || bracketFormatMode == LINUX_MODE
                     || bracketFormatMode == STROUSTRUP_MODE))
         {
             shouldBreakLineAtNextChar = true;
         }
 
     }
     else    // attach bracket
     {
         // are there comments before the bracket?
         if (isCharImmediatelyPostComment || isCharImmediatelyPostLineComment)
         {
             if (isOkToBreakBlock(bracketType)
                     && !(isCharImmediatelyPostComment && isCharImmediatelyPostLineComment)  // don't attach if two comments on the line
                     && peekNextChar() != '}'        // don't attach { }
                     && previousCommandChar != '{'   // don't attach { {
                     && previousCommandChar != '}'   // don't attach } {
                     && previousCommandChar != ';')  // don't attach ; {
             {
                 appendCharInsideComments();
             }
             else
             {
                 appendCurrentChar();            // don't attach
             }
         }
         else if (previousCommandChar == '{'
                  || previousCommandChar == '}'
                  || previousCommandChar == ';')  // '}' , ';' chars added for proper handling of '{' immediately after a '}' or ';'
         {
             appendCurrentChar();                // don't attach
         }
         else
         {
             // if a blank line preceeds this don't attach
             if (isEmptyLine(formattedLine))
                 appendCurrentChar();            // don't attach
             else if (isOkToBreakBlock(bracketType)
                      && !(isImmediatelyPostPreprocessor
                           && currentLineBeginsWithBracket))     // lineBeginsWith('{')
             {
                 if (peekNextChar() != '}')
                 {
                     appendSpacePad();
                     appendCurrentChar(false);       // OK to attach
                     // should a following comment attach with the bracket?
                     // insert spaces to reposition the comment
                     if (isBeforeComment()
                             && !isBeforeMultipleLineEndComments(charNum)
                             && (!isBeforeAnyLineEndComment(charNum) || currentLineBeginsWithBracket))   // lineBeginsWith('{')
                     {
                         breakLine();
                         currentLine.insert(charNum+1, charNum+1, ' ');
                     }
                 }
                 else
                 {
                     appendSpacePad();
                     appendCurrentChar();
                 }
             }
             else
             {
                 if (!isInLineBreak)
                     appendSpacePad();
                 appendCurrentChar();            // don't attach
             }
         }
     }
 }
 
 /**
  * format closing bracket
  * currentChar contains the bracket
  * the calling function should have a continue statement after calling this method
  *
  * @param bracketType    the type of bracket to be formatted.
  */
 void ASFormatter::formatClosingBracket(BracketType bracketType)
 {
     assert(!isBracketType(bracketType, 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 brackets that appear immedately AFTER an empty block (e.g. '{} \n}').
     if (previousCommandChar == '{')
         isImmediatelyPostEmptyBlock = true;
 
     if ((!(previousCommandChar == '{' && isPreviousBracketBlockRelated))    // this '{' does not close an empty block
             && isOkToBreakBlock(bracketType)                                // astyle is allowed to break on line blocks
             && !isImmediatelyPostEmptyBlock)                                // this '}' does not immediately follow an empty block
     {
         breakLine();
         appendCurrentChar();
     }
     else
     {
         appendCurrentChar();
     }
 
     // if a declaration follows a definition, space pad
     if (isLegalNameChar(peekNextChar()))
         appendSpaceAfter();
 
     if (shouldBreakBlocks && currentHeader != NULL && parenStack->back() == 0)
     {
         isAppendPostBlockEmptyLineRequested = true;
     }
 }
 
 /**
  * format array brackets as attached or broken
  * determine if the brackets can have an inStatement indent
  * currentChar contains the bracket
  * the brackets 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 bracketType            the type of bracket to be formatted, must be an ARRAY_TYPE.
  * @param isOpeningArrayBracket  indicates if this is the opening bracket for the array block.
  */
 void ASFormatter::formatArrayBrackets(BracketType bracketType, bool isOpeningArrayBracket)
 {
     assert(isBracketType(bracketType, ARRAY_TYPE));
     assert(currentChar == '{' || currentChar == '}');
 
     if (currentChar == '{')
     {
         // is this the first opening bracket in the array?
         if (isOpeningArrayBracket)
         {
             if (bracketFormatMode == ATTACH_MODE
                     || bracketFormatMode == LINUX_MODE
                     || bracketFormatMode == STROUSTRUP_MODE)
             {
                 // don't attach to a preprocessor directive
                 if (isImmediatelyPostPreprocessor && currentLineBeginsWithBracket)  // lineBeginsWith('{')
                 {
                     isInLineBreak = true;
                     appendCurrentChar();                // don't attach
                 }
                 else if (isCharImmediatelyPostComment)
                 {
                     // TODO: attach bracket to line-end comment
                     appendCurrentChar();                // don't attach
                 }
                 else if (isCharImmediatelyPostLineComment)
                 {
                     appendCharInsideComments();
                 }
                 else
                 {
                     // if a blank line preceeds this don't attach
                     if (isEmptyLine(formattedLine))
                         appendCurrentChar();            // don't attach
                     else
                     {
                         // if bracket is broken or not an assignment
                         if (currentLineBeginsWithBracket    // lineBeginsWith('{')
                                 && !isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE))
                         {
                             appendSpacePad();
                             appendCurrentChar(false);       // OK to attach
 
                             if (currentLineBeginsWithBracket
                                     && (int)currentLineFirstBracketNum == charNum)
                                 shouldBreakLineAtNextChar = true;
                         }
                         else
                         {
                             appendSpacePad();
                             appendCurrentChar();
                         }
                     }
                 }
             }
             else if (bracketFormatMode == BREAK_MODE)
             {
                 if (isWhiteSpace(peekNextChar()))
                     breakLine();
                 else if (isBeforeAnyComment())
                 {
                     // do not break unless comment is at line end
                     if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBracket)
                     {
                         currentChar = ' ';              // remove bracket from current line
                         appendOpeningBracket = true;    // append bracket to following line
                     }
                 }
                 if (!isInLineBreak)
                     appendSpacePad();
                 appendCurrentChar();
 
                 if (currentLineBeginsWithBracket
                         && (int)currentLineFirstBracketNum == charNum
                         && !isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE))
                     shouldBreakLineAtNextChar = true;
             }
             else if (bracketFormatMode == HORSTMANN_MODE)
             {
                 if (isWhiteSpace(peekNextChar()))
                     breakLine();
                 else if (isBeforeAnyComment())
                 {
                     // do not break unless comment is at line end
                     if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBracket)    // lineBeginsWith('{')
                     {
                         currentChar = ' ';              // remove bracket from current line
                         appendOpeningBracket = true;    // append bracket to following line
                     }
                 }
                 if (!isInLineBreak)
                     appendSpacePad();
                 appendCurrentChar();
             }
             else if (bracketFormatMode == NONE_MODE)
             {
                 if (currentLineBeginsWithBracket)       // lineBeginsWith('{')
                 {
                     appendCurrentChar();                // don't attach
                 }
                 else
                 {
                     appendSpacePad();
                     appendCurrentChar(false);           // OK to attach
                 }
             }
         }
         else         // not the first opening bracket
         {
             if (bracketFormatMode == HORSTMANN_MODE)
             {
                 if (previousNonWSChar == '{'
                         && bracketTypeStack->size() > 2
                         && !isBracketType((*bracketTypeStack)[bracketTypeStack->size()-2], SINGLE_LINE_TYPE))
                     formatArrayRunIn();
             }
             else if (!isInLineBreak
                      && !isWhiteSpace(peekNextChar())
                      && previousNonWSChar == '{'
                      && bracketTypeStack->size() > 2
                      && !isBracketType((*bracketTypeStack)[bracketTypeStack->size()-2], SINGLE_LINE_TYPE))
                 formatArrayRunIn();
 
             appendCurrentChar();
         }
     }
     else if (currentChar == '}')
     {
         // does this close the first opening bracket in the array?
         if (!isBracketType(bracketType, SINGLE_LINE_TYPE) )
             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(bracketFormatMode == HORSTMANN_MODE || bracketFormatMode == NONE_MODE);
 
     // keep one line blocks returns true without indenting the run-in
     if (!isOkToBreakBlock(bracketTypeStack->back()))
         return; // true;
 
     size_t lastText = formattedLine.find_last_not_of(" \t");
     if (lastText == string::npos || formattedLine[lastText] != '{')
         return; // false;
 
     // make sure the bracket is broken
     if (formattedLine.find_first_not_of(" \t{") != string::npos)
         return; // false;
 
     if (isBracketType(bracketTypeStack->back(), NAMESPACE_TYPE))
         return; // false;
 
     bool extraIndent = false;
     isInLineBreak = true;
 
     // cannot attach a class modifier without indent-classes
     if (isCStyle()
             && isCharPotentialHeader(currentLine, charNum)
             && (isBracketType(bracketTypeStack->back(), CLASS_TYPE)
                 || (isBracketType(bracketTypeStack->back(), STRUCT_TYPE)
                     && isInIndentableStruct)))
     {
         if (findKeyword(currentLine, charNum, AS_PUBLIC)
                 || findKeyword(currentLine, charNum, AS_PRIVATE)
                 || findKeyword(currentLine, charNum, AS_PROTECTED))
         {
             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()
             && !preBracketHeaderStack->empty()
             && preBracketHeaderStack->back() == &AS_SWITCH
             && ((isLegalNameChar(currentChar)
                  && !findKeyword(currentLine, charNum, AS_CASE))
                 || isSequenceReached("//")
                 || isSequenceReached("/*")))
         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 (getIndentString() == "\t")
     {
         appendChar('\t', false);
         horstmannIndentChars = 2;   // one for { and one for tab
         if (extraIndent)
         {
             appendChar('\t', false);
             horstmannIndentChars++;
         }
     }
     else
     {
         int indent = getIndentLength();
         formattedLine.append(indent-1, ' ');
         horstmannIndentChars = indent;
         if (extraIndent)
         {
             formattedLine.append(indent, ' ');
             horstmannIndentChars += indent;
         }
     }
     isInHorstmannRunIn = true;
 }
 
 /**
  * remove whitepace and add indentation for an array run-in.
  */
 void ASFormatter::formatArrayRunIn()
 {
     assert(isBracketType(bracketTypeStack->back(), ARRAY_TYPE));
 
     // make sure the bracket 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);
         horstmannIndentChars = 2;   // one for { and one for tab
     }
     else
     {
         int indent = getIndentLength();
         formattedLine.append(indent-1, ' ');
         horstmannIndentChars = indent;
     }
     isInHorstmannRunIn = true;
     isInLineBreak = false;
 }
 
 /**
  * delete a bracketTypeStack vector object
  * BracketTypeStack did not work with the DeleteContainer template
  */
 void ASFormatter::deleteContainer(vector<BracketType>* &container)
 {
     if (container != NULL)
     {
         container->clear();
         delete (container);
         container = NULL;
     }
 }
 
 /**
  * delete a vector object
  * T is the type of vector
  * used for all vectors except bracketTypeStack
  */
 template<typename T>
 void ASFormatter::deleteContainer(T &container)
 {
     if (container != NULL)
     {
         container->clear();
         delete (container);
         container = NULL;
     }
 }
 
 /**
  * initialize a BracketType vector object
  * BracketType did not work with the DeleteContainer template
  */
 void ASFormatter::initContainer(vector<BracketType>* &container, vector<BracketType>* value)
 {
     if (container != NULL)
         deleteContainer(container);
     container = value;
 }
 
 /**
  * initialize a vector object
  * T is the type of vector
  * used for all vectors except bracketTypeStack
  */
 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 != NULL)
         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(currentLine[charNum] == '\t');
 
     // do NOT replace if in quotes
     if (isInQuote || isInQuoteContinuation)
         return;
 
     size_t indent = getIndentLength();
     size_t numSpaces = indent - ((tabIncrementIn + charNum) % indent);
     currentLine.replace(charNum, 1, numSpaces, ' ');
     currentChar = currentLine[charNum];
 }
 
 /**
 * is it ok to break this block?
 */
 bool ASFormatter::isOkToBreakBlock(BracketType bracketType) const
 {
     // Actually, there should not be an ARRAY_TYPE bracket here.
     // But this will avoid breaking a one line block when there is.
     // Otherwise they will be formatted differently on consecutive runs.
     if (isBracketType(bracketType, ARRAY_TYPE)
             && isBracketType(bracketType, SINGLE_LINE_TYPE))
         return false;
     if (!isBracketType(bracketType, SINGLE_LINE_TYPE)
             || shouldBreakOneLineBlocks
             || breakCurrentOneLineBlock)
         return true;
     return false;
 }
 
 /**
 * check if a sharp header is a paren or nonparen header
 */
 bool ASFormatter::isSharpStyleWithParen(const string* header) const
 {
     if (isSharpStyle() && peekNextChar() == '('
             && (header == &AS_CATCH
                 || header == &AS_DELEGATE))
         return true;
     return false;
 }
 
 /**
  * check for a following header when a comment is reached.
  * if a header follows, the comments are kept as part of the header block.
  * firstLine must contain the start of the comment.
  */
 void ASFormatter::checkForFollowingHeader(const string& firstLine)
 {
     // look ahead to find the next non-comment text
     string nextText = peekNextText(firstLine, true);
     if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0))
         return;
 
     const string* newHeader = ASBeautifier::findHeader(nextText, 0, headers);
 
     if (newHeader == NULL)
         return;
 
     // may need to break if a header follows
     bool isClosingHeader = (newHeader == &AS_ELSE
                             || newHeader == &AS_CATCH
                             || newHeader == &AS_FINALLY);
 
     // if a closing header, reset break unless break is requested
     if (isClosingHeader)
     {
         if (!shouldBreakClosingHeaderBlocks)
             isPrependPostBlockEmptyLineRequested = false;
     }
     // if an opening header, break before the comment
     else
     {
         isPrependPostBlockEmptyLineRequested = true;
     }
 }
 
 /**
  * process preprocessor statements.
  * charNum should be the index of the preprocessor directive.
  *
  * delete bracketTypeStack entries added by #if if a #else is found.
  * prevents double entries in the bracketTypeStack.
  */
 void ASFormatter::processPreprocessor()
 {
     assert(currentChar == '#');
 
     const int preproc = charNum + 1;
 
     if (currentLine.compare(preproc, 2, "if") == 0)
     {
         preprocBracketTypeStackSize = bracketTypeStack->size();
     }
     else if (currentLine.compare(preproc, 4, "else") == 0)
     {
         // delete stack entries added in #if
         // should be replaced by #else
         if (preprocBracketTypeStackSize > 0)
         {
             int addedPreproc = bracketTypeStack->size() - preprocBracketTypeStackSize;
             for (int i=0; i < addedPreproc; i++)
                 bracketTypeStack->pop_back();
         }
     }
 }
 
 /**
  * determine if the next line starts a comment
  * and a header follows the comment or comments
  */
 bool ASFormatter::commentAndHeaderFollows() const
 {
     // is the next line a comment
     string nextLine = sourceIterator->peekNextLine();
     size_t firstChar = nextLine.find_first_not_of(" \t");
     if (firstChar == string::npos
             || !(nextLine.compare(firstChar, 2, "//") == 0
                  || nextLine.compare(firstChar, 2, "/*") == 0))
     {
         sourceIterator->peekReset();
         return false;
     }
 
     // if next line is a comment, find the next non-comment text
     string nextText = peekNextText(nextLine, true);
     if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0))
         return false;
 
     const string* newHeader = ASBeautifier::findHeader(nextText, 0, headers);
 
     if (newHeader == NULL)
         return false;
 
     bool isClosingHeader = (newHeader == &AS_ELSE
                             || newHeader == &AS_CATCH
                             || newHeader == &AS_FINALLY);
 
     if (isClosingHeader && !shouldBreakClosingHeaderBlocks)
         return false;
 
     return true;
 }
 
 /**
  * determine if a bracket should be attached or broken
  * uses brackets in the bracketTypeStack
  * the last bracket in the bracketTypeStack is the one being formatted
  * returns true if the bracket should be broken
  */
 bool ASFormatter::isCurrentBracketBroken() const
 {
     assert(bracketTypeStack->size() > 0);
 
     bool breakBracket = false;
     size_t bracketTypeStackEnd = bracketTypeStack->size()-1;
 
     if (isBracketType((*bracketTypeStack)[bracketTypeStackEnd], EXTERN_TYPE))
     {
         if (currentLineBeginsWithBracket
                 || bracketFormatMode == HORSTMANN_MODE)
             breakBracket = true;
     }
     else if (bracketFormatMode == NONE_MODE)
     {
         if (currentLineBeginsWithBracket
                 && (int)currentLineFirstBracketNum == charNum)      // lineBeginsWith('{')
             breakBracket = true;
     }
     else if (bracketFormatMode == BREAK_MODE || bracketFormatMode == HORSTMANN_MODE)
     {
         breakBracket = true;
     }
     else if (bracketFormatMode == LINUX_MODE || bracketFormatMode == STROUSTRUP_MODE)
     {
         // break a class if Linux
         if (isBracketType((*bracketTypeStack)[bracketTypeStackEnd], CLASS_TYPE))
         {
             if (bracketFormatMode == LINUX_MODE)
                 breakBracket = true;
         }
         // break a namespace or interface if Linux
         else if (isBracketType((*bracketTypeStack)[bracketTypeStackEnd], NAMESPACE_TYPE)
                  || isBracketType((*bracketTypeStack)[bracketTypeStackEnd], INTERFACE_TYPE))
         {
             if (bracketFormatMode == LINUX_MODE)
                 breakBracket = true;
         }
         // break the first bracket if a function
         else if (bracketTypeStackEnd == 1
                  && isBracketType((*bracketTypeStack)[bracketTypeStackEnd], COMMAND_TYPE))
         {
             breakBracket = true;
         }
         else if (bracketTypeStackEnd > 1)
         {
             // break the first bracket after a namespace or extern if a function
             if (isBracketType((*bracketTypeStack)[bracketTypeStackEnd-1], NAMESPACE_TYPE)
                     || isBracketType((*bracketTypeStack)[bracketTypeStackEnd-1], EXTERN_TYPE))
             {
                 if (isBracketType((*bracketTypeStack)[bracketTypeStackEnd], COMMAND_TYPE))
                     breakBracket = true;
             }
             // if not C style then break the first bracket after a class if a function
             else if (!isCStyle())
             {
                 if ((isBracketType((*bracketTypeStack)[bracketTypeStackEnd-1], CLASS_TYPE)
                         || isBracketType((*bracketTypeStack)[bracketTypeStackEnd-1], ARRAY_TYPE)
                         || isBracketType((*bracketTypeStack)[bracketTypeStackEnd-1], STRUCT_TYPE))
                         && isBracketType((*bracketTypeStack)[bracketTypeStackEnd], COMMAND_TYPE))
                     breakBracket = true;
             }
         }
     }
     return breakBracket;
 }
 
 /**
  * format comment body
  * the calling function should have a continue statement after calling this method
  */
 void ASFormatter::formatCommentBody()
 {
     assert(isInComment);
 
     if (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 != ';'
                 && !isBracketType(bracketTypeStack->back(),  ARRAY_TYPE)
                 && isOkToBreakBlock(bracketTypeStack->back()))
             breakLine();
     }
     else
     {
         appendCurrentChar();
         // append the comment up to the next tab or comment end
         // tabs must be checked for convert-tabs before appending
         while (charNum + 1 < (int) currentLine.length()
                 && currentLine[charNum+1] != '\t'
                 && currentLine.compare(charNum+1, 2, "*/") != 0)
         {
             currentChar = currentLine[++charNum];
             appendCurrentChar();
         }
     }
 }
 
 /**
  * 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 = true;
     isImmediatelyPostLineComment = false;
 
     if (spacePadNum != 0)
         adjustComments();
     formattedLineCommentNum = formattedLine.length();
 
     // must be done BEFORE appendSequence
     if (previousCommandChar == '{'
             && !isImmediatelyPostComment
             && !isImmediatelyPostLineComment)
     {
         if (bracketFormatMode == NONE_MODE)
         {
             // should a run-in statement be attached?
             if (currentLineBeginsWithBracket)
                 formatRunIn();
         }
         else if (bracketFormatMode == ATTACH_MODE)
         {
             // if the bracket was not attached?
             if (formattedLine[0] == '{'
                     && !isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE))
                 isInLineBreak = true;
         }
         else if (bracketFormatMode == HORSTMANN_MODE)
         {
             // should a run-in statement be attached?
             if (formattedLine[0] == '{')
                 formatRunIn();
         }
     }
     else if (!doesLineStartComment)
         noTrimCommentContinuation = true;
 
     // appendSequence will write the previous line
     appendSequence(AS_OPEN_COMMENT);
     goForward(1);
 
     // must be done AFTER appendSequence
     if (shouldBreakBlocks)
     {
         // break before the comment if a header follows the comment
         // for speed, do not check if previous line is empty,
         //     if previous line is a line comment or if previous line is '{'
         if (doesLineStartComment
                 && !isImmediatelyPostEmptyLine
                 && !isImmediatelyPostComment
                 && !isImmediatelyPostLineComment
                 && previousCommandChar != '{')
         {
             checkForFollowingHeader(currentLine.substr(charNum-1));
         }
     }
 
     if (previousCommandChar == '}')
         currentHeader = NULL;
 }
 
 /**
  * format a line comment body
  * the calling function should have a continue statement after calling this method
  */
 void ASFormatter::formatLineCommentBody()
 {
     assert(isInLineComment);
 
     appendCurrentChar();
     // append the comment up to the next tab
     // tabs must be checked for convert-tabs before appending
     while (charNum + 1 < (int) currentLine.length()
             && currentLine[charNum+1] != '\t')
     {
         currentChar = currentLine[++charNum];
         appendCurrentChar();
     }
 
     // explicitely 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 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 (currentLine[charNum+2] == '\xf2')       // check for windows line marker
         isAppendPostBlockEmptyLineRequested = false;
 
     isInLineComment = true;
     isCharImmediatelyPostComment = false;
 
     // do not indent if in column 1 or 2
     if (!shouldIndentCol1Comments && !lineCommentNoIndent)
     {
         if (charNum == 0)
             lineCommentNoIndent = true;
         else if (charNum == 1 && currentLine[0] == ' ')
             lineCommentNoIndent = true;
     }
     // move comment if spaces were added or deleted
     if (lineCommentNoIndent == false && spacePadNum != 0)
         adjustComments();
     formattedLineCommentNum = formattedLine.length();
 
     // must be done BEFORE appendSequence
     // check for run-in statement
     if (previousCommandChar == '{'
             && !isImmediatelyPostComment
             && !isImmediatelyPostLineComment)
     {
         if (bracketFormatMode == NONE_MODE)
         {
             if (currentLineBeginsWithBracket)
                 formatRunIn();
         }
         else if (bracketFormatMode == HORSTMANN_MODE)
         {
             if (!lineCommentNoIndent)
                 formatRunIn();
             else
                 isInLineBreak = true;
         }
         else if (bracketFormatMode == BREAK_MODE)
         {
             if (formattedLine[0] == '{')
                 isInLineBreak = true;
         }
         else
         {
             if (currentLineBeginsWithBracket)
                 isInLineBreak = true;
         }
     }
 
     // appendSequence will write the previous line
     appendSequence(AS_OPEN_LINE_COMMENT);
     goForward(1);
 
     if (formattedLine.compare(0, 2, "//") == 0)
         lineIsLineCommentOnly = true;
 
     // must be done AFTER appendSequence
     if (shouldBreakBlocks)
     {
         // break before the comment if a header follows the line comment
         // for speed, do not check if previous line is empty,
         //     if previous line is a comment or if previous line is '{'
         if (lineIsLineCommentOnly
                 && previousCommandChar != '{'
                 && !isImmediatelyPostEmptyLine
                 && !isImmediatelyPostComment
                 && !isImmediatelyPostLineComment)
         {
             checkForFollowingHeader(currentLine.substr(charNum-1));
         }
     }
 
     if (previousCommandChar == '}')
         currentHeader = NULL;
 
     // 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();
         }
     }
 
     // explicitely 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 (peekNextChar() == '"')              // check consecutive quotes
         {
             appendSequence("\"\"");
             goForward(1);
             return;
         }
         else
         {
             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();
         }
     }
 }
 
 /**
  * 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 == '\'');
 
     isInQuote = true;
     quoteChar = currentChar;
     if (isSharpStyle() && previousChar == '@')
         isInVerbatimQuote = true;
 
     // a quote following a bracket is an array
     if (previousCommandChar == '{'
             && !isImmediatelyPostComment
             && !isImmediatelyPostLineComment
             && isNonInStatementArray
             && !isBracketType(bracketTypeStack->back(), SINGLE_LINE_TYPE)
             && !isWhiteSpace(peekNextChar()))
     {
         if (bracketFormatMode == NONE_MODE)
         {
             if (currentLineBeginsWithBracket)
                 formatRunIn();
         }
         else if (bracketFormatMode == HORSTMANN_MODE)
         {
             if (!lineCommentNoIndent)
                 formatRunIn();
             else
                 isInLineBreak = true;
         }
         else if (bracketFormatMode == BREAK_MODE)
         {
             if (formattedLine[0] == '{')
                 isInLineBreak = true;
         }
         else
         {
             if (currentLineBeginsWithBracket)
                 isInLineBreak = true;
         }
     }
     previousCommandChar = ' ';
     appendCurrentChar();
 }
 
 /**
  * get the next line comment adjustment that results from breaking a closing bracket.
  * the bracket must be on the same line as the closing header.
  * i.e "} else" changed to "} \n else".
  */
 int ASFormatter::getNextLineCommentAdjustment()
 {
     assert(foundClosingHeader && previousNonWSChar == '}');
     if (charNum < 1)
         return 0;
     size_t lastBracket = currentLine.rfind('}', charNum - 1);
     if (lastBracket != string::npos)
         return (lastBracket - charNum); // return a negative number
     return 0;
 }
 
 LineEndFormat ASFormatter::getLineEndFormat() const
 {
     return lineEnd;
 }
 
 /**
  * get the current line comment adjustment that results from attaching
  * a closing header to a closing bracket.
  * the bracket must be on the line previous to the closing header.
  * the adjustment is 2 chars, one for the bracket and one for the space.
  * i.e "} \n else" changed to "} else".
  */
 int ASFormatter::getCurrentLineCommentAdjustment()
 {
     assert(foundClosingHeader && previousNonWSChar == '}');
     if (charNum < 1)
         return 2;
     size_t lastBracket = currentLine.rfind('}', charNum - 1);
     if (lastBracket == string::npos)
         return 2;
     return 0;
 }
 
 /**
  * get the previous word
  * the argument 'end' must point to the search start.
  *
  * @return is the previous word.
  */
 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 bracket
  * is followed by a closing header.
  * the break depends on the bracketFormatMode and other factors.
  */
 void ASFormatter::isLineBreakBeforeClosingHeader()
 {
     assert(foundClosingHeader && previousNonWSChar == '}');
     if (bracketFormatMode == BREAK_MODE || bracketFormatMode == HORSTMANN_MODE)
     {
         isInLineBreak = true;
     }
     else if (bracketFormatMode == NONE_MODE)
     {
         if (shouldBreakClosingHeaderBrackets
                 || getBracketIndent() || getBlockIndent())
         {
             isInLineBreak = true;
         }
         else
         {
             appendSpacePad();
             // is closing bracket broken?
             size_t i = currentLine.find_first_not_of(" \t");
             if (i != string::npos && currentLine[i] == '}')
                 isInLineBreak = false;
 
             if (shouldBreakBlocks)
                 isAppendPostBlockEmptyLineRequested = false;
         }
     }
     // bracketFormatMode == ATTACH_MODE, LINUX_MODE, STROUSTRUP_MODE
     else
     {
         if (shouldBreakClosingHeaderBrackets
                 || getBracketIndent() || getBlockIndent())
         {
             isInLineBreak = true;
         }
         else
         {
             // if a blank line does not preceed this
             // or last line is not a one line block, attach header
             bool previousLineIsEmpty = isEmptyLine(formattedLine);
             bool previousLineIsOneLineBlock = false;
             size_t firstBracket = findNextChar(formattedLine, '{');
             if (firstBracket != string::npos)
                 previousLineIsOneLineBlock = isOneLineBlockReached(formattedLine, firstBracket);
             if (!previousLineIsEmpty
                     && !previousLineIsOneLineBlock)
             {
                 isInLineBreak = false;
                 appendSpacePad();
                 spacePadNum = 0;    // don't count as comment padding
             }
 
             if (shouldBreakBlocks)
                 isAppendPostBlockEmptyLineRequested = false;
         }
     }
 }
 
 /**
  * Add brackets to a single line statement following a header.
  * Brackets are not added if the proper conditions are not met.
  * Brackets are added to the currentLine.
  */
 bool ASFormatter::addBracketsToStatement()
 {
     assert(isImmediatelyPostHeader);
 
     if (currentHeader != &AS_IF
             && currentHeader != &AS_ELSE
             && currentHeader != &AS_FOR
             && currentHeader != &AS_WHILE
             && currentHeader != &AS_DO
             && currentHeader != &AS_FOREACH)
         return false;
 
     // do not add if a header follows (i.e. else if)
     if (isCharPotentialHeader(currentLine, charNum))
         if (findHeader(headers) != NULL)
             return false;
 
     // find the next semi-colon
     size_t nextSemiColon = findNextChar(currentLine, ';', charNum+1);
     if (nextSemiColon == string::npos)
         return false;
 
     // add closing bracket before changing the line length
     if (nextSemiColon == currentLine.length() - 1)
         currentLine.append(" }");
     else
         currentLine.insert(nextSemiColon + 1, " }");
     // add opening bracket
     currentLine.insert(charNum, "{ ");
     currentChar = '{';
     // remove extra spaces
     if (!shouldAddOneLineBrackets)
     {
         size_t lastText = formattedLine.find_last_not_of(" \t");
         if ((formattedLine.length() - 1) - lastText > 1)
             formattedLine.erase(lastText + 1);
     }
     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 char to find.
  * @return the position on the line or string::npos if not found.
  */
 size_t ASFormatter::findNextChar(string& line, char searchChar, int searchStart /*0*/)
 {
     // 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 (line[i] == '\'' || 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' brackets
         // 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 line          a reference to the line to indent.
  * @param index         the current line index.
  * @return              true if the struct has access modifiers.
  */
 bool ASFormatter::isStructAccessModified(string  &firstLine, size_t index) const
 {
     assert(firstLine[index] == '{');
     assert(isCStyle());
 
     bool isFirstLine = true;
     bool needReset = false;
     size_t bracketCount = 1;
     string nextLine = firstLine.substr(index + 1);
 
     // find the first non-blank text, bypassing all comments.
     bool isInComment = false;
     while (sourceIterator->hasMoreLines())
     {
         if (isFirstLine)
             isFirstLine = false;
         else
         {
             nextLine = sourceIterator->peekNextLine();
             needReset = true;
         }
         // 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)
             {
                 i = nextLine.find("*/", i);
                 if (i == string::npos)
                 {
                     i = nextLine.length();
                     continue;
                 }
                 i++;
                 isInComment = false;
                 continue;
             }
             if (nextLine.compare(i, 2, "//") == 0)
             {
                 i = nextLine.length();
                 continue;
             }
             // handle brackets
             if (nextLine[i] == '{')
                 bracketCount++;
             if (nextLine[i] == '}')
                 bracketCount--;
             if (bracketCount == 0)
             {
                 if (needReset)
                     sourceIterator->peekReset();
                 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))
                 {
                     if (needReset)
                         sourceIterator->peekReset();
                     return true;
                 }
                 string name = getCurrentWord(nextLine, i);
                 i += name.length() - 1;
             }
         }   // end of for loop
     }   // end of while loop
 
     if (needReset)
         sourceIterator->peekReset();
     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(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 indent = getIndentLength();
     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
             {
                 i = 0;
                 continuationIncrementIn = tabIncrementIn;
                 break;
             }
             if (currentLine[i] == '\t')
                 continuationIncrementIn += indent - 1 - ((continuationIncrementIn + i) % indent);
         }
 
         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 (i >= len)
             charNum = 0;
     }
     return;
 }
 
 
 }   // end namespace astyle