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

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

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

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

1 files changed, 1056 insertions, 0 deletions

diff --git a/thirdparty/astyle/astyle.h b/thirdparty/astyle/astyle.h
new file mode 100755
index 00000000..54ef227c
--- /dev/null
+++ b/thirdparty/astyle/astyle.h
@@ -0,0 +1,1056 @@
+// astyle.h
+// Copyright (c) 2017 by Jim Pattee <jimp03@email.com>.
+// This code is licensed under the MIT License.
+// License.md describes the conditions under which this software may be distributed.
+
+#ifndef ASTYLE_H
+#define ASTYLE_H
+
+//-----------------------------------------------------------------------------
+// headers
+//-----------------------------------------------------------------------------
+
+#ifdef __VMS
+	#define __USE_STD_IOSTREAM 1
+	#include <assert>
+#else
+	#include <cassert>
+#endif
+
+#include <cctype>
+#include <iostream>		// for cout
+#include <memory>
+#include <string>
+#include <vector>
+
+#ifdef __GNUC__
+	#include <cstring>              // need both string and cstring for GCC
+#endif
+
+//-----------------------------------------------------------------------------
+// declarations
+//-----------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+	#pragma warning(disable: 4267)  // conversion from size_t to int
+#endif
+
+#ifdef __BORLANDC__
+	#pragma warn -8004	            // variable is assigned a value that is never used
+#endif
+
+#ifdef __INTEL_COMPILER
+	#pragma warning(disable:  383)  // value copied to temporary, reference to temporary used
+	#pragma warning(disable:  981)  // operands are evaluated in unspecified order
+#endif
+
+#ifdef __clang__
+	#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+
+//-----------------------------------------------------------------------------
+// astyle namespace
+//-----------------------------------------------------------------------------
+
+namespace astyle {
+//
+using namespace std;
+
+//----------------------------------------------------------------------------
+// definitions
+//----------------------------------------------------------------------------
+
+enum FileType { C_TYPE = 0, JAVA_TYPE = 1, SHARP_TYPE = 2 };
+
+/* The enums below are not recognized by 'vectors' in Microsoft Visual C++
+   V5 when they are part of a namespace!!!  Use Visual C++ V6 or higher.
+*/
+enum FormatStyle
+{
+	STYLE_NONE,
+	STYLE_ALLMAN,
+	STYLE_JAVA,
+	STYLE_KR,
+	STYLE_STROUSTRUP,
+	STYLE_WHITESMITH,
+	STYLE_VTK,
+	STYLE_BANNER,
+	STYLE_GNU,
+	STYLE_LINUX,
+	STYLE_HORSTMANN,
+	STYLE_1TBS,
+	STYLE_GOOGLE,
+	STYLE_MOZILLA,
+	STYLE_PICO,
+	STYLE_LISP
+};
+
+enum BraceMode
+{
+	NONE_MODE,
+	ATTACH_MODE,
+	BREAK_MODE,
+	LINUX_MODE,
+	RUN_IN_MODE		// broken braces
+};
+
+// maximun value for int is 16,384 (total value of 32,767)
+enum BraceType
+{
+	NULL_TYPE        = 0,
+	NAMESPACE_TYPE   = 1,		// also a DEFINITION_TYPE
+	CLASS_TYPE       = 2,		// also a DEFINITION_TYPE
+	STRUCT_TYPE      = 4,		// also a DEFINITION_TYPE
+	INTERFACE_TYPE   = 8,		// also a DEFINITION_TYPE
+	DEFINITION_TYPE  = 16,
+	COMMAND_TYPE     = 32,
+	ARRAY_NIS_TYPE   = 64,		// also an ARRAY_TYPE
+	ENUM_TYPE        = 128,		// also an ARRAY_TYPE
+	INIT_TYPE        = 256,		// also an ARRAY_TYPE
+	ARRAY_TYPE       = 512,
+	EXTERN_TYPE      = 1024,	// extern "C", not a command type extern
+	EMPTY_BLOCK_TYPE = 2048,	// also a SINGLE_LINE_TYPE
+	BREAK_BLOCK_TYPE = 4096,	// also a SINGLE_LINE_TYPE
+	SINGLE_LINE_TYPE = 8192
+};
+
+enum MinConditional
+{
+	MINCOND_ZERO,
+	MINCOND_ONE,
+	MINCOND_TWO,
+	MINCOND_ONEHALF,
+	MINCOND_END
+};
+
+enum ObjCColonPad
+{
+	COLON_PAD_NO_CHANGE,
+	COLON_PAD_NONE,
+	COLON_PAD_ALL,
+	COLON_PAD_AFTER,
+	COLON_PAD_BEFORE
+};
+
+enum PointerAlign
+{
+	PTR_ALIGN_NONE,
+	PTR_ALIGN_TYPE,
+	PTR_ALIGN_MIDDLE,
+	PTR_ALIGN_NAME
+};
+
+enum ReferenceAlign
+{
+	REF_ALIGN_NONE   = PTR_ALIGN_NONE,
+	REF_ALIGN_TYPE   = PTR_ALIGN_TYPE,
+	REF_ALIGN_MIDDLE = PTR_ALIGN_MIDDLE,
+	REF_ALIGN_NAME   = PTR_ALIGN_NAME,
+	REF_SAME_AS_PTR
+};
+
+enum FileEncoding
+{
+	ENCODING_8BIT,
+	UTF_16BE,
+	UTF_16LE,     // Windows default
+	UTF_32BE,
+	UTF_32LE
+};
+
+enum LineEndFormat
+{
+	LINEEND_DEFAULT,	// Use line break that matches most of the file
+	LINEEND_WINDOWS,
+	LINEEND_LINUX,
+	LINEEND_MACOLD,
+	LINEEND_CRLF = LINEEND_WINDOWS,
+	LINEEND_LF   = LINEEND_LINUX,
+	LINEEND_CR   = LINEEND_MACOLD
+};
+
+//-----------------------------------------------------------------------------
+// Class ASSourceIterator
+// A pure virtual class is used by ASFormatter and ASBeautifier instead of
+// ASStreamIterator. This allows programs using AStyle as a plug-in to define
+// their own ASStreamIterator. The ASStreamIterator class must inherit
+// this class.
+//-----------------------------------------------------------------------------
+
+class ASSourceIterator
+{
+public:
+	ASSourceIterator() {}
+	virtual ~ASSourceIterator() {}
+	virtual int getStreamLength() const = 0;
+	virtual bool hasMoreLines() const = 0;
+	virtual string nextLine(bool emptyLineWasDeleted = false) = 0;
+	virtual string peekNextLine() = 0;
+	virtual void peekReset() = 0;
+	virtual streamoff tellg() = 0;
+};
+
+//-----------------------------------------------------------------------------
+// Class ASPeekStream
+// A small class using RAII to peek ahead in the ASSourceIterator stream
+// and to reset the ASSourceIterator pointer in the destructor.
+// It enables a return from anywhere in the method.
+//-----------------------------------------------------------------------------
+
+class ASPeekStream
+{
+private:
+	ASSourceIterator* sourceIterator;
+	bool needReset;		// reset sourceIterator to the original position
+
+public:
+	explicit ASPeekStream(ASSourceIterator* sourceIterator_)
+	{ sourceIterator = sourceIterator_; needReset = false; }
+
+	~ASPeekStream()
+	{ if (needReset) sourceIterator->peekReset(); }
+
+	bool hasMoreLines() const
+	{ return sourceIterator->hasMoreLines(); }
+
+	string peekNextLine()
+	{ needReset = true; return sourceIterator->peekNextLine(); }
+};
+
+
+//-----------------------------------------------------------------------------
+// Class ASResource
+//-----------------------------------------------------------------------------
+
+class ASResource
+{
+public:
+	void buildAssignmentOperators(vector<const string*>* assignmentOperators);
+	void buildCastOperators(vector<const string*>* castOperators);
+	void buildHeaders(vector<const string*>* headers, int fileType, bool beautifier = false);
+	void buildIndentableMacros(vector<const pair<const string, const string>* >* indentableMacros);
+	void buildIndentableHeaders(vector<const string*>* indentableHeaders);
+	void buildNonAssignmentOperators(vector<const string*>* nonAssignmentOperators);
+	void buildNonParenHeaders(vector<const string*>* nonParenHeaders, int fileType, bool beautifier = false);
+	void buildOperators(vector<const string*>* operators, int fileType);
+	void buildPreBlockStatements(vector<const string*>* preBlockStatements, int fileType);
+	void buildPreCommandHeaders(vector<const string*>* preCommandHeaders, int fileType);
+	void buildPreDefinitionHeaders(vector<const string*>* preDefinitionHeaders, int fileType);
+
+public:
+	static const string AS_IF, AS_ELSE;
+	static const string AS_DO, AS_WHILE;
+	static const string AS_FOR;
+	static const string AS_SWITCH, AS_CASE, AS_DEFAULT;
+	static const string AS_TRY, AS_CATCH, AS_THROW, AS_THROWS, AS_FINALLY, AS_USING;
+	static const string _AS_TRY, _AS_FINALLY, _AS_EXCEPT;
+	static const string AS_PUBLIC, AS_PROTECTED, AS_PRIVATE;
+	static const string AS_CLASS, AS_STRUCT, AS_UNION, AS_INTERFACE, AS_NAMESPACE;
+	static const string AS_MODULE;
+	static const string AS_END;
+	static const string AS_SELECTOR;
+	static const string AS_EXTERN, AS_ENUM;
+	static const string AS_STATIC, AS_CONST, AS_SEALED, AS_OVERRIDE, AS_VOLATILE, AS_NEW, AS_DELETE;
+	static const string AS_NOEXCEPT, AS_INTERRUPT, AS_AUTORELEASEPOOL;
+	static const string AS_WHERE, AS_LET, AS_SYNCHRONIZED;
+	static const string AS_OPERATOR, AS_TEMPLATE;
+	static const string AS_OPEN_BRACE, AS_CLOSE_BRACE;
+	static const string AS_OPEN_LINE_COMMENT, AS_OPEN_COMMENT, AS_CLOSE_COMMENT;
+	static const string AS_BAR_DEFINE, AS_BAR_INCLUDE, AS_BAR_IF, AS_BAR_EL, AS_BAR_ENDIF;
+	static const string AS_AUTO, AS_RETURN;
+	static const string AS_CIN, AS_COUT, AS_CERR;
+	static const string AS_ASSIGN, AS_PLUS_ASSIGN, AS_MINUS_ASSIGN, AS_MULT_ASSIGN;
+	static const string AS_DIV_ASSIGN, AS_MOD_ASSIGN, AS_XOR_ASSIGN, AS_OR_ASSIGN, AS_AND_ASSIGN;
+	static const string AS_GR_GR_ASSIGN, AS_LS_LS_ASSIGN, AS_GR_GR_GR_ASSIGN, AS_LS_LS_LS_ASSIGN;
+	static const string AS_GCC_MIN_ASSIGN, AS_GCC_MAX_ASSIGN;
+	static const string AS_EQUAL, AS_PLUS_PLUS, AS_MINUS_MINUS, AS_NOT_EQUAL, AS_GR_EQUAL;
+	static const string AS_LS_EQUAL, AS_LS_LS_LS, AS_LS_LS, AS_GR_GR_GR, AS_GR_GR;
+	static const string AS_QUESTION_QUESTION, AS_LAMBDA;
+	static const string AS_ARROW, AS_AND, AS_OR;
+	static const string AS_SCOPE_RESOLUTION;
+	static const string AS_PLUS, AS_MINUS, AS_MULT, AS_DIV, AS_MOD, AS_GR, AS_LS;
+	static const string AS_NOT, AS_BIT_XOR, AS_BIT_OR, AS_BIT_AND, AS_BIT_NOT;
+	static const string AS_QUESTION, AS_COLON, AS_SEMICOLON, AS_COMMA;
+	static const string AS_ASM, AS__ASM__, AS_MS_ASM, AS_MS__ASM;
+	static const string AS_QFOREACH, AS_QFOREVER, AS_FOREVER;
+	static const string AS_FOREACH, AS_LOCK, AS_UNSAFE, AS_FIXED;
+	static const string AS_GET, AS_SET, AS_ADD, AS_REMOVE;
+	static const string AS_DELEGATE, AS_UNCHECKED;
+	static const string AS_CONST_CAST, AS_DYNAMIC_CAST, AS_REINTERPRET_CAST, AS_STATIC_CAST;
+	static const string AS_NS_DURING, AS_NS_HANDLER;
+};  // Class ASResource
+
+//-----------------------------------------------------------------------------
+// Class ASBase
+// Functions definitions are at the end of ASResource.cpp.
+//-----------------------------------------------------------------------------
+
+class ASBase : protected ASResource
+{
+private:
+	// all variables should be set by the "init" function
+	int baseFileType;      // a value from enum FileType
+
+protected:
+	ASBase() : baseFileType(C_TYPE) { }
+
+protected:  // inline functions
+	void init(int fileTypeArg) { baseFileType = fileTypeArg; }
+	bool isCStyle() const { return (baseFileType == C_TYPE); }
+	bool isJavaStyle() const { return (baseFileType == JAVA_TYPE); }
+	bool isSharpStyle() const { return (baseFileType == SHARP_TYPE); }
+	bool isWhiteSpace(char ch) const { return (ch == ' ' || ch == '\t'); }
+
+protected:  // functions definitions are at the end of ASResource.cpp
+	const string* findHeader(const string& line, int i,
+	                         const vector<const string*>* possibleHeaders) const;
+	bool findKeyword(const string& line, int i, const string& keyword) const;
+	const string* findOperator(const string& line, int i,
+	                           const vector<const string*>* possibleOperators) const;
+	string getCurrentWord(const string& line, size_t index) const;
+	bool isDigit(char ch) const;
+	bool isLegalNameChar(char ch) const;
+	bool isCharPotentialHeader(const string& line, size_t i) const;
+	bool isCharPotentialOperator(char ch) const;
+	bool isDigitSeparator(const string& line, int i) const;
+	char peekNextChar(const string& line, int i) const;
+
+};  // Class ASBase
+
+//-----------------------------------------------------------------------------
+// Class ASBeautifier
+//-----------------------------------------------------------------------------
+
+class ASBeautifier : protected ASBase
+{
+public:
+	ASBeautifier();
+	virtual ~ASBeautifier();
+	virtual void init(ASSourceIterator* iter);
+	virtual string beautify(const string& originalLine);
+	void setCaseIndent(bool state);
+	void setClassIndent(bool state);
+	void setContinuationIndentation(int indent = 1);
+	void setCStyle();
+	void setDefaultTabLength();
+	void setEmptyLineFill(bool state);
+	void setForceTabXIndentation(int length);
+	void setAfterParenIndent(bool state);
+	void setJavaStyle();
+	void setLabelIndent(bool state);
+	void setMaxContinuationIndentLength(int max);
+	void setMaxInStatementIndentLength(int max);
+	void setMinConditionalIndentOption(int min);
+	void setMinConditionalIndentLength();
+	void setModeManuallySet(bool state);
+	void setModifierIndent(bool state);
+	void setNamespaceIndent(bool state);
+	void setAlignMethodColon(bool state);
+	void setSharpStyle();
+	void setSpaceIndentation(int length = 4);
+	void setSwitchIndent(bool state);
+	void setTabIndentation(int length = 4, bool forceTabs = false);
+	void setPreprocDefineIndent(bool state);
+	void setPreprocConditionalIndent(bool state);
+	int  getBeautifierFileType() const;
+	int  getFileType() const;
+	int  getIndentLength() const;
+	int  getTabLength() const;
+	string getIndentString() const;
+	string getNextWord(const string& line, size_t currPos) const;
+	bool getAlignMethodColon() const;
+	bool getBraceIndent() const;
+	bool getBlockIndent() const;
+	bool getCaseIndent() const;
+	bool getClassIndent() const;
+	bool getEmptyLineFill() const;
+	bool getForceTabIndentation() const;
+	bool getModeManuallySet() const;
+	bool getModifierIndent() const;
+	bool getNamespaceIndent() const;
+	bool getPreprocDefineIndent() const;
+	bool getSwitchIndent() const;
+
+protected:
+	void deleteBeautifierVectors();
+	int  getNextProgramCharDistance(const string& line, int i) const;
+	int  indexOf(const vector<const string*>& container, const string* element) const;
+	void setBlockIndent(bool state);
+	void setBraceIndent(bool state);
+	void setBraceIndentVtk(bool state);
+	string extractPreprocessorStatement(const string& line) const;
+	string trim(const string& str) const;
+	string rtrim(const string& str) const;
+
+	// variables set by ASFormatter - must be updated in activeBeautifierStack
+	int  inLineNumber;
+	int  runInIndentContinuation;
+	int  nonInStatementBrace;
+	int  objCColonAlignSubsequent;		// for subsequent lines not counting indent
+	bool lineCommentNoBeautify;
+	bool isElseHeaderIndent;
+	bool isCaseHeaderCommentIndent;
+	bool isNonInStatementArray;
+	bool isSharpAccessor;
+	bool isSharpDelegate;
+	bool isInExternC;
+	bool isInBeautifySQL;
+	bool isInIndentableStruct;
+	bool isInIndentablePreproc;
+
+private:  // functions
+	ASBeautifier(const ASBeautifier& other);     // inline functions
+	ASBeautifier& operator=(ASBeautifier&);      // not to be implemented
+
+	void adjustObjCMethodDefinitionIndentation(const string& line_);
+	void adjustObjCMethodCallIndentation(const string& line_);
+	void adjustParsedLineIndentation(size_t iPrelim, bool isInExtraHeaderIndent);
+	void computePreliminaryIndentation();
+	void parseCurrentLine(const string& line);
+	void popLastContinuationIndent();
+	void processPreprocessor(const string& preproc, const string& line);
+	void registerContinuationIndent(const string& line, int i, int spaceIndentCount_,
+	                                int tabIncrementIn, int minIndent, bool updateParenStack);
+	void registerContinuationIndentColon(const string& line, int i, int tabIncrementIn);
+	void initVectors();
+	void initTempStacksContainer(vector<vector<const string*>*>*& container,
+	                             vector<vector<const string*>*>* value);
+	void clearObjCMethodDefinitionAlignment();
+	void deleteBeautifierContainer(vector<ASBeautifier*>*& container);
+	void deleteTempStacksContainer(vector<vector<const string*>*>*& container);
+	int  adjustIndentCountForBreakElseIfComments() const;
+	int  computeObjCColonAlignment(const string& line, int colonAlignPosition) const;
+	int  convertTabToSpaces(int i, int tabIncrementIn) const;
+	int  getContinuationIndentAssign(const string& line, size_t currPos) const;
+	int  getContinuationIndentComma(const string& line, size_t currPos) const;
+	int  getObjCFollowingKeyword(const string& line, int bracePos) const;
+	bool isIndentedPreprocessor(const string& line, size_t currPos) const;
+	bool isLineEndComment(const string& line, int startPos) const;
+	bool isPreprocessorConditionalCplusplus(const string& line) const;
+	bool isInPreprocessorUnterminatedComment(const string& line);
+	bool statementEndsWithComma(const string& line, int index) const;
+	const string& getIndentedLineReturn(const string& newLine, const string& originalLine) const;
+	string getIndentedSpaceEquivalent(const string& line_) const;
+	string preLineWS(int lineIndentCount, int lineSpaceIndentCount) const;
+	template<typename T> void deleteContainer(T& container);
+	template<typename T> void initContainer(T& container, T value);
+	vector<vector<const string*>*>* copyTempStacks(const ASBeautifier& other) const;
+	pair<int, int> computePreprocessorIndent();
+
+private:  // variables
+	int beautifierFileType;
+	vector<const string*>* headers;
+	vector<const string*>* nonParenHeaders;
+	vector<const string*>* preBlockStatements;
+	vector<const string*>* preCommandHeaders;
+	vector<const string*>* assignmentOperators;
+	vector<const string*>* nonAssignmentOperators;
+	vector<const string*>* indentableHeaders;
+
+	vector<ASBeautifier*>* waitingBeautifierStack;
+	vector<ASBeautifier*>* activeBeautifierStack;
+	vector<int>* waitingBeautifierStackLengthStack;
+	vector<int>* activeBeautifierStackLengthStack;
+	vector<const string*>* headerStack;
+	vector<vector<const string*>* >* tempStacks;
+	vector<int>* squareBracketDepthStack;
+	vector<bool>* blockStatementStack;
+	vector<bool>* parenStatementStack;
+	vector<bool>* braceBlockStateStack;
+	vector<int>* continuationIndentStack;
+	vector<int>* continuationIndentStackSizeStack;
+	vector<int>* parenIndentStack;
+	vector<pair<int, int> >* preprocIndentStack;
+
+	ASSourceIterator* sourceIterator;
+	const string* currentHeader;
+	const string* previousLastLineHeader;
+	const string* probationHeader;
+	const string* lastLineHeader;
+	string indentString;
+	string verbatimDelimiter;
+	bool isInQuote;
+	bool isInVerbatimQuote;
+	bool haveLineContinuationChar;
+	bool isInAsm;
+	bool isInAsmOneLine;
+	bool isInAsmBlock;
+	bool isInComment;
+	bool isInPreprocessorComment;
+	bool isInRunInComment;
+	bool isInCase;
+	bool isInQuestion;
+	bool isContinuation;
+	bool isInHeader;
+	bool isInTemplate;
+	bool isInDefine;
+	bool isInDefineDefinition;
+	bool classIndent;
+	bool isIndentModeOff;
+	bool isInClassHeader;			// is in a class before the opening brace
+	bool isInClassHeaderTab;		// is in an indentable class header line
+	bool isInClassInitializer;		// is in a class after the ':' initializer
+	bool isInClass;					// is in a class after the opening brace
+	bool isInObjCMethodDefinition;
+	bool isInObjCMethodCall;
+	bool isInObjCMethodCallFirst;
+	bool isImmediatelyPostObjCMethodDefinition;
+	bool isImmediatelyPostObjCMethodCall;
+	bool isInIndentablePreprocBlock;
+	bool isInObjCInterface;
+	bool isInEnum;
+	bool isInEnumTypeID;
+	bool isInLet;
+	bool modifierIndent;
+	bool switchIndent;
+	bool caseIndent;
+	bool namespaceIndent;
+	bool blockIndent;
+	bool braceIndent;
+	bool braceIndentVtk;
+	bool shouldIndentAfterParen;
+	bool labelIndent;
+	bool shouldIndentPreprocDefine;
+	bool isInConditional;
+	bool isModeManuallySet;
+	bool shouldForceTabIndentation;
+	bool emptyLineFill;
+	bool backslashEndsPrevLine;
+	bool lineOpensWithLineComment;
+	bool lineOpensWithComment;
+	bool lineStartsInComment;
+	bool blockCommentNoIndent;
+	bool blockCommentNoBeautify;
+	bool previousLineProbationTab;
+	bool lineBeginsWithOpenBrace;
+	bool lineBeginsWithCloseBrace;
+	bool lineBeginsWithComma;
+	bool lineIsCommentOnly;
+	bool lineIsLineCommentOnly;
+	bool shouldIndentBracedLine;
+	bool isInSwitch;
+	bool foundPreCommandHeader;
+	bool foundPreCommandMacro;
+	bool shouldAlignMethodColon;
+	bool shouldIndentPreprocConditional;
+	int  indentCount;
+	int  spaceIndentCount;
+	int  spaceIndentObjCMethodAlignment;
+	int  bracePosObjCMethodAlignment;
+	int  colonIndentObjCMethodAlignment;
+	int  lineOpeningBlocksNum;
+	int  lineClosingBlocksNum;
+	int  fileType;
+	int  minConditionalOption;
+	int  minConditionalIndent;
+	int  parenDepth;
+	int  indentLength;
+	int  tabLength;
+	int  continuationIndent;
+	int  blockTabCount;
+	int  maxContinuationIndent;
+	int  classInitializerIndents;
+	int  templateDepth;
+	int  squareBracketCount;
+	int  prevFinalLineSpaceIndentCount;
+	int  prevFinalLineIndentCount;
+	int  defineIndentCount;
+	int  preprocBlockIndent;
+	char quoteChar;
+	char prevNonSpaceCh;
+	char currentNonSpaceCh;
+	char currentNonLegalCh;
+	char prevNonLegalCh;
+};  // Class ASBeautifier
+
+//-----------------------------------------------------------------------------
+// Class ASEnhancer
+//-----------------------------------------------------------------------------
+
+class ASEnhancer : protected ASBase
+{
+public:  // functions
+	ASEnhancer();
+	virtual ~ASEnhancer();
+	void init(int, int, int, bool, bool, bool, bool, bool, bool, bool,
+	          vector<const pair<const string, const string>* >*);
+	void enhance(string& line, bool isInNamespace, bool isInPreprocessor, bool isInSQL);
+
+private:  // functions
+	void   convertForceTabIndentToSpaces(string&  line) const;
+	void   convertSpaceIndentToForceTab(string& line) const;
+	size_t findCaseColon(const string&  line, size_t caseIndex) const;
+	int    indentLine(string&  line, int indent) const;
+	bool   isBeginDeclareSectionSQL(const string&  line, size_t index) const;
+	bool   isEndDeclareSectionSQL(const string&  line, size_t index) const;
+	bool   isOneLineBlockReached(const string& line, int startChar) const;
+	void   parseCurrentLine(string& line, bool isInPreprocessor, bool isInSQL);
+	size_t processSwitchBlock(string&  line, size_t index);
+	int    unindentLine(string&  line, int unindent) const;
+
+private:
+	// options from command line or options file
+	int  indentLength;
+	int  tabLength;
+	bool useTabs;
+	bool forceTab;
+	bool namespaceIndent;
+	bool caseIndent;
+	bool preprocBlockIndent;
+	bool preprocDefineIndent;
+	bool emptyLineFill;
+
+	// parsing variables
+	int  lineNumber;
+	bool isInQuote;
+	bool isInComment;
+	char quoteChar;
+
+	// unindent variables
+	int  braceCount;
+	int  switchDepth;
+	int  eventPreprocDepth;
+	bool lookingForCaseBrace;
+	bool unindentNextLine;
+	bool shouldUnindentLine;
+	bool shouldUnindentComment;
+
+	// struct used by ParseFormattedLine function
+	// contains variables used to unindent the case blocks
+	struct SwitchVariables
+	{
+		int  switchBraceCount;
+		int  unindentDepth;
+		bool unindentCase;
+	};
+
+	SwitchVariables sw;                      // switch variables struct
+	vector<SwitchVariables> switchStack;     // stack vector of switch variables
+
+	// event table variables
+	bool nextLineIsEventIndent;             // begin event table indent is reached
+	bool isInEventTable;                    // need to indent an event table
+	vector<const pair<const string, const string>* >* indentableMacros;
+
+	// SQL variables
+	bool nextLineIsDeclareIndent;           // begin declare section indent is reached
+	bool isInDeclareSection;                // need to indent a declare section
+
+};  // Class ASEnhancer
+
+//-----------------------------------------------------------------------------
+// Class ASFormatter
+//-----------------------------------------------------------------------------
+
+class ASFormatter : public ASBeautifier
+{
+public:	// functions
+	ASFormatter();
+	virtual ~ASFormatter();
+	virtual void init(ASSourceIterator* si);
+	virtual bool hasMoreLines() const;
+	virtual string nextLine();
+	LineEndFormat getLineEndFormat() const;
+	bool getIsLineReady() const;
+	void setFormattingStyle(FormatStyle style);
+	void setAddBracesMode(bool state);
+	void setAddOneLineBracesMode(bool state);
+	void setRemoveBracesMode(bool state);
+	void setAttachClass(bool state);
+	void setAttachClosingWhile(bool state);
+	void setAttachExternC(bool state);
+	void setAttachNamespace(bool state);
+	void setAttachInline(bool state);
+	void setBraceFormatMode(BraceMode mode);
+	void setBreakAfterMode(bool state);
+	void setBreakClosingHeaderBracesMode(bool state);
+	void setBreakBlocksMode(bool state);
+	void setBreakClosingHeaderBlocksMode(bool state);
+	void setBreakElseIfsMode(bool state);
+	void setBreakOneLineBlocksMode(bool state);
+	void setBreakOneLineHeadersMode(bool state);
+	void setBreakOneLineStatementsMode(bool state);
+	void setMethodPrefixPaddingMode(bool state);
+	void setMethodPrefixUnPaddingMode(bool state);
+	void setReturnTypePaddingMode(bool state);
+	void setReturnTypeUnPaddingMode(bool state);
+	void setParamTypePaddingMode(bool state);
+	void setParamTypeUnPaddingMode(bool state);
+	void setCloseTemplatesMode(bool state);
+	void setCommaPaddingMode(bool state);
+	void setDeleteEmptyLinesMode(bool state);
+	void setIndentCol1CommentsMode(bool state);
+	void setLineEndFormat(LineEndFormat fmt);
+	void setMaxCodeLength(int max);
+	void setObjCColonPaddingMode(ObjCColonPad mode);
+	void setOperatorPaddingMode(bool state);
+	void setParensOutsidePaddingMode(bool state);
+	void setParensFirstPaddingMode(bool state);
+	void setParensInsidePaddingMode(bool state);
+	void setParensHeaderPaddingMode(bool state);
+	void setParensUnPaddingMode(bool state);
+	void setPointerAlignment(PointerAlign alignment);
+	void setPreprocBlockIndent(bool state);
+	void setReferenceAlignment(ReferenceAlign alignment);
+	void setStripCommentPrefix(bool state);
+	void setTabSpaceConversionMode(bool state);
+	size_t getChecksumIn() const;
+	size_t getChecksumOut() const;
+	int  getChecksumDiff() const;
+	int  getFormatterFileType() const;
+	// retained for compatability with release 2.06
+	// "Brackets" have been changed to "Braces" in 3.0
+	// they are referenced only by the old "bracket" options
+	void setAddBracketsMode(bool state);
+	void setAddOneLineBracketsMode(bool state);
+	void setRemoveBracketsMode(bool state);
+	void setBreakClosingHeaderBracketsMode(bool state);
+
+
+private:  // functions
+	ASFormatter(const ASFormatter& copy);       // not to be implemented
+	ASFormatter& operator=(ASFormatter&);       // not to be implemented
+	template<typename T> void deleteContainer(T& container);
+	template<typename T> void initContainer(T& container, T value);
+	char peekNextChar() const;
+	BraceType getBraceType();
+	bool adjustChecksumIn(int adjustment);
+	bool computeChecksumIn(const string& currentLine_);
+	bool computeChecksumOut(const string& beautifiedLine);
+	bool addBracesToStatement();
+	bool removeBracesFromStatement();
+	bool commentAndHeaderFollows();
+	bool getNextChar();
+	bool getNextLine(bool emptyLineWasDeleted = false);
+	bool isArrayOperator() const;
+	bool isBeforeComment() const;
+	bool isBeforeAnyComment() const;
+	bool isBeforeAnyLineEndComment(int startPos) const;
+	bool isBeforeMultipleLineEndComments(int startPos) const;
+	bool isBraceType(BraceType a, BraceType b) const;
+	bool isClassInitializer() const;
+	bool isClosingHeader(const string* header) const;
+	bool isCurrentBraceBroken() const;
+	bool isDereferenceOrAddressOf() const;
+	bool isExecSQL(const string& line, size_t index) const;
+	bool isEmptyLine(const string& line) const;
+	bool isExternC() const;
+	bool isMultiStatementLine() const;
+	bool isNextWordSharpNonParenHeader(int startChar) const;
+	bool isNonInStatementArrayBrace() const;
+	bool isOkToSplitFormattedLine();
+	bool isPointerOrReference() const;
+	bool isPointerOrReferenceCentered() const;
+	bool isPointerOrReferenceVariable(const string& word) const;
+	bool isSharpStyleWithParen(const string* header) const;
+	bool isStructAccessModified(const string& firstLine, size_t index) const;
+	bool isIndentablePreprocessorBlock(const string& firstLine, size_t index);
+	bool isNDefPreprocStatement(const string& nextLine_, const string& preproc) const;
+	bool isUnaryOperator() const;
+	bool isUniformInitializerBrace() const;
+	bool isImmediatelyPostCast() const;
+	bool isInExponent() const;
+	bool isInSwitchStatement() const;
+	bool isNextCharOpeningBrace(int startChar) const;
+	bool isOkToBreakBlock(BraceType braceType) const;
+	bool isOperatorPaddingDisabled() const;
+	bool pointerSymbolFollows() const;
+	int  findObjCColonAlignment() const;
+	int  getCurrentLineCommentAdjustment();
+	int  getNextLineCommentAdjustment();
+	int  isOneLineBlockReached(const string& line, int startChar) const;
+	void adjustComments();
+	void appendChar(char ch, bool canBreakLine);
+	void appendCharInsideComments();
+	void appendClosingHeader();
+	void appendOperator(const string& sequence, bool canBreakLine = true);
+	void appendSequence(const string& sequence, bool canBreakLine = true);
+	void appendSpacePad();
+	void appendSpaceAfter();
+	void breakLine(bool isSplitLine = false);
+	void buildLanguageVectors();
+	void updateFormattedLineSplitPoints(char appendedChar);
+	void updateFormattedLineSplitPointsOperator(const string& sequence);
+	void checkIfTemplateOpener();
+	void clearFormattedLineSplitPoints();
+	void convertTabToSpaces();
+	void deleteContainer(vector<BraceType>*& container);
+	void formatArrayRunIn();
+	void formatRunIn();
+	void formatArrayBraces(BraceType braceType, bool isOpeningArrayBrace);
+	void formatClosingBrace(BraceType braceType);
+	void formatCommentBody();
+	void formatCommentOpener();
+	void formatCommentCloser();
+	void formatLineCommentBody();
+	void formatLineCommentOpener();
+	void formatOpeningBrace(BraceType braceType);
+	void formatQuoteBody();
+	void formatQuoteOpener();
+	void formatPointerOrReference();
+	void formatPointerOrReferenceCast();
+	void formatPointerOrReferenceToMiddle();
+	void formatPointerOrReferenceToName();
+	void formatPointerOrReferenceToType();
+	void fixOptionVariableConflicts();
+	void goForward(int i);
+	void isLineBreakBeforeClosingHeader();
+	void initContainer(vector<BraceType>*& container, vector<BraceType>* value);
+	void initNewLine();
+	void padObjCMethodColon();
+	void padObjCMethodPrefix();
+	void padObjCParamType();
+	void padObjCReturnType();
+	void padOperators(const string* newOperator);
+	void padParens();
+	void processPreprocessor();
+	void resetEndOfStatement();
+	void setAttachClosingBraceMode(bool state);
+	void stripCommentPrefix();
+	void testForTimeToSplitFormattedLine();
+	void trimContinuationLine();
+	void updateFormattedLineSplitPointsPointerOrReference(size_t index);
+	size_t findFormattedLineSplitPoint() const;
+	size_t findNextChar(const string& line, char searchChar, int searchStart = 0) const;
+	const string* checkForHeaderFollowingComment(const string& firstLine) const;
+	const string* getFollowingOperator() const;
+	string getPreviousWord(const string& line, int currPos) const;
+	string peekNextText(const string& firstLine,
+	                    bool endOnEmptyLine = false,
+	                    shared_ptr<ASPeekStream> streamArg = nullptr) const;
+
+private:  // variables
+	int formatterFileType;
+	vector<const string*>* headers;
+	vector<const string*>* nonParenHeaders;
+	vector<const string*>* preDefinitionHeaders;
+	vector<const string*>* preCommandHeaders;
+	vector<const string*>* operators;
+	vector<const string*>* assignmentOperators;
+	vector<const string*>* castOperators;
+	vector<const pair<const string, const string>* >* indentableMacros;	// for ASEnhancer
+
+	ASSourceIterator* sourceIterator;
+	ASEnhancer* enhancer;
+
+	vector<const string*>* preBraceHeaderStack;
+	vector<BraceType>* braceTypeStack;
+	vector<int>* parenStack;
+	vector<bool>* structStack;
+	vector<bool>* questionMarkStack;
+
+	string currentLine;
+	string formattedLine;
+	string readyFormattedLine;
+	string verbatimDelimiter;
+	const string* currentHeader;
+	char currentChar;
+	char previousChar;
+	char previousNonWSChar;
+	char previousCommandChar;
+	char quoteChar;
+	streamoff preprocBlockEnd;
+	int  charNum;
+	int  runInIndentChars;
+	int  nextLineSpacePadNum;
+	int  objCColonAlign;
+	int  preprocBraceTypeStackSize;
+	int  spacePadNum;
+	int  tabIncrementIn;
+	int  templateDepth;
+	int  squareBracketCount;
+	size_t checksumIn;
+	size_t checksumOut;
+	size_t currentLineFirstBraceNum;	// first brace location on currentLine
+	size_t formattedLineCommentNum;     // comment location on formattedLine
+	size_t leadingSpaces;
+	size_t maxCodeLength;
+
+	// possible split points
+	size_t maxSemi;			// probably a 'for' statement
+	size_t maxAndOr;		// probably an 'if' statement
+	size_t maxComma;
+	size_t maxParen;
+	size_t maxWhiteSpace;
+	size_t maxSemiPending;
+	size_t maxAndOrPending;
+	size_t maxCommaPending;
+	size_t maxParenPending;
+	size_t maxWhiteSpacePending;
+
+	size_t previousReadyFormattedLineLength;
+	FormatStyle formattingStyle;
+	BraceMode braceFormatMode;
+	BraceType previousBraceType;
+	PointerAlign pointerAlignment;
+	ReferenceAlign referenceAlignment;
+	ObjCColonPad objCColonPadMode;
+	LineEndFormat lineEnd;
+	bool isVirgin;
+	bool isInVirginLine;
+	bool shouldPadCommas;
+	bool shouldPadOperators;
+	bool shouldPadParensOutside;
+	bool shouldPadFirstParen;
+	bool shouldPadParensInside;
+	bool shouldPadHeader;
+	bool shouldStripCommentPrefix;
+	bool shouldUnPadParens;
+	bool shouldConvertTabs;
+	bool shouldIndentCol1Comments;
+	bool shouldIndentPreprocBlock;
+	bool shouldCloseTemplates;
+	bool shouldAttachExternC;
+	bool shouldAttachNamespace;
+	bool shouldAttachClass;
+	bool shouldAttachClosingWhile;
+	bool shouldAttachInline;
+	bool isInLineComment;
+	bool isInComment;
+	bool isInCommentStartLine;
+	bool noTrimCommentContinuation;
+	bool isInPreprocessor;
+	bool isInPreprocessorBeautify;
+	bool isInTemplate;
+	bool doesLineStartComment;
+	bool lineEndsInCommentOnly;
+	bool lineIsCommentOnly;
+	bool lineIsLineCommentOnly;
+	bool lineIsEmpty;
+	bool isImmediatelyPostCommentOnly;
+	bool isImmediatelyPostEmptyLine;
+	bool isInClassInitializer;
+	bool isInQuote;
+	bool isInVerbatimQuote;
+	bool haveLineContinuationChar;
+	bool isInQuoteContinuation;
+	bool isHeaderInMultiStatementLine;
+	bool isSpecialChar;
+	bool isNonParenHeader;
+	bool foundQuestionMark;
+	bool foundPreDefinitionHeader;
+	bool foundNamespaceHeader;
+	bool foundClassHeader;
+	bool foundStructHeader;
+	bool foundInterfaceHeader;
+	bool foundPreCommandHeader;
+	bool foundPreCommandMacro;
+	bool foundTrailingReturnType;
+	bool foundCastOperator;
+	bool isInLineBreak;
+	bool endOfAsmReached;
+	bool endOfCodeReached;
+	bool lineCommentNoIndent;
+	bool isFormattingModeOff;
+	bool isInEnum;
+	bool isInExecSQL;
+	bool isInAsm;
+	bool isInAsmOneLine;
+	bool isInAsmBlock;
+	bool isLineReady;
+	bool elseHeaderFollowsComments;
+	bool caseHeaderFollowsComments;
+	bool isPreviousBraceBlockRelated;
+	bool isInPotentialCalculation;
+	bool isCharImmediatelyPostComment;
+	bool isPreviousCharPostComment;
+	bool isCharImmediatelyPostLineComment;
+	bool isCharImmediatelyPostOpenBlock;
+	bool isCharImmediatelyPostCloseBlock;
+	bool isCharImmediatelyPostTemplate;
+	bool isCharImmediatelyPostReturn;
+	bool isCharImmediatelyPostThrow;
+	bool isCharImmediatelyPostNewDelete;
+	bool isCharImmediatelyPostOperator;
+	bool isCharImmediatelyPostPointerOrReference;
+	bool isInObjCMethodDefinition;
+	bool isInObjCInterface;
+	bool isInObjCReturnType;
+	bool isInObjCSelector;
+	bool breakCurrentOneLineBlock;
+	bool shouldRemoveNextClosingBrace;
+	bool isInBraceRunIn;
+	bool currentLineBeginsWithBrace;
+	bool attachClosingBraceMode;
+	bool shouldBreakOneLineBlocks;
+	bool shouldBreakOneLineHeaders;
+	bool shouldBreakOneLineStatements;
+	bool shouldBreakClosingHeaderBraces;
+	bool shouldBreakElseIfs;
+	bool shouldBreakLineAfterLogical;
+	bool shouldAddBraces;
+	bool shouldAddOneLineBraces;
+	bool shouldRemoveBraces;
+	bool shouldPadMethodColon;
+	bool shouldPadMethodPrefix;
+	bool shouldReparseCurrentChar;
+	bool shouldUnPadMethodPrefix;
+	bool shouldPadReturnType;
+	bool shouldUnPadReturnType;
+	bool shouldPadParamType;
+	bool shouldUnPadParamType;
+	bool shouldDeleteEmptyLines;
+	bool needHeaderOpeningBrace;
+	bool shouldBreakLineAtNextChar;
+	bool shouldKeepLineUnbroken;
+	bool passedSemicolon;
+	bool passedColon;
+	bool isImmediatelyPostNonInStmt;
+	bool isCharImmediatelyPostNonInStmt;
+	bool isImmediatelyPostComment;
+	bool isImmediatelyPostLineComment;
+	bool isImmediatelyPostEmptyBlock;
+	bool isImmediatelyPostObjCMethodPrefix;
+	bool isImmediatelyPostPreprocessor;
+	bool isImmediatelyPostReturn;
+	bool isImmediatelyPostThrow;
+	bool isImmediatelyPostNewDelete;
+	bool isImmediatelyPostOperator;
+	bool isImmediatelyPostTemplate;
+	bool isImmediatelyPostPointerOrReference;
+	bool shouldBreakBlocks;
+	bool shouldBreakClosingHeaderBlocks;
+	bool isPrependPostBlockEmptyLineRequested;
+	bool isAppendPostBlockEmptyLineRequested;
+	bool isIndentableProprocessor;
+	bool isIndentableProprocessorBlock;
+	bool prependEmptyLine;
+	bool appendOpeningBrace;
+	bool foundClosingHeader;
+	bool isInHeader;
+	bool isImmediatelyPostHeader;
+	bool isInCase;
+	bool isFirstPreprocConditional;
+	bool processedFirstConditional;
+	bool isJavaStaticConstructor;
+
+private:  // inline functions
+	// append the CURRENT character (curentChar) to the current formatted line.
+	void appendCurrentChar(bool canBreakLine = true)
+	{ appendChar(currentChar, canBreakLine); }
+
+	// check if a specific sequence exists in the current placement of the current line
+	bool isSequenceReached(const char* sequence) const
+	{ return currentLine.compare(charNum, strlen(sequence), sequence) == 0; }
+
+	// call ASBase::findHeader for the current character
+	const string* findHeader(const vector<const string*>* headers_)
+	{ return ASBase::findHeader(currentLine, charNum, headers_); }
+
+	// call ASBase::findOperator for the current character
+	const string* findOperator(const vector<const string*>* operators_)
+	{ return ASBase::findOperator(currentLine, charNum, operators_); }
+};  // Class ASFormatter
+
+//-----------------------------------------------------------------------------
+// astyle namespace global declarations
+//-----------------------------------------------------------------------------
+// sort comparison functions for ASResource
+bool sortOnLength(const string* a, const string* b);
+bool sortOnName(const string* a, const string* b);
+
+}   // namespace astyle
+
+// end of astyle namespace  --------------------------------------------------
+
+#endif // closes ASTYLE_H