File indexing completed on 2024-04-21 04:36:09

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *
  *   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 <iostream>
 
 
 namespace astyle
 {
 // static member variables
 int ASBeautifier::beautifierFileType = 9;       // initialized with an invalid type
 vector<const string*>* ASBeautifier::headers = NULL;
 vector<const string*>* ASBeautifier::nonParenHeaders = NULL;
 vector<const string*>* ASBeautifier::preBlockStatements;
 vector<const string*>* ASBeautifier::assignmentOperators = NULL;
 vector<const string*>* ASBeautifier::nonAssignmentOperators;
 vector<const string*>* ASBeautifier::indentableHeaders;
 
 
 /**
  * ASBeautifier's constructor
  */
 ASBeautifier::ASBeautifier()
 {
     waitingBeautifierStack = NULL;
     activeBeautifierStack = NULL;
     waitingBeautifierStackLengthStack = NULL;
     activeBeautifierStackLengthStack = NULL;
 
     headerStack  = NULL;
     tempStacks = NULL;
     blockParenDepthStack = NULL;
     blockStatementStack = NULL;
     parenStatementStack = NULL;
     bracketBlockStateStack = NULL;
     inStatementIndentStack = NULL;
     inStatementIndentStackSizeStack = NULL;
     parenIndentStack = NULL;
     sourceIterator = NULL;
     isIndentManuallySet = false;
     isMinConditionalManuallySet = false;
     isModeManuallySet = false;
     shouldForceTabIndentation = false;
     setSpaceIndentation(4);             // also sets minConditionalIndent
     setMaxInStatementIndentLength(40);
     classInitializerTabs = 1;
     setClassIndent(false);
     setSwitchIndent(false);
     setCaseIndent(false);
     setBlockIndent(false);
     setBracketIndent(false);
     setNamespaceIndent(false);
     setLabelIndent(false);
     setEmptyLineFill(false);
     setCStyle();
     setPreprocessorIndent(false);
 
     // initialize ASBeautifier static member vectors
     beautifierFileType = 9;     // reset to an invalid type
     initVector(headers);
     initVector(nonParenHeaders);
     initVector(assignmentOperators);
     initVector(nonAssignmentOperators);
     initVector(preBlockStatements);
     initVector(indentableHeaders);
 }
 
 /**
  * ASBeautifier's copy constructor
  * must explicitly call the base class copy constructor
  */
 ASBeautifier::ASBeautifier(const ASBeautifier &other) : ASBase(other)
 {
     // these don't need to copy the stack
     waitingBeautifierStack = NULL;
     activeBeautifierStack = NULL;
     waitingBeautifierStackLengthStack = NULL;
     activeBeautifierStackLengthStack = NULL;
 
     // vector '=' operator performs a DEEP copy of all elements in the vector
 
     headerStack  = new vector<const string*>;
     *headerStack = *other.headerStack;
 
     //tempStacks = new vector<vector<const string*>*>;
     //vector<vector<const string*>*>::iterator iter;
     //for (iter = other.tempStacks->begin();
     //        iter != other.tempStacks->end();
     //        ++iter)
     //{
     //  vector<const string*> *newVec = new vector<const string*>;
     //  *newVec = **iter;
     //  tempStacks->push_back(newVec);
     //}
     tempStacks = copyTempStacks(other);
 
     blockParenDepthStack = new vector<int>;
     *blockParenDepthStack = *other.blockParenDepthStack;
 
     blockStatementStack = new vector<bool>;
     *blockStatementStack = *other.blockStatementStack;
 
     parenStatementStack =  new vector<bool>;
     *parenStatementStack = *other.parenStatementStack;
 
     bracketBlockStateStack = new vector<bool>;
     *bracketBlockStateStack = *other.bracketBlockStateStack;
 
     inStatementIndentStack = new vector<int>;
     *inStatementIndentStack = *other.inStatementIndentStack;
 
     inStatementIndentStackSizeStack = new vector<int>;
     *inStatementIndentStackSizeStack = *other.inStatementIndentStackSizeStack;
 
     parenIndentStack = new vector<int>;
     *parenIndentStack = *other.parenIndentStack;
 
     sourceIterator = other.sourceIterator;
 
     // protected variables
     // variables set by ASFormatter
     // must also be updated in activeBeautifierStack
     inLineNumber = other.inLineNumber;
     horstmannIndentInStatement = other.horstmannIndentInStatement;
     nonInStatementBracket = other.nonInStatementBracket;
     lineCommentNoBeautify = other.lineCommentNoBeautify;
     isNonInStatementArray = other.isNonInStatementArray;
     isSharpAccessor = other.isSharpAccessor;
     isSharpDelegate = other.isSharpDelegate;
     isInExtern = other.isInExtern;
     isInBeautifySQL = other.isInBeautifySQL;
     isInIndentableStruct = other.isInIndentableStruct;
 
     // private variables
     indentString = other.indentString;
     currentHeader = other.currentHeader;
     previousLastLineHeader = other.previousLastLineHeader;
     probationHeader = other.probationHeader;
     isInQuote = other.isInQuote;
     isInVerbatimQuote = other.isInVerbatimQuote;
     haveLineContinuationChar = other.haveLineContinuationChar;
     isInAsm = other.isInAsm;
     isInAsmOneLine = other.isInAsmOneLine;
     isInAsmBlock = other.isInAsmBlock;
     isInComment = other.isInComment;
     isInHorstmannComment = other.isInHorstmannComment;
     isInCase = other.isInCase;
     isInQuestion = other.isInQuestion;
     isInStatement = other.isInStatement;
     isInHeader = other.isInHeader;
     isInTemplate = other.isInTemplate;
     isInDefine = other.isInDefine;
     isInDefineDefinition = other.isInDefineDefinition;
     classIndent = other.classIndent;
     isInClassInitializer = other.isInClassInitializer;
     isInClassHeaderTab = other.isInClassHeaderTab;
     isInEnum = other.isInEnum;
     switchIndent = other.switchIndent;
     caseIndent = other.caseIndent;
     namespaceIndent = other.namespaceIndent;
     bracketIndent = other.bracketIndent;
     blockIndent = other.blockIndent;
     labelIndent = other.labelIndent;
     preprocessorIndent = other.preprocessorIndent;
     isInConditional = other.isInConditional;
     isIndentManuallySet = other.isIndentManuallySet;
     isMinConditionalManuallySet = other.isMinConditionalManuallySet;
     isModeManuallySet = other.isModeManuallySet;
     shouldForceTabIndentation = other.shouldForceTabIndentation;
     emptyLineFill = other.emptyLineFill;
     lineOpensComment = other.lineOpensComment;
     backslashEndsPrevLine = other.backslashEndsPrevLine;
     blockCommentNoIndent = other.blockCommentNoIndent;
     blockCommentNoBeautify = other.blockCommentNoBeautify;
     previousLineProbationTab = other.previousLineProbationTab;
     fileType = other.fileType;
     minConditionalIndent = other.minConditionalIndent;
     parenDepth = other.parenDepth;
     indentLength = other.indentLength;
     blockTabCount = other.blockTabCount;
     maxInStatementIndent = other.maxInStatementIndent;
     classInitializerTabs = other.classInitializerTabs;
     templateDepth = other.templateDepth;
     prevFinalLineSpaceTabCount = other.prevFinalLineSpaceTabCount;
     prevFinalLineTabCount = other.prevFinalLineTabCount;
     defineTabCount = other.defineTabCount;
     quoteChar = other.quoteChar;
     prevNonSpaceCh = other.prevNonSpaceCh;
     currentNonSpaceCh = other.currentNonSpaceCh;
     currentNonLegalCh = other.currentNonLegalCh;
     prevNonLegalCh = other.prevNonLegalCh;
 }
 
 /**
  * ASBeautifier's destructor
  */
 ASBeautifier::~ASBeautifier()
 {
     deleteContainer(waitingBeautifierStack);
     deleteContainer(activeBeautifierStack);
     deleteContainer(waitingBeautifierStackLengthStack);
     deleteContainer(activeBeautifierStackLengthStack);
     deleteContainer(headerStack);
     deleteContainer(tempStacks);
     deleteContainer(blockParenDepthStack);
     deleteContainer(blockStatementStack);
     deleteContainer(parenStatementStack);
     deleteContainer(bracketBlockStateStack);
     deleteContainer(inStatementIndentStack);
     deleteContainer(inStatementIndentStackSizeStack);
     deleteContainer(parenIndentStack);
 }
 
 /**
  * initialize the ASBeautifier.
  *
  * init() should be called every time a ABeautifier object is to start
  * beautifying a NEW source file.
  * init() recieves a pointer to a ASSourceIterator object that will be
  * used to iterate through the source code.
  *
  * @param iter     a pointer to the ASSourceIterator or ASStreamIterator object.
  */
 void ASBeautifier::init(ASSourceIterator *iter)
 {
     sourceIterator = iter;
     init();
 }
 
 /**
  * initialize the ASBeautifier.
  */
 void ASBeautifier::init()
 {
     initStatic();
     ASBase::init(getFileType());
 
     initContainer(waitingBeautifierStack, new vector<ASBeautifier*>);
     initContainer(activeBeautifierStack, new vector<ASBeautifier*>);
 
     initContainer(waitingBeautifierStackLengthStack, new vector<int>);
     initContainer(activeBeautifierStackLengthStack, new vector<int>);
 
     initContainer(headerStack,  new vector<const string*>);
 
     initContainer(tempStacks, new vector<vector<const string*>*>);
     tempStacks->push_back(new vector<const string*>);
 
     initContainer(blockParenDepthStack, new vector<int>);
     initContainer(blockStatementStack, new vector<bool>);
     initContainer(parenStatementStack, new vector<bool>);
 
     initContainer(bracketBlockStateStack, new vector<bool>);
     bracketBlockStateStack->push_back(true);
 
     initContainer(inStatementIndentStack, new vector<int>);
     initContainer(inStatementIndentStackSizeStack, new vector<int>);
     inStatementIndentStackSizeStack->push_back(0);
     initContainer(parenIndentStack, new vector<int>);
 
     previousLastLineHeader = NULL;
     currentHeader = NULL;
 
     isInQuote = false;
     isInVerbatimQuote = false;
     haveLineContinuationChar = false;
     isInAsm = false;
     isInAsmOneLine = false;
     isInAsmBlock = false;
     isInComment = false;
     isInHorstmannComment = false;
     isInStatement = false;
     isInCase = false;
     isInQuestion = false;
     isInClassInitializer = false;
     isInClassHeaderTab = false;
     isInEnum = false;
     isInHeader = false;
     isInTemplate = false;
     isInConditional = false;
 
     templateDepth = 0;
     parenDepth = 0;
     blockTabCount = 0;
     prevNonSpaceCh = '{';
     currentNonSpaceCh = '{';
     prevNonLegalCh = '{';
     currentNonLegalCh = '{';
     quoteChar = ' ';
     prevFinalLineSpaceTabCount = 0;
     prevFinalLineTabCount = 0;
     probationHeader = NULL;
     backslashEndsPrevLine = false;
     lineOpensComment = false;
     isInDefine = false;
     isInDefineDefinition = false;
     defineTabCount = 0;
     lineCommentNoBeautify = false;
     blockCommentNoIndent = false;
     blockCommentNoBeautify = false;
     previousLineProbationTab = false;
     isNonInStatementArray = false;
     isSharpAccessor = false;
     isSharpDelegate = false;
     isInExtern = false;
     isInBeautifySQL = false;
     isInIndentableStruct = false;
     inLineNumber = 0;
     horstmannIndentInStatement = 0;
     nonInStatementBracket = 0;
 }
 
 /*
  * initialize the static vars
  */
 void ASBeautifier::initStatic()
 {
     if (fileType == beautifierFileType)    // don't build unless necessary
         return;
 
     beautifierFileType = fileType;
 
     headers->clear();
     nonParenHeaders->clear();
     assignmentOperators->clear();
     nonAssignmentOperators->clear();
     preBlockStatements->clear();
     indentableHeaders->clear();
 
     ASResource::buildHeaders(headers, fileType, true);
     ASResource::buildNonParenHeaders(nonParenHeaders, fileType, true);
     ASResource::buildAssignmentOperators(assignmentOperators);
     ASResource::buildNonAssignmentOperators(nonAssignmentOperators);
     ASResource::buildPreBlockStatements(preBlockStatements, fileType);
     ASResource::buildIndentableHeaders(indentableHeaders);
 }
 
 /**
  * set indentation style to C/C++.
  */
 void ASBeautifier::setCStyle()
 {
     fileType = C_TYPE;
 }
 
 /**
  * set indentation style to Java.
  */
 void ASBeautifier::setJavaStyle()
 {
     fileType = JAVA_TYPE;
 }
 
 /**
  * set indentation style to C#.
  */
 void ASBeautifier::setSharpStyle()
 {
     fileType = SHARP_TYPE;
 }
 
 /**
  * set mode manually set flag
  */
 void ASBeautifier::setModeManuallySet(bool state)
 {
     isModeManuallySet = state;
 }
 
 /**
  * indent using one tab per indentation
  */
 void ASBeautifier::setTabIndentation(int length, bool forceTabs)
 {
     indentString = "\t";
     indentLength = length;
     shouldForceTabIndentation = forceTabs;
 
     if (!isMinConditionalManuallySet)
         minConditionalIndent = indentLength * 2;
 }
 
 /**
  * indent using a number of spaces per indentation.
  *
  * @param   length     number of spaces per indent.
  */
 void ASBeautifier::setSpaceIndentation(int length)
 {
     indentString = string(length, ' ');
     indentLength = length;
 
     if (!isMinConditionalManuallySet)
         minConditionalIndent = indentLength * 2;
 }
 
 /**
  * set indent manually set flag
  */
 void ASBeautifier::setIndentManuallySet(bool state)
 {
     isIndentManuallySet = state;
 }
 
 /**
  * set the maximum indentation between two lines in a multi-line statement.
  *
  * @param   max     maximum indentation length.
  */
 void ASBeautifier::setMaxInStatementIndentLength(int max)
 {
     maxInStatementIndent = max;
 }
 
 /**
  * set the minimum indentation between two lines in a multi-line condition.
  *
  * @param   min     minimal indentation length.
  */
 void ASBeautifier::setMinConditionalIndentLength(int min)
 {
     minConditionalIndent = min;
 }
 
 /**
  * set min conditional manually set flag
  */
 void ASBeautifier::setMinConditionalManuallySet(bool state)
 {
     isMinConditionalManuallySet = state;
 }
 
 /**
  * set the state of the bracket indentation option. If true, brackets will
  * be indented one additional indent.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setBracketIndent(bool state)
 {
     bracketIndent = state;
 }
 
 /**
  * set the state of the block indentation option. If true, entire blocks
  * will be indented one additional indent, similar to the GNU indent style.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setBlockIndent(bool state)
 {
     blockIndent = state;
 }
 
 /**
  * set the state of the class indentation option. If true, C++ class
  * definitions will be indented one additional indent.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setClassIndent(bool state)
 {
     classIndent = state;
 }
 
 /**
  * set the state of the switch indentation option. If true, blocks of 'switch'
  * statements will be indented one additional indent.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setSwitchIndent(bool state)
 {
     switchIndent = state;
 }
 
 /**
  * set the state of the case indentation option. If true, lines of 'case'
  * statements will be indented one additional indent.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setCaseIndent(bool state)
 {
     caseIndent = state;
 }
 
 /**
  * set the state of the namespace indentation option.
  * If true, blocks of 'namespace' statements will be indented one
  * additional indent. Otherwise, NO indentation will be added.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setNamespaceIndent(bool state)
 {
     namespaceIndent = state;
 }
 
 /**
  * set the state of the label indentation option.
  * If true, labels will be indented one indent LESS than the
  * current indentation level.
  * If false, labels will be flushed to the left with NO
  * indent at all.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setLabelIndent(bool state)
 {
     labelIndent = state;
 }
 
 /**
  * set the state of the preprocessor indentation option.
  * If true, multiline #define statements will be indented.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setPreprocessorIndent(bool state)
 {
     preprocessorIndent = state;
 }
 
 /**
  * set the state of the empty line fill option.
  * If true, empty lines will be filled with the whitespace.
  * of their previous lines.
  * If false, these lines will remain empty.
  *
  * @param   state             state of option.
  */
 void ASBeautifier::setEmptyLineFill(bool state)
 {
     emptyLineFill = state;
 }
 
 /**
  * get the file type.
  */
 int ASBeautifier::getFileType()
 {
     return fileType;
 }
 
 /**
  * get the number of spaces per indent
  *
  * @return   value of indentLength option.
  */
 int ASBeautifier::getIndentLength(void)
 {
     return indentLength;
 }
 
 /**
  * get the char used for indentation, space or tab
  *
  * @return   the char used for indentation.
  */
 string ASBeautifier::getIndentString(void)
 {
     return indentString;
 }
 
 /**
  * get indent manually set flag
  */
 bool ASBeautifier::getIndentManuallySet()
 {
     return isIndentManuallySet;
 }
 
 /**
  * get the state of the isMinConditionalManuallySet flag
  *
  * @return   the state of isMinConditionalManuallySet.
  */
 bool ASBeautifier::getMinConditionalManuallySet()
 {
     return isMinConditionalManuallySet;
 }
 
 /**
  * get mode manually set flag
  */
 bool ASBeautifier::getModeManuallySet()
 {
     return isModeManuallySet;
 }
 
 /**
  * get the state of the force tab indentation option.
  *
  * @return   state of force tab indentation.
  */
 bool ASBeautifier::getForceTabIndentation(void)
 {
     return shouldForceTabIndentation;
 }
 
 /**
  * get the state of the block indentation option.
  *
  * @return   state of blockIndent option.
  */
 bool ASBeautifier::getBlockIndent(void)
 {
     return blockIndent;
 }
 
 /**
  * get the state of the bracket indentation option.
  *
  * @return   state of bracketIndent option.
  */
 bool ASBeautifier::getBracketIndent(void)
 {
     return bracketIndent;
 }
 
 /**
  * get the state of the class indentation option. If true, blocks of
  * the 'class' statement will be indented one additional indent.
  *
  * @return   state of classIndent option.
  */
 bool ASBeautifier::getClassIndent(void)
 {
     return classIndent;
 }
 
 /**
  * get the state of the switch indentation option. If true, blocks of
  * the 'switch' statement will be indented one additional indent.
  *
  * @return   state of switchIndent option.
  */
 bool ASBeautifier::getSwitchIndent(void)
 {
     return switchIndent;
 }
 
 /**
  * get the state of the case indentation option. If true, lines of 'case'
  * statements will be indented one additional indent.
  *
  * @return   state of caseIndent option.
  */
 bool ASBeautifier::getCaseIndent(void)
 {
     return caseIndent;
 }
 
 /**
  * get the state of the empty line fill option.
  * If true, empty lines will be filled with the whitespace.
  * of their previous lines.
  * If false, these lines will remain empty.
  *
  * @return   state of emptyLineFill option.
  */
 bool ASBeautifier::getEmptyLineFill(void)
 {
     return emptyLineFill;
 }
 
 /**
  * check if there are any indented lines ready to be read by nextLine()
  *
  * @return    are there any indented lines ready?
  */
 bool ASBeautifier::hasMoreLines() const
 {
     return sourceIterator->hasMoreLines();
 }
 
 /**
  * get the next indented line.
  *
  * @return    indented line.
  */
 string ASBeautifier::nextLine()
 {
     return beautify(sourceIterator->nextLine());
 }
 
 /**
  * beautify a line of source code.
  * every line of source code in a source code file should be sent
  * one after the other to the beautify method.
  *
  * @return      the indented line.
  * @param originalLine       the original unindented line.
  */
 string ASBeautifier::beautify(const string &originalLine)
 {
     string line;
     bool isInLineComment = false;
     bool lineStartsInComment = false;
     bool isInClass = false;
     bool isInSwitch = false;
     bool isInOperator = false;
     bool isSpecialChar = false;
     bool haveCaseIndent = false;
     bool haveAssignmentThisLine = false;
     bool lineBeginsWithBracket = false;
     bool closingBracketReached = false;
     bool shouldIndentBrackettedLine = true;
     bool previousLineProbation = (probationHeader != NULL);
     bool isInQuoteContinuation = isInVerbatimQuote | haveLineContinuationChar;
     char ch = ' ';
     char prevCh;
     char tempCh;
     int tabCount = 0;
     int spaceTabCount = 0;
     int lineOpeningBlocksNum = 0;
     int lineClosingBlocksNum = 0;
     int tabIncrementIn = 0;
     int i;
     int iPrelim;
     string outBuffer; // the newly idented line is buffered here
     const string *lastLineHeader = NULL;
 
     currentHeader = NULL;
     lineStartsInComment = isInComment;
     blockCommentNoBeautify = blockCommentNoIndent;
     isInAsmOneLine = false;
     lineOpensComment = false;
     previousLineProbationTab = false;
     haveLineContinuationChar = false;
 
     // handle and remove white spaces around the line:
     // If not in comment, first find out size of white space before line,
     // so that possible comments starting in the line continue in
     // relation to the preliminary white-space.
     if (isInQuoteContinuation)
     {
         // trim a single space added by ASFormatter, otherwise leave it alone
         if (!(originalLine.length() == 1 && originalLine[0] == ' '))
             line = originalLine;
     }
     else if (isInComment || isInBeautifySQL)
     {
         // trim the end of comment and SQL lines
         line = originalLine;
         size_t trimEnd = line.find_last_not_of(" \t");
         if (trimEnd == string::npos)
             trimEnd = 0;
         else
             trimEnd++;
         if (trimEnd < line.length())
             line.erase(trimEnd);
     }
     else
     {
         line = trim(originalLine);
         if (line.length() > 0 && line[0] == '{')
             lineBeginsWithBracket = true;
 
         isInHorstmannComment = false;
         size_t j = line.find_first_not_of(" \t{");
         if (j != string::npos && line.compare(j, 2, "/*") == 0)
         {
             lineOpensComment = true;
             size_t k = line.find_first_not_of(" \t");
             if (k != string::npos && line.compare(k, 1, "{") == 0)
                 isInHorstmannComment = true;
         }
     }
 
     if (line.length() == 0)
     {
         if (backslashEndsPrevLine)  // must continue to clear variables
             line = ' ';
         else if (emptyLineFill && !isInQuoteContinuation && headerStack->size() > 0)
             return preLineWS(prevFinalLineSpaceTabCount, prevFinalLineTabCount);
         else
             return line;
     }
 
     // handle preprocessor commands
     // except C# region and endregion
 
     if (!isInComment
             && (line[0] == '#' || backslashEndsPrevLine)
             && line.compare(0, 7, "#region") != 0
             && line.compare(0, 10, "#endregion") != 0)
     {
         if (line[0] == '#')
         {
             string preproc = trim(string(line.c_str() + 1));
 
             // When finding a multi-lined #define statement, the original beautifier
             // 1. sets its isInDefineDefinition flag
             // 2. clones a new beautifier that will be used for the actual indentation
             //    of the #define. This clone is put into the activeBeautifierStack in order
             //    to be called for the actual indentation.
             // The original beautifier will have isInDefineDefinition = true, isInDefine = false
             // The cloned beautifier will have   isInDefineDefinition = true, isInDefine = true
             if (preprocessorIndent && preproc.compare(0, 6, "define") == 0 && line[line.length() - 1] == '\\')
             {
                 if (!isInDefineDefinition)
                 {
                     ASBeautifier *defineBeautifier;
 
                     // this is the original beautifier
                     isInDefineDefinition = true;
 
                     // push a new beautifier into the active stack
                     // this beautifier will be used for the indentation of this define
                     defineBeautifier = new ASBeautifier(*this);
                     activeBeautifierStack->push_back(defineBeautifier);
                 }
                 else
                 {
                     // the is the cloned beautifier that is in charge of indenting the #define.
                     isInDefine = true;
                 }
             }
             else if (preproc.compare(0, 2, "if") == 0)
             {
                 // push a new beautifier into the stack
                 waitingBeautifierStackLengthStack->push_back(waitingBeautifierStack->size());
                 activeBeautifierStackLengthStack->push_back(activeBeautifierStack->size());
                 waitingBeautifierStack->push_back(new ASBeautifier(*this));
             }
             else if (preproc.compare(0, 4/*2*/, "else") == 0)
             {
                 if (waitingBeautifierStack && !waitingBeautifierStack->empty())
                 {
                     // MOVE current waiting beautifier to active stack.
                     activeBeautifierStack->push_back(waitingBeautifierStack->back());
                     waitingBeautifierStack->pop_back();
                 }
             }
             else if (preproc.compare(0, 4, "elif") == 0)
             {
                 if (waitingBeautifierStack && !waitingBeautifierStack->empty())
                 {
                     // append a COPY current waiting beautifier to active stack, WITHOUT deleting the original.
                     activeBeautifierStack->push_back(new ASBeautifier(*(waitingBeautifierStack->back())));
                 }
             }
             else if (preproc.compare(0, 5, "endif") == 0)
             {
                 int stackLength;
                 ASBeautifier *beautifier;
 
                 if (waitingBeautifierStackLengthStack && !waitingBeautifierStackLengthStack->empty())
                 {
                     stackLength = waitingBeautifierStackLengthStack->back();
                     waitingBeautifierStackLengthStack->pop_back();
                     while ((int) waitingBeautifierStack->size() > stackLength)
                     {
                         beautifier = waitingBeautifierStack->back();
                         waitingBeautifierStack->pop_back();
                         delete beautifier;
                     }
                 }
 
                 if (!activeBeautifierStackLengthStack->empty())
                 {
                     stackLength = activeBeautifierStackLengthStack->back();
                     activeBeautifierStackLengthStack->pop_back();
                     while ((int) activeBeautifierStack->size() > stackLength)
                     {
                         beautifier = activeBeautifierStack->back();
                         activeBeautifierStack->pop_back();
                         delete beautifier;
                     }
                 }
             }
         }
 
         // check if the last char is a backslash
         if (line.length() > 0)
             backslashEndsPrevLine = (line[line.length() - 1] == '\\');
         else
             backslashEndsPrevLine = false;
 
         // check if this line ends a multi-line #define
         // if so, use the #define's cloned beautifier for the line's indentation
         // and then remove it from the active beautifier stack and delete it.
         if (!backslashEndsPrevLine && isInDefineDefinition && !isInDefine)
         {
             string beautifiedLine;
             ASBeautifier *defineBeautifier;
 
             isInDefineDefinition = false;
             defineBeautifier = activeBeautifierStack->back();
             activeBeautifierStack->pop_back();
 
             beautifiedLine = defineBeautifier->beautify(line);
             delete defineBeautifier;
             return beautifiedLine;
         }
 
         // unless this is a multi-line #define, return this precompiler line as is.
         if (!isInDefine && !isInDefineDefinition)
             return originalLine;
     }
 
     // if there exists any worker beautifier in the activeBeautifierStack,
     // then use it instead of me to indent the current line.
     // variables set by ASFormatter must be updated.
     if (!isInDefine && activeBeautifierStack != NULL && !activeBeautifierStack->empty())
     {
         activeBeautifierStack->back()->inLineNumber = inLineNumber;
         activeBeautifierStack->back()->horstmannIndentInStatement = horstmannIndentInStatement;
         activeBeautifierStack->back()->nonInStatementBracket = nonInStatementBracket;
         activeBeautifierStack->back()->lineCommentNoBeautify = lineCommentNoBeautify;
         activeBeautifierStack->back()->isNonInStatementArray = isNonInStatementArray;
         activeBeautifierStack->back()->isSharpAccessor = isSharpAccessor;
         activeBeautifierStack->back()->isSharpDelegate = isSharpDelegate;
         activeBeautifierStack->back()->isInExtern = isInExtern;
         activeBeautifierStack->back()->isInBeautifySQL = isInBeautifySQL;
         activeBeautifierStack->back()->isInIndentableStruct = isInIndentableStruct;
         // must return originalLine not the trimmed line
         return activeBeautifierStack->back()->beautify(originalLine);
     }
 
     // calculate preliminary indentation based on data from past lines
 
     if (!inStatementIndentStack->empty())
         spaceTabCount = inStatementIndentStack->back();
 
     for (i = 0; i < (int) headerStack->size(); i++)
     {
         isInClass = false;
 
         if (blockIndent)
         {
             // do NOT indent opening block for these headers
             if (!((*headerStack)[i] == &AS_NAMESPACE
                     || (*headerStack)[i] == &AS_CLASS
                     || (*headerStack)[i] == &AS_STRUCT
                     || (*headerStack)[i] == &AS_UNION
                     || (*headerStack)[i] == &AS_CONST
                     || (*headerStack)[i] == &AS_INTERFACE
                     || (*headerStack)[i] == &AS_THROWS
                     || (*headerStack)[i] == &AS_STATIC))
                 ++tabCount;
         }
         else if (!(i > 0 && (*headerStack)[i-1] != &AS_OPEN_BRACKET
                    && (*headerStack)[i] == &AS_OPEN_BRACKET))
             ++tabCount;
 
         if (!isJavaStyle() && !namespaceIndent && i >= 1
                 && (*headerStack)[i-1] == &AS_NAMESPACE
                 && (*headerStack)[i] == &AS_OPEN_BRACKET)
             --tabCount;
 
         if (isCStyle() && i >= 1
                 && (*headerStack)[i-1] == &AS_CLASS
                 && (*headerStack)[i] == &AS_OPEN_BRACKET)
         {
             if (classIndent)
                 ++tabCount;
             isInClass = true;
         }
 
         // is the switchIndent option is on, indent switch statements an additional indent.
         else if (switchIndent && i > 1
                  && (*headerStack)[i-1] == &AS_SWITCH
                  && (*headerStack)[i] == &AS_OPEN_BRACKET)
         {
             ++tabCount;
             isInSwitch = true;
         }
 
     }   // end of for loop * end of for loop * end of for loop * end of for loop * end of for loop *
 
     iPrelim = i;
 
     if (!lineStartsInComment
             && isCStyle()
             && isInClass
             && classIndent
             && headerStack->size() >= 2
             && (*headerStack)[headerStack->size()-2] == &AS_CLASS
             && (*headerStack)[headerStack->size()-1] == &AS_OPEN_BRACKET
             && line[0] == '}'
             && bracketBlockStateStack->back() == true)
         --tabCount;
 
     else if (!lineStartsInComment
              && isInSwitch
              && switchIndent
              && headerStack->size() >= 2
              && (*headerStack)[headerStack->size()-2] == &AS_SWITCH
              && (*headerStack)[headerStack->size()-1] == &AS_OPEN_BRACKET
              && line[0] == '}')
         --tabCount;
 
     if (isInClassInitializer)
     {
         if (lineStartsInComment || lineOpensComment)
         {
             if (!lineBeginsWithBracket)
                 tabCount--;
         }
         else if (isCStyle() && !isClassAccessModifier(line))
         {
             isInClassHeaderTab = true;
             tabCount += classInitializerTabs;
         }
         else if (blockIndent)
         {
             if (!lineBeginsWithBracket)
                 tabCount++;
         }
     }
     // handle special case of indented horstmann brackets
     else if (lineStartsInComment && isInHorstmannComment && bracketIndent)
         tabCount++;
 
     // handle special case of horstmann comment in an indented class statement
     if (isInClass
             && classIndent
             && isInHorstmannComment
             && !lineOpensComment
             && headerStack->size() >= 2
             && (*headerStack)[headerStack->size()-2] == &AS_CLASS)
         --tabCount;
 
     if (isInConditional)
     {
         --tabCount;
     }
 
 
     // parse characters in the current line.
 
     for (i = 0; i < (int) line.length(); i++)
     {
         outBuffer.append(1, line[i]);
 
         tempCh = line[i];
         prevCh = ch;
         ch = tempCh;
 
         if (isInBeautifySQL)
             continue;
 
         if (isWhiteSpace(ch))
         {
             if (ch == '\t')
                 tabIncrementIn += convertTabToSpaces(i, tabIncrementIn);
             continue;
         }
 
         // handle special characters (i.e. backslash+character such as \n, \t, ...)
 
         if (isInQuote && !isInVerbatimQuote)
         {
             if (isSpecialChar)
             {
                 isSpecialChar = false;
                 continue;
             }
             if (line.compare(i, 2, "\\\\") == 0)
             {
                 outBuffer.append(1, '\\');
                 i++;
                 continue;
             }
             if (ch == '\\')
             {
                 if (peekNextChar(line, i) == ' ')   // is this '\' at end of line
                     haveLineContinuationChar = true;
                 else
                     isSpecialChar = true;
                 continue;
             }
         }
         else if (isInDefine && ch == '\\')
             continue;
 
         // handle quotes (such as 'x' and "Hello Dolly")
         if (!(isInComment || isInLineComment) && (ch == '"' || ch == '\''))
         {
             if (!isInQuote)
             {
                 quoteChar = ch;
                 isInQuote = true;
                 if (isSharpStyle() && prevCh == '@')
                     isInVerbatimQuote = true;
             }
             else if (isInVerbatimQuote && ch == '"')
             {
                 if (peekNextChar(line, i) == '"')           // check consecutive quotes
                 {
                     outBuffer.append(1, '"');
                     i++;
                 }
                 else
                 {
                     isInQuote = false;
                     isInVerbatimQuote = false;
                 }
             }
             else if (quoteChar == ch)
             {
                 isInQuote = false;
                 isInStatement = true;
                 continue;
             }
         }
         if (isInQuote)
             continue;
 
         // handle comments
 
         if (!(isInComment || isInLineComment) && line.compare(i, 2, "//") == 0)
         {
             isInLineComment = true;
             outBuffer.append(1, '/');
             i++;
             continue;
         }
         else if (!(isInComment || isInLineComment) && line.compare(i, 2, "/*") == 0)
         {
             isInComment = true;
             outBuffer.append(1, '*');
             i++;
             if (!lineOpensComment)                  // does line start with comment?
                 blockCommentNoIndent = true;        // if no, cannot indent continuation lines
             continue;
         }
         else if ((isInComment || isInLineComment) && line.compare(i, 2, "*/") == 0)
         {
             isInComment = false;
             outBuffer.append(1, '/');
             i++;
             blockCommentNoIndent = false;           // ok to indent next comment
             continue;
         }
         // treat C# '#region' and '#endregion' statements as a line comment
         else if (isSharpStyle() &&
                  (line.compare(i, 7, "#region") == 0 || line.compare(i, 10, "#endregion") == 0))
         {
             isInLineComment = true;
         }
 
         if (isInComment || isInLineComment)
         {
             // append rest of the comment up to the comment end
             while (i+1 < (int) line.length()
                     && line.compare(i+1, 2, "*/") != 0)
                 outBuffer.append(1, line[++i]);
             continue;
         }
 
         // if we have reached this far then we are NOT in a comment or string of special character...
 
         // SQL if formatted in ASEnhancer
         if (isInBeautifySQL)
             continue;
 
         if (probationHeader != NULL)
         {
             if (((probationHeader == &AS_STATIC || probationHeader == &AS_CONST) && ch == '{')
                     || (probationHeader == &AS_SYNCHRONIZED && ch == '('))
             {
                 // insert the probation header as a new header
                 isInHeader = true;
                 headerStack->push_back(probationHeader);
 
                 // handle the specific probation header
                 isInConditional = (probationHeader == &AS_SYNCHRONIZED);
 
                 isInStatement = false;
                 // if the probation comes from the previous line, then indent by 1 tab count.
                 if (previousLineProbation
                         && ch == '{'
                         && !(blockIndent
                              && (probationHeader == &AS_CONST || probationHeader == &AS_STATIC)))
                 {
                     tabCount++;
                     previousLineProbationTab = true;
                 }
                 previousLineProbation = false;
             }
 
             // dismiss the probation header
             probationHeader = NULL;
         }
 
         prevNonSpaceCh = currentNonSpaceCh;
         currentNonSpaceCh = ch;
         if (!isLegalNameChar(ch) && ch != ',' && ch != ';')
         {
             prevNonLegalCh = currentNonLegalCh;
             currentNonLegalCh = ch;
         }
 
         if (isInHeader)
         {
             isInHeader = false;
             currentHeader = headerStack->back();
         }
         else
             currentHeader = NULL;
 
         if (isCStyle() && isInTemplate
                 && (ch == '<' || ch == '>')
                 &&  findOperator(line, i, nonAssignmentOperators) == NULL)
         {
             if (ch == '<')
             {
                 ++templateDepth;
             }
             else if (ch == '>')
             {
                 if (--templateDepth <= 0)
                 {
                     if (isInTemplate)
                         ch = ';';
                     else
                         ch = 't';
                     isInTemplate = false;
                     templateDepth = 0;
                 }
             }
         }
 
         // handle parenthesies
         if (ch == '(' || ch == '[' || ch == ')' || ch == ']')
         {
             if (ch == '(' || ch == '[')
             {
                 isInOperator = false;
                 // if have a struct header, this is a declaration not a definition
                 if (ch == '('
                         && (isInClassInitializer || isInClassHeaderTab)
                         && headerStack->size() > 0
                         && headerStack->back() == &AS_STRUCT)
                 {
                     headerStack->pop_back();
                     isInClassInitializer = false;
                     // -1 for isInClassInitializer, -2 for isInClassHeaderTab
                     if (isInClassHeaderTab)
                     {
                         tabCount -= (1 + classInitializerTabs);
                         isInClassHeaderTab = false;
                     }
                     if (tabCount < 0)
                         tabCount = 0;
                 }
 
                 if (parenDepth == 0)
                 {
                     parenStatementStack->push_back(isInStatement);
                     isInStatement = true;
                 }
                 parenDepth++;
 
                 inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
 
                 if (currentHeader != NULL)
                     registerInStatementIndent(line, i, spaceTabCount, tabIncrementIn, minConditionalIndent/*indentLength*2*/, true);
                 else
                     registerInStatementIndent(line, i, spaceTabCount, tabIncrementIn, 0, true);
             }
             else if (ch == ')' || ch == ']')
             {
                 parenDepth--;
                 if (parenDepth == 0)
                 {
                     if (!parenStatementStack->empty())      // in case of unmatched closing parens
                     {
                         isInStatement = parenStatementStack->back();
                         parenStatementStack->pop_back();
                     }
                     ch = ' ';
                     isInAsm = false;
                     isInConditional = false;
                 }
 
                 if (!inStatementIndentStackSizeStack->empty())
                 {
                     int previousIndentStackSize = inStatementIndentStackSizeStack->back();
                     inStatementIndentStackSizeStack->pop_back();
                     while (previousIndentStackSize < (int) inStatementIndentStack->size())
                         inStatementIndentStack->pop_back();
 
                     if (!parenIndentStack->empty())
                     {
                         int poppedIndent = parenIndentStack->back();
                         parenIndentStack->pop_back();
 
                         if (i == 0)
                             spaceTabCount = poppedIndent;
                     }
                 }
             }
 
             continue;
         }
 
 
         if (ch == '{')
         {
             // first, check if '{' is a block-opener or an static-array opener
             bool isBlockOpener = ((prevNonSpaceCh == '{' && bracketBlockStateStack->back())
                                   || prevNonSpaceCh == '}'
                                   || prevNonSpaceCh == ')'
                                   || prevNonSpaceCh == ';'
                                   || peekNextChar(line, i) == '{'
                                   || isInClassInitializer
                                   || isNonInStatementArray
                                   || isSharpAccessor
                                   || isSharpDelegate
                                   || isInExtern
                                   || (isInDefine &&
                                       (prevNonSpaceCh == '('
                                        || isLegalNameChar(prevNonSpaceCh))));
 
             // remove inStatementIndent for C++ class initializer
             if (isInClassInitializer)
             {
                 if (inStatementIndentStack->size() > 0)
                     inStatementIndentStack->pop_back();
                 isInStatement = false;
                 if (lineBeginsWithBracket)
                     spaceTabCount = 0;
                 isInClassInitializer = false;
             }
 
             if (!isBlockOpener && currentHeader != NULL)
             {
                 for (size_t n = 0; n < nonParenHeaders->size(); n++)
                     if (currentHeader == (*nonParenHeaders)[n])
                     {
                         isBlockOpener = true;
                         break;
                     }
             }
 
             bracketBlockStateStack->push_back(isBlockOpener);
 
             if (!isBlockOpener)
             {
                 inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
                 registerInStatementIndent(line, i, spaceTabCount, tabIncrementIn, 0, true);
                 parenDepth++;
                 if (i == 0)
                     shouldIndentBrackettedLine = false;
 
                 continue;
             }
 
             // this bracket is a block opener...
 
             ++lineOpeningBlocksNum;
 
             if (isInClassHeaderTab)
             {
                 isInClassHeaderTab = false;
                 // decrease tab count if bracket is broken
                 size_t firstChar = line.find_first_not_of(" \t");
                 if (firstChar != string::npos
                         && line[firstChar] == '{'
                         && (int) firstChar == i)
                 {
                     tabCount -= classInitializerTabs;
                     // decrease one more if an empty class
                     if (headerStack->size() > 0
                             && (*headerStack).back() == &AS_CLASS)
                     {
                         int nextChar = getNextProgramCharDistance(line, i);
                         if (line[nextChar] == '}')
                             tabCount--;
                     }
                 }
             }
 
             if (bracketIndent && !namespaceIndent && headerStack->size() > 0
                     && (*headerStack).back() == &AS_NAMESPACE)
             {
                 shouldIndentBrackettedLine = false;
                 tabCount--;
             }
 
             // an indentable struct is treated like a class in the header stack
             if (headerStack->size() > 0
                     && (*headerStack).back() == &AS_STRUCT
                     && isInIndentableStruct)
                 (*headerStack).back() = &AS_CLASS;
 
             blockParenDepthStack->push_back(parenDepth);
             blockStatementStack->push_back(isInStatement);
 
             inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
             if (inStatementIndentStack->size() > 0)
             {
                 spaceTabCount = 0;
                 inStatementIndentStack->back() = 0;
             }
 
             blockTabCount += isInStatement ? 1 : 0;
             parenDepth = 0;
             isInStatement = false;
 
             tempStacks->push_back(new vector<const string*>);
             headerStack->push_back(&AS_OPEN_BRACKET);
             lastLineHeader = &AS_OPEN_BRACKET;
 
             continue;
         }
 
         //check if a header has been reached
         bool isPotentialHeader = isCharPotentialHeader(line, i);
 
         if (isPotentialHeader)
         {
             const string *newHeader = findHeader(line, i, headers);
 
             if (newHeader != NULL)
             {
                 char peekChar = peekNextChar(line, i + 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
                 // default(int) keyword in C# is NOT a header
                 else if ((newHeader == &AS_GET || newHeader == &AS_SET || newHeader == &AS_DEFAULT)
                          && (peekChar == ';' ||  peekChar == '('))
                 {
                     newHeader = NULL;
                 }
             }
 
             if (newHeader != NULL)
             {
                 // if we reached here, then this is a header...
                 bool isIndentableHeader = true;
 
                 isInHeader = true;
 
                 vector<const string*> *lastTempStack;
                 if (tempStacks->empty())
                     lastTempStack = NULL;
                 else
                     lastTempStack = tempStacks->back();
 
                 // if a new block is opened, push a new stack into tempStacks to hold the
                 // future list of headers in the new block.
 
                 // take care of the special case: 'else if (...)'
                 if (newHeader == &AS_IF && lastLineHeader == &AS_ELSE)
                 {
                     headerStack->pop_back();
                 }
 
                 // take care of 'else'
                 else if (newHeader == &AS_ELSE)
                 {
                     if (lastTempStack != NULL)
                     {
                         int indexOfIf = indexOf(*lastTempStack, &AS_IF);
                         if (indexOfIf != -1)
                         {
                             // recreate the header list in headerStack up to the previous 'if'
                             // from the temporary snapshot stored in lastTempStack.
                             int restackSize = lastTempStack->size() - indexOfIf - 1;
                             for (int r = 0; r < restackSize; r++)
                             {
                                 headerStack->push_back(lastTempStack->back());
                                 lastTempStack->pop_back();
                             }
                             if (!closingBracketReached)
                                 tabCount += restackSize;
                         }
                         /*
                          * If the above if is not true, i.e. no 'if' before the 'else',
                          * then nothing beautiful will come out of this...
                          * I should think about inserting an Exception here to notify the caller of this...
                          */
                     }
                 }
 
                 // check if 'while' closes a previous 'do'
                 else if (newHeader == &AS_WHILE)
                 {
                     if (lastTempStack != NULL)
                     {
                         int indexOfDo = indexOf(*lastTempStack, &AS_DO);
                         if (indexOfDo != -1)
                         {
                             // recreate the header list in headerStack up to the previous 'do'
                             // from the temporary snapshot stored in lastTempStack.
                             int restackSize = lastTempStack->size() - indexOfDo - 1;
                             for (int r = 0; r < restackSize; r++)
                             {
                                 headerStack->push_back(lastTempStack->back());
                                 lastTempStack->pop_back();
                             }
                             if (!closingBracketReached)
                                 tabCount += restackSize;
                         }
                     }
                 }
                 // check if 'catch' closes a previous 'try' or 'catch'
                 else if (newHeader == &AS_CATCH || newHeader == &AS_FINALLY)
                 {
                     if (lastTempStack != NULL)
                     {
                         int indexOfTry = indexOf(*lastTempStack, &AS_TRY);
                         if (indexOfTry == -1)
                             indexOfTry = indexOf(*lastTempStack, &AS_CATCH);
                         if (indexOfTry != -1)
                         {
                             // recreate the header list in headerStack up to the previous 'try'
                             // from the temporary snapshot stored in lastTempStack.
                             int restackSize = lastTempStack->size() - indexOfTry - 1;
                             for (int r = 0; r < restackSize; r++)
                             {
                                 headerStack->push_back(lastTempStack->back());
                                 lastTempStack->pop_back();
                             }
 
                             if (!closingBracketReached)
                                 tabCount += restackSize;
                         }
                     }
                 }
                 else if (newHeader == &AS_CASE)
                 {
                     isInCase = true;
                     if (!haveCaseIndent)
                     {
                         haveCaseIndent = true;
                         if (!lineBeginsWithBracket)
                             --tabCount;
                     }
                 }
                 else if (newHeader == &AS_DEFAULT)
                 {
                     isInCase = true;
                     --tabCount;
                 }
                 else if (newHeader == &AS_STATIC
                          || newHeader == &AS_SYNCHRONIZED
                          || (newHeader == &AS_CONST && isCStyle()))
                 {
                     if (!headerStack->empty() &&
                             (headerStack->back() == &AS_STATIC
                              || headerStack->back() == &AS_SYNCHRONIZED
                              || headerStack->back() == &AS_CONST))
                     {
                         isIndentableHeader = false;
                     }
                     else
                     {
                         isIndentableHeader = false;
                         probationHeader = newHeader;
                     }
                 }
                 else if (newHeader == &AS_CONST)
                 {
                     isIndentableHeader = false;
                 }
                 else if (newHeader == &AS_TEMPLATE)
                 {
                     if (isCStyle())
                         isInTemplate = true;
                     isIndentableHeader = false;
                 }
 
                 if (isIndentableHeader)
                 {
                     headerStack->push_back(newHeader);
                     isInStatement = false;
                     if (indexOf(*nonParenHeaders, newHeader) == -1)
                     {
                         isInConditional = true;
                     }
                     lastLineHeader = newHeader;
                 }
                 else
                     isInHeader = false;
 
                 outBuffer.append(newHeader->substr(1));
                 i += newHeader->length() - 1;
 
                 continue;
             }  // newHeader != NULL
 
             if (isCStyle() && findKeyword(line, i, AS_ENUM))
                 isInEnum = true;
 
         }   // isPotentialHeader
 
         if (ch == '?')
             isInQuestion = true;
 
         // special handling of 'case' statements
         if (ch == ':')
         {
             if ((int) line.length() > i + 1 && line[i+1] == ':') // look for ::
             {
                 ++i;
                 outBuffer.append(1, ':');
                 ch = ' ';
                 continue;
             }
 
             else if (isInQuestion)
             {
                 isInQuestion = false;
             }
 
             else if (isCStyle() && isInClassInitializer)
             {
                 // found a 'class A : public B' definition
                 // so do nothing special
             }
 
             else if (isCStyle()
                      && (isInAsm || isInAsmOneLine || isInAsmBlock))
             {
                 // do nothing special
             }
 
             else if (isCStyle() && isdigit(peekNextChar(line, i)))
             {
                 // found a bit field
                 // so do nothing special
             }
 
             else if (isCStyle() && isInClass && prevNonSpaceCh != ')')
             {
                 // found a 'private:' or 'public:' inside a class definition
                 --tabCount;
             }
 
             else if (isCStyle() && prevNonSpaceCh == ')' && !isInCase)
             {
                 isInClassInitializer = true;
                 if (i == 0)
                     tabCount += classInitializerTabs;
             }
 
             else if (isJavaStyle() && lastLineHeader == &AS_FOR)
             {
                 // found a java for-each statement
                 // so do nothing special
             }
 
             else
             {
                 currentNonSpaceCh = ';'; // so that brackets after the ':' will appear as block-openers
                 if (isInCase)
                 {
                     isInCase = false;
                     ch = ';'; // from here on, treat char as ';'
                 }
                 else if (isCStyle() || (isSharpStyle() && peekNextChar(line, i) == ';'))    // is in a label (e.g. 'label1:')
                 {
                     if (labelIndent)
                         --tabCount; // unindent label by one indent
                     else if (!lineBeginsWithBracket)
                         tabCount = 0; // completely flush indent to left
                 }
             }
         }
 
         if ((ch == ';'  || (parenDepth > 0 && ch == ','))  && !inStatementIndentStackSizeStack->empty())
             while ((int) inStatementIndentStackSizeStack->back() + (parenDepth > 0 ? 1 : 0)
                     < (int) inStatementIndentStack->size())
                 inStatementIndentStack->pop_back();
 
         // handle commas
         // previous "isInStatement" will be from an assignment operator
         if (ch == ',' && parenDepth == 0 && !isInStatement && !isNonInStatementArray)
         {
             // is comma at end of line
             size_t nextChar = line.find_first_not_of(" \t", i + 1);
             if (nextChar != string::npos)
             {
                 if (line.compare(nextChar, 2, "//") == 0
                         || line.compare(nextChar, 2, "/*") == 0)
                     nextChar = string::npos;
             }
             // register indent
             if (nextChar == string::npos)
             {
                 // register indent at first word after the colon of a C++ class initializer
                 if (isInClassInitializer)
                 {
                     size_t firstChar = line.find_first_not_of(" \t");
                     if (firstChar != string::npos && line[firstChar] == ':')
                     {
                         size_t firstWord = line.find_first_not_of(" \t", firstChar + 1);
                         if (firstChar != string::npos)
                         {
                             int inStatementIndent = firstWord + spaceTabCount + tabIncrementIn;
                             inStatementIndentStack->push_back(inStatementIndent);
                             isInStatement = true;
                         }
                     }
                 }
                 // register indent at previous word
                 else
                 {
                     int prevWord = getInStatementIndentComma(line, i);
                     int inStatementIndent = prevWord + spaceTabCount + tabIncrementIn;
                     inStatementIndentStack->push_back(inStatementIndent);
                     isInStatement = true;
                 }
             }
         }
 
         // handle ends of statements
         if ((ch == ';' && parenDepth == 0) || ch == '}')
         {
             if (ch == '}')
             {
                 // first check if this '}' closes a previous block, or a static array...
                 if (!bracketBlockStateStack->empty())
                 {
                     bool bracketBlockState = bracketBlockStateStack->back();
                     bracketBlockStateStack->pop_back();
                     if (!bracketBlockState)
                     {
                         if (!inStatementIndentStackSizeStack->empty())
                         {
                             // this bracket is a static array
 
                             int previousIndentStackSize = inStatementIndentStackSizeStack->back();
                             inStatementIndentStackSizeStack->pop_back();
                             while (previousIndentStackSize < (int) inStatementIndentStack->size())
                                 inStatementIndentStack->pop_back();
                             parenDepth--;
                             if (i == 0)
                                 shouldIndentBrackettedLine = false;
 
                             if (!parenIndentStack->empty())
                             {
                                 int poppedIndent = parenIndentStack->back();
                                 parenIndentStack->pop_back();
                                 if (i == 0)
                                     spaceTabCount = poppedIndent;
                             }
                         }
                         continue;
                     }
                 }
 
                 // this bracket is block closer...
 
                 ++lineClosingBlocksNum;
 
                 if (!inStatementIndentStackSizeStack->empty())
                     inStatementIndentStackSizeStack->pop_back();
 
                 if (!blockParenDepthStack->empty())
                 {
                     parenDepth = blockParenDepthStack->back();
                     blockParenDepthStack->pop_back();
                     isInStatement = blockStatementStack->back();
                     blockStatementStack->pop_back();
 
                     if (isInStatement)
                         blockTabCount--;
                 }
 
                 closingBracketReached = true;
                 isInAsmOneLine = 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
 
                 int headerPlace = indexOf(*headerStack, &AS_OPEN_BRACKET);
                 if (headerPlace != -1)
                 {
                     const string *popped = headerStack->back();
                     while (popped != &AS_OPEN_BRACKET)
                     {
                         headerStack->pop_back();
                         popped = headerStack->back();
                     }
                     headerStack->pop_back();
 
                     // do not indent namespace bracket unless namespaces are indented
                     if (!namespaceIndent && headerStack->size() > 0
                             && (*headerStack).back() == &AS_NAMESPACE)
                         shouldIndentBrackettedLine = false;
 
                     if (!tempStacks->empty())
                     {
                         vector<const string*> *temp =  tempStacks->back();
                         tempStacks->pop_back();
                         delete temp;
                     }
                 }
 
 
                 ch = ' '; // needed due to cases such as '}else{', so that headers ('else' tn tih case) will be identified...
             }
 
             /*
              * Create a temporary snapshot of the current block's header-list in the
              * uppermost inner stack in tempStacks, and clear the headerStack up to
              * the begining of the block.
              * Thus, the next future statement will think it comes one indent past
              * the block's '{' unless it specifically checks for a companion-header
              * (such as a previous 'if' for an 'else' header) within the tempStacks,
              * and recreates the temporary snapshot by manipulating the tempStacks.
              */
             if (!tempStacks->back()->empty())
                 while (!tempStacks->back()->empty())
                     tempStacks->back()->pop_back();
             while (!headerStack->empty() && headerStack->back() != &AS_OPEN_BRACKET)
             {
                 tempStacks->back()->push_back(headerStack->back());
                 headerStack->pop_back();
             }
 
             if (parenDepth == 0 && ch == ';')
                 isInStatement = false;
 
             previousLastLineHeader = NULL;
             isInClassInitializer = false;
             isInEnum = false;
             isInQuestion = false;
 
             continue;
         }
 
         if (isPotentialHeader)
         {
             // check for preBlockStatements in C/C++ ONLY if not within parenthesies
             // (otherwise 'struct XXX' statements would be wrongly interpreted...)
             if (!isInTemplate && !(isCStyle() && parenDepth > 0))
             {
                 const string *newHeader = findHeader(line, i, preBlockStatements);
                 if (newHeader != NULL
                         && !(isCStyle() && newHeader == &AS_CLASS && isInEnum)) // is it 'enum class'
                 {
                     isInClassInitializer = true;
 
                     if (!isSharpStyle())
                         headerStack->push_back(newHeader);
                     // do not need 'where' in the headerStack
                     // do not need second 'class' statement in a row
                     else if (!(newHeader == &AS_WHERE
                                || (newHeader == &AS_CLASS
                                    && headerStack->size() > 0
                                    && headerStack->back() == &AS_CLASS)))
                         headerStack->push_back(newHeader);
 
                     outBuffer.append(newHeader->substr(1));
                     i += newHeader->length() - 1;
                     continue;
                 }
             }
             const string *foundIndentableHeader = findHeader(line, i, indentableHeaders);
 
             if (foundIndentableHeader != NULL)
             {
                 // must bypass the header before registering the in statement
                 outBuffer.append(foundIndentableHeader->substr(1));
                 i += foundIndentableHeader->length() - 1;
                 if (!isInOperator && !isInTemplate && !isNonInStatementArray)
                 {
                     registerInStatementIndent(line, i, spaceTabCount, tabIncrementIn, 0, false);
                     isInStatement = true;
                 }
                 continue;
             }
 
             if (isCStyle() && findKeyword(line, i, AS_OPERATOR))
                 isInOperator = true;
 
             // "new" operator is a pointer, not a calculation
             if (findKeyword(line, i, AS_NEW))
             {
                 if (prevNonSpaceCh == '=' && isInStatement && !inStatementIndentStack->empty())
                     inStatementIndentStack->back() = 0;
             }
 
             if (isCStyle())
             {
                 if (findKeyword(line, i, AS_ASM)
                         || findKeyword(line, i, AS__ASM__))
                 {
                     isInAsm = true;
                 }
                 else if (findKeyword(line, i, AS_MS_ASM)        // microsoft specific
                          || findKeyword(line, i, AS_MS__ASM))
                 {
                     int index = 4;
                     if (peekNextChar(line, i) == '_')       // check for __asm
                         index = 5;
 
                     char peekedChar = ASBase::peekNextChar(line, i + index);
                     if (peekedChar == '{' || peekedChar == ' ')
                         isInAsmBlock = true;
                     else
                         isInAsmOneLine = true;
                 }
             }
 
             // append the entire name for all others
             string name = getCurrentWord(line, i);
             outBuffer.append(name.substr(1));
             i += name.length() - 1;
             continue;
         }
 
         // Handle operators
 
         bool isPotentialOperator = isCharPotentialOperator(ch);
 
         if (isPotentialOperator)
         {
             // Check if an operator has been reached.
             const string *foundAssignmentOp = findOperator(line, i, assignmentOperators);
             const string *foundNonAssignmentOp = findOperator(line, i, nonAssignmentOperators);
 
             // Since findHeader's boundry checking was not used above, it is possible
             // that both an assignment op and a non-assignment op where found,
             // e.g. '>>' and '>>='. If this is the case, treat the LONGER one as the
             // found operator.
             if (foundAssignmentOp != NULL && foundNonAssignmentOp != NULL)
             {
                 if (foundAssignmentOp->length() < foundNonAssignmentOp->length())
                     foundAssignmentOp = NULL;
                 else
                     foundNonAssignmentOp = NULL;
             }
 
             if (foundNonAssignmentOp != NULL)
             {
                 if (foundNonAssignmentOp->length() > 1)
                 {
                     outBuffer.append(foundNonAssignmentOp->substr(1));
                     i += foundNonAssignmentOp->length() - 1;
                 }
 
                 // For C++ input/output, operator<< and >> should be
                 // aligned, if we are not in a statement already and
                 // also not in the "operator<<(...)" header line
                 if (!isInOperator
                         && inStatementIndentStack->empty()
                         && isCStyle()
                         && (foundNonAssignmentOp == &AS_GR_GR ||
                             foundNonAssignmentOp == &AS_LS_LS))
                 {
                     // this will be true if the line begins with the operator
                     if (i < 2 && spaceTabCount == 0)
                         spaceTabCount += 2 * indentLength;
                     // align to the beginning column of the operator
                     registerInStatementIndent(line, i - foundNonAssignmentOp->length(), spaceTabCount, tabIncrementIn, 0, false);
                 }
             }
 
             else if (foundAssignmentOp != NULL)
             {
                 if (foundAssignmentOp->length() > 1)
                 {
                     outBuffer.append(foundAssignmentOp->substr(1));
                     i += foundAssignmentOp->length() - 1;
                 }
 
                 if (!isInOperator && !isInTemplate && !isNonInStatementArray)
                 {
                     // if multiple assignments, align on the previous word
                     if (foundAssignmentOp == &AS_ASSIGN
                             && prevNonSpaceCh != ']'        // an array
                             && statementEndsWithComma(line, i))
                     {
                         if (!haveAssignmentThisLine)        // only one assignment indent per line
                         {
                             // register indent at previous word
                             haveAssignmentThisLine = true;
                             int prevWordIndex = getInStatementIndentAssign(line, i);
                             int inStatementIndent = prevWordIndex + spaceTabCount + tabIncrementIn;
                             inStatementIndentStack->push_back(inStatementIndent);
                         }
                     }
                     else
                         registerInStatementIndent(line, i, spaceTabCount, tabIncrementIn, 0, false);
 
                     isInStatement = true;
                 }
             }
         }
     }   // end of for loop * end of for loop * end of for loop * end of for loop * end of for loop *
 
     // handle special cases of unindentation:
 
     /*
      * if '{' doesn't follow an immediately previous '{' in the headerStack
      * (but rather another header such as "for" or "if", then unindent it
      * by one indentation relative to its block.
      */
 
     if (!lineStartsInComment
             && !blockIndent
             && outBuffer.length() > 0
             && outBuffer[0] == '{'
             && !(lineOpeningBlocksNum > 0 && lineOpeningBlocksNum == lineClosingBlocksNum)
             && !(headerStack->size() > 1 && (*headerStack)[headerStack->size()-2] == &AS_OPEN_BRACKET)
             && shouldIndentBrackettedLine)
         --tabCount;
 
     // must check one less in headerStack if more than one header on a line (allow-addins)...
     else if (!lineStartsInComment
              && (int) headerStack->size() > iPrelim + 1
              && !blockIndent
              && outBuffer.length() > 0
              && outBuffer[0] == '{'
              && !(lineOpeningBlocksNum > 0 && lineOpeningBlocksNum == lineClosingBlocksNum)
              && !(headerStack->size() > 2 && (*headerStack)[headerStack->size()-3] == &AS_OPEN_BRACKET)
              && shouldIndentBrackettedLine)
         --tabCount;
 
     // unindent a closing bracket...
     else if (!lineStartsInComment
              && outBuffer.length() > 0
              && outBuffer[0] == '}'
              && shouldIndentBrackettedLine)
         --tabCount;
 
     // correctly indent one-line-blocks...
     else if (!lineStartsInComment
              && outBuffer.length() > 0
              && lineOpeningBlocksNum > 0
              && lineOpeningBlocksNum == lineClosingBlocksNum
              && previousLineProbationTab)
         --tabCount; //lineOpeningBlocksNum - (blockIndent ? 1 : 0);
 
     // correctly indent class continuation lines...
     else if (!lineStartsInComment
              && !lineOpensComment
              && isInClassHeaderTab
              && !blockIndent
              && outBuffer.length() > 0
              && lineOpeningBlocksNum == 0
              && lineOpeningBlocksNum == lineClosingBlocksNum
              && (headerStack->size() > 0 && headerStack->back() == &AS_CLASS))
         --tabCount;
 
     if (tabCount < 0)
         tabCount = 0;
 
     // take care of extra bracket indentatation option...
     if (!lineStartsInComment
             && bracketIndent
             && shouldIndentBrackettedLine
             && outBuffer.length() > 0
             && (outBuffer[0] == '{' || outBuffer[0] == '}'))
         tabCount++;
 
     if (isInDefine)
     {
         if (outBuffer[0] == '#')
         {
             string preproc = trim(string(outBuffer.c_str() + 1));
             if (preproc.compare(0, 6, "define") == 0)
             {
                 if (!inStatementIndentStack->empty()
                         && inStatementIndentStack->back() > 0)
                 {
                     defineTabCount = tabCount;
                 }
                 else
                 {
                     defineTabCount = tabCount - 1;
                     tabCount--;
                 }
             }
         }
 
         tabCount -= defineTabCount;
     }
 
     if (tabCount < 0)
         tabCount = 0;
     if (lineCommentNoBeautify || blockCommentNoBeautify || isInQuoteContinuation)
         tabCount = spaceTabCount = 0;
 
     // finally, insert indentations into begining of line
 
     if (shouldForceTabIndentation)
     {
         tabCount += spaceTabCount / indentLength;
         spaceTabCount = spaceTabCount % indentLength;
     }
 
     outBuffer = preLineWS(spaceTabCount, tabCount) + outBuffer;
 
     prevFinalLineSpaceTabCount = spaceTabCount;
     prevFinalLineTabCount = tabCount;
 
     if (lastLineHeader != NULL)
         previousLastLineHeader = lastLineHeader;
 
     return outBuffer;
 }
 
 
 string ASBeautifier::preLineWS(int spaceTabCount, int tabCount)
 {
     string ws;
 
     for (int i = 0; i < tabCount; i++)
         ws += indentString;
 
     while ((spaceTabCount--) > 0)
         ws += string(" ");
 
     return ws;
 
 }
 
 bool ASBeautifier::isClassAccessModifier(string& line) const
 {
     size_t firstChar = line.find_first_not_of(" \t");
     if (firstChar == string::npos)
         return false;
     // bypass a colon
     if (line[firstChar] == ':')
     {
         firstChar = line.find_first_not_of(" \t");
         if (firstChar == string::npos)
             return false;
     }
     if (line.compare(firstChar, 7, "public ") == 0
             || line.compare(firstChar, 8, "private ") == 0
             || line.compare(firstChar, 10, "protected ") == 0)
         return true;
     return false;
 }
 
 /**
  * register an in-statement indent.
  */
 void ASBeautifier::registerInStatementIndent(const string &line, int i, int spaceTabCount,
         int tabIncrementIn, int minIndent, bool updateParenStack)
 {
     int inStatementIndent;
     int remainingCharNum = line.length() - i;
     int nextNonWSChar = getNextProgramCharDistance(line, i);
 
     // if indent is around the last char in the line, indent instead one indent from the previous indent
     if (nextNonWSChar == remainingCharNum)
     {
         int previousIndent = spaceTabCount;
         if (!inStatementIndentStack->empty())
             previousIndent = inStatementIndentStack->back();
         int currIndent = /*2*/ indentLength + previousIndent;
         if (currIndent > maxInStatementIndent
                 && line[i] != '{')
             currIndent = indentLength * 2 + spaceTabCount;
         inStatementIndentStack->push_back(currIndent);
         if (updateParenStack)
             parenIndentStack->push_back(previousIndent);
         return;
     }
 
     if (updateParenStack)
         parenIndentStack->push_back(i + spaceTabCount - horstmannIndentInStatement);
 
     int tabIncrement = tabIncrementIn;
 
     // check for following tabs
     for (int j = i + 1; j < (i + nextNonWSChar); j++)
     {
         if (line[j] == '\t')
             tabIncrement += convertTabToSpaces(j, tabIncrement);
     }
 
     inStatementIndent = i + nextNonWSChar + spaceTabCount + tabIncrement;
 
     // check for run-in statement
     if (i > 0 && line[0] == '{')
         inStatementIndent -= indentLength;
 
 //  if (i + nextNonWSChar < minIndent)
 //      inStatementIndent = minIndent + spaceTabCount;
 
     if (inStatementIndent < minIndent)
         inStatementIndent = minIndent + spaceTabCount;
 
 //  if (i + nextNonWSChar > maxInStatementIndent)
 //      inStatementIndent =  indentLength * 2 + spaceTabCount;
 
     if (inStatementIndent > maxInStatementIndent)
         inStatementIndent = indentLength * 2 + spaceTabCount;
 
     if (!inStatementIndentStack->empty() &&
             inStatementIndent < inStatementIndentStack->back())
         inStatementIndent = inStatementIndentStack->back();
 
     // the block opener is not indented for a NonInStatementArray
     if (isNonInStatementArray && !bracketBlockStateStack->empty() && bracketBlockStateStack->back())
         inStatementIndent = 0;
 
     inStatementIndentStack->push_back(inStatementIndent);
 }
 
 /**
  * get distance to the next non-white space, non-comment character in the line.
  * if no such character exists, return the length remaining to the end of the line.
  */
 int ASBeautifier::getNextProgramCharDistance(const string &line, int i) const
 {
     bool inComment = false;
     int  remainingCharNum = line.length() - i;
     int  charDistance;
     char ch;
 
     for (charDistance = 1; charDistance < remainingCharNum; charDistance++)
     {
         ch = line[i + charDistance];
         if (inComment)
         {
             if (line.compare(i + charDistance, 2, "*/") == 0)
             {
                 charDistance++;
                 inComment = false;
             }
             continue;
         }
         else if (isWhiteSpace(ch))
             continue;
         else if (ch == '/')
         {
             if (line.compare(i + charDistance, 2, "//") == 0)
                 return remainingCharNum;
             else if (line.compare(i + charDistance, 2, "/*") == 0)
             {
                 charDistance++;
                 inComment = true;
             }
         }
         else
             return charDistance;
     }
 
     return charDistance;
 }
 
 // check if a specific line position contains a header.
 const string* ASBeautifier::findHeader(const string &line, int i,
                                        const vector<const string*>* possibleHeaders) const
 {
     assert(isCharPotentialHeader(line, i));
     // check the word
     size_t maxHeaders = possibleHeaders->size();
     for (size_t p = 0; p < maxHeaders; p++)
     {
         const string* header = (*possibleHeaders)[p];
         const size_t wordEnd = i + header->length();
         if (wordEnd > line.length())
             continue;
         int result = (line.compare(i, header->length(), *header));
         if (result > 0)
             continue;
         if (result < 0)
             break;
         // check that this is not part of a longer word
         if (wordEnd == line.length())
             return header;
         if (isLegalNameChar(line[wordEnd]))
             continue;
         // is not a header if part of a definition
         const char peekChar = peekNextChar(line, wordEnd - 1);
         if (peekChar == ',' || peekChar == ')')
             break;
         return header;
     }
     return NULL;
 }
 
 // check if a specific line position contains an operator.
 const string* ASBeautifier::findOperator(const string &line, int i,
         const vector<const string*>* possibleOperators) const
 {
     assert(isCharPotentialOperator(line[i]));
     // find the operator in the vector
     // the vector contains the LONGEST operators first
     // must loop thru the entire vector
     size_t maxOperators = possibleOperators->size();
     for (size_t p = 0; p < maxOperators; p++)
     {
         const size_t wordEnd = i + (*(*possibleOperators)[p]).length();
         if (wordEnd > line.length())
             continue;
         if (line.compare(i, (*(*possibleOperators)[p]).length(), *(*possibleOperators)[p]) == 0)
             return (*possibleOperators)[p];
     }
     return NULL;
 }
 
 /**
  * find the index number of a string element in a container of strings
  *
  * @return              the index number of element in the container. -1 if element not found.
  * @param container     a vector of strings.
  * @param element       the element to find .
  */
 int ASBeautifier::indexOf(vector<const string*> &container, const string *element)
 {
     vector<const string*>::const_iterator where;
 
     where = find(container.begin(), container.end(), element);
     if (where == container.end())
         return -1;
     else
         return (int) (where - container.begin());
 }
 
 /**
  * convert tabs to spaces.
  * i is the position of the 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.
  */
 int ASBeautifier::convertTabToSpaces(int i, int tabIncrementIn) const
 {
     int tabToSpacesAdjustment = indentLength - 1 - ((tabIncrementIn + i) % indentLength);
     return tabToSpacesAdjustment;
 }
 
 /**
  * trim removes the white space surrounding a line.
  *
  * @return          the trimmed line.
  * @param str       the line to trim.
  */
 string ASBeautifier::trim(const string &str)
 {
 
     int start = 0;
     int end = str.length() - 1;
 
     while (start < end && isWhiteSpace(str[start]))
         start++;
 
     while (start <= end && isWhiteSpace(str[end]))
         end--;
 
     string returnStr(str, start, end + 1 - start);
     return returnStr;
 }
 
 /**
  * Copy tempStacks for the copy constructor.
  * The value of the vectors must also be copied.
  */
 vector<vector<const string*>*>* ASBeautifier::copyTempStacks(const ASBeautifier &other) const
 {
     vector<vector<const string*>*> *tempStacksNew = new vector<vector<const string*>*>;
     vector<vector<const string*>*>::iterator iter;
     for (iter = other.tempStacks->begin();
             iter != other.tempStacks->end();
             ++iter)
     {
         vector<const string*> *newVec = new vector<const string*>;
         *newVec = **iter;
         tempStacksNew->push_back(newVec);
     }
     return tempStacksNew;
 }
 
 /**
  * delete a static member vector to eliminate memory leak reporting for the vector
  */
 void ASBeautifier::deleteStaticVectors()
 {
     beautifierFileType = 9;     // reset to an invalid type
     deleteVector(headers);
     deleteVector(nonParenHeaders);
     deleteVector(preBlockStatements);
     deleteVector(assignmentOperators);
     deleteVector(nonAssignmentOperators);
     deleteVector(indentableHeaders);
 }
 
 /**
  * delete a vector object
  * T is the type of vector
  * used for all vectors except tempStacks
  */
 template<typename T>
 void ASBeautifier::deleteContainer(T &container)
 {
     if (container != NULL)
     {
         container->clear();
         delete (container);
         container = NULL;
     }
 }
 
 /**
  * Delete the tempStacks vector object.
  * The tempStacks is a vector of pointers to strings allocated with
  * the 'new' operator.
  * Therefore the strings have to be deleted in addition to the
  * tempStacks entries.
  */
 void ASBeautifier::deleteContainer(vector<vector<const string*>*>* &container)
 {
     if (container != NULL)
     {
         vector<vector<const string*>*>::iterator iter = container->begin();
         for (; iter != container->end(); iter++)
             delete *iter;
         container->clear();
         delete (container);
         container = NULL;
     }
 }
 
 /**
  * delete a vector<const string*>* object
  */
 void ASBeautifier::deleteVector(vector<const string*>*& container)
 {
     assert(container != NULL);
     delete container;
     container = NULL;
 }
 
 /**
  * initialize a vector object
  * T is the type of vector
  * used for all vectors
  */
 template<typename T>
 void ASBeautifier::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;
 }
 
 /**
  * initialize a vector<const string*>* object
  */
 void ASBeautifier::initVector(vector<const string*>*& container)
 {
     assert(container == NULL);
     container = new vector<const string*>;
 }
 
 /**
  * Determine if an assignment statement ends with a comma
  *     that is not in a function argument. It ends with a
  *     comma if a comma is the last char on the line.
  *
  * @return  true if line ends with a comma, otherwise false.
  */
 bool ASBeautifier::statementEndsWithComma(string &line, int index)
 {
     assert(line[index] == '=');
 
     bool isInComment = false;
     bool isInQuote = false;
     int parenCount = 0;
     size_t lineLength = line.length();
     size_t i = 0;
     char quoteChar = ' ';
 
     for (i = index + 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)
         {
             if (isLineEndComment(line, i))
                 break;
             else
             {
                 isInComment = true;
                 ++i;
                 continue;
             }
         }
 
         if (ch == '(')
             parenCount++;
         if (ch == ')')
             parenCount--;
     }
     if (isInComment
             || isInQuote
             || parenCount > 0)
         return false;
 
     size_t lastChar = line.find_last_not_of(" \t", i - 1);
 
     if (lastChar == string::npos || line[lastChar] != ',')
         return false;
 
     return true;
 }
 
 /**
  * check if current comment is a line-end comment
  *
  * @return     is before a line-end comment.
  */
 bool ASBeautifier::isLineEndComment(string& line, int startPos) const
 {
     assert(line.compare(startPos, 2, "/*") == 0);
 
     // comment must be closed on this line with nothing after it
     size_t endNum = line.find("*/", startPos + 2);
     if (endNum != string::npos)
     {
         size_t nextChar = line.find_first_not_of(" \t", endNum + 2);
         if (nextChar == string::npos)
             return true;
     }
     return false;
 }
 
 /**
  * get the previous word index for an assignment operator
  *
  * @return is the index to the previous word (the in statement indent).
  */
 int ASBeautifier::getInStatementIndentAssign(const string& line, size_t currPos) const
 {
     assert(line[currPos] == '=');
 
     if (currPos == 0)
         return 0;
 
     // get the last legal word (may be a number)
     size_t end = line.find_last_not_of(" \t", currPos-1);
     if (end == string::npos || !isLegalNameChar(line[end]))
         return 0;
 
     int start;          // start of the previous word
     for (start = end; start > -1; start--)
     {
         if (!isLegalNameChar(line[start]) || line[start] == '.')
             break;
     }
     start++;
 
     return start;
 }
 
 /**
  * get the instatement indent for a comma
  *
  * @return is the indent to the second word on the line (the in statement indent).
  */
 int ASBeautifier::getInStatementIndentComma(const string& line, size_t currPos) const
 {
     assert(line[currPos] == ',');
 
     if (currPos == 0)
         return 0;
 
     // get first word on a line
     size_t indent = line.find_first_not_of(" \t");
     if (indent == string::npos || !isLegalNameChar(line[indent]))
         return 0;
 
     // bypass first word
     for (; indent < currPos; indent++)
     {
         if (!isLegalNameChar(line[indent]))
             break;
     }
     indent++;
     if (indent >= currPos)
         return 0;
 
     // point to second word or assignment operator
     indent = line.find_last_not_of(" \t", indent);
     if (indent == string::npos || indent >= currPos)
         return 0;
 
     return indent;
 }
 
 
 }   // end namespace astyle