--- /dev/null
+// 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
projects / openjpeg.git / blobdiff