summaryrefslogtreecommitdiffstats
path: root/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h
diff options
context:
space:
mode:
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h')
-rw-r--r--debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h1797
1 files changed, 1797 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h
new file mode 100644
index 00000000..7d7e0167
--- /dev/null
+++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/chunk.h
@@ -0,0 +1,1797 @@
+/**
+ * @file chunk.h
+ * Manages and navigates the list of chunks.
+ *
+ * @author Ben Gardner
+ * @author Guy Maurel
+ * @license GPL v2+
+ */
+
+#ifndef CHUNK_LIST_H_INCLUDED
+#define CHUNK_LIST_H_INCLUDED
+
+#include "uncrustify_types.h"
+// necessary to not sort it
+#include "char_table.h"
+#include "language_names.h"
+#include "language_tools.h"
+
+
+static constexpr int ANY_LEVEL = -1;
+
+
+/**
+ * Specifies which chunks should/should not be found.
+ * ALL (default)
+ * - return the true next/prev
+ *
+ * PREPROC
+ * - If not in a preprocessor, skip over any encountered preprocessor stuff
+ * - If in a preprocessor, fail to leave (return Chunk::NullChunkPtr)
+ */
+enum class E_Scope : unsigned int
+{
+ ALL, //! search in all kind of chunks
+ PREPROC, //! search only in preprocessor chunks
+};
+
+
+/**
+ * Specifies which direction or location an operation shall be performed.
+ */
+enum class E_Direction : unsigned int
+{
+ FORWARD,
+ BACKWARD
+};
+
+
+class ChunkListManager;
+
+// This is the main type of this program
+class Chunk
+{
+ friend ChunkListManager;
+
+public:
+ //! constructors
+ Chunk(bool null_c = false); // default
+ Chunk(const Chunk &o); // !!! partial copy: chunk is not linked to others
+
+ Chunk &operator=(const Chunk &o); // !!! partial copy: chunk is not linked to others
+
+ //! whether this is a null Chunk or not
+ bool IsNullChunk() const { return(m_nullChunk); }
+ bool IsNotNullChunk() const { return(!m_nullChunk); }
+
+ //! sets all elements of the struct to their default value
+ void Reset();
+
+
+ // --------- Access methods
+
+ /**
+ * @brief returns the type of the chunk
+ */
+ E_Token GetType() const;
+
+ /**
+ * @brief Sets the chunk type
+ * @param token the type to set
+ */
+ void SetType(const E_Token token);
+
+ /**
+ * @brief Returns the parent type of the chunk
+ */
+ E_Token GetParentType() const;
+
+ /**
+ * @brief Sets the type of the parent chunk
+ * @param token the type to set
+ */
+ void SetParentType(const E_Token token);
+
+ /**
+ * @brief Returns the parent of the chunk
+ */
+ Chunk *GetParent() const;
+
+ /**
+ * @brief Sets the parent of the chunk
+ * @param parent the parent chunk to set
+ */
+ void SetParent(Chunk *parent);
+
+ /**
+ * @brief Returns the alignment data of the chunk as a const reference
+ */
+ const AlignmentData &GetAlignData() const;
+
+ /**
+ * @brief Returns the alignment data of the chunk as a modifiable reference
+ */
+ AlignmentData &AlignData();
+
+ /**
+ * @brief Returns the indentation data of the chunk as a const reference
+ */
+ const IndentationData &GetIndentData() const;
+
+ /**
+ * @brief Returns the indentation data of the chunk as a modifiable reference
+ */
+ IndentationData &IndentData();
+
+ /**
+ * @brief Returns the text data of the chunk as a const reference
+ */
+ const UncText &GetStr() const;
+
+ /**
+ * @brief Returns the text data of the chunk as a modifiable reference
+ */
+ UncText &Str();
+
+ /**
+ * @brief returns the number of characters in the chunk text string
+ */
+ size_t Len() const;
+
+ /**
+ * @brief returns the content of the chunk text as C string
+ */
+ const char *Text() const;
+
+ /**
+ * Returns a filled up (if necessary) copy of the first chars of the Text() string
+ */
+ const char *ElidedText(char *for_the_copy) const;
+
+ /**
+ * @brief Returns the tracking data of the chunk as a const reference
+ */
+ const TrackList *GetTrackingData() const;
+
+ /**
+ * @brief Returns the tracking data of the chunk as a modifiable reference
+ */
+ TrackList * &TrackingData();
+
+ /**
+ * @brief Returns the type of the parent chunk
+ */
+ E_Token GetTypeOfParent() const;
+
+ /**
+ * @brief Returns the chunk flags
+ */
+ PcfFlags GetFlags() const;
+
+ /**
+ * @brief Sets the chunk flags
+ * @param flags the new chunk flags
+ */
+ void SetFlags(PcfFlags flags);
+
+ /**
+ * @brief Tests if some chunk flags are set
+ * @param flags the flag bits to test
+ * @return true if the specified bits are set, false otherwise
+ */
+ bool TestFlags(PcfFlags flags) const;
+
+ /**
+ * @brief Resets some of the chunk flag bits
+ * @param resetBits the flag bits to reset
+ */
+ void ResetFlagBits(PcfFlags resetBits);
+
+ /**
+ * @brief Sets some of the chunk flag bits
+ * @param setBits the flag bits to set
+ */
+ void SetFlagBits(PcfFlags setBits);
+
+ /**
+ * @brief Sets and reset some of the chunk flag bits
+ * @param resetBits the flag bits to reset
+ * @param setBits the flag bits to set
+ */
+ void UpdateFlagBits(PcfFlags resetBits, PcfFlags setBits);
+
+ /**
+ * @brief Returns the line number of the chunk in the input file
+ */
+ size_t GetOrigLine() const;
+
+ /**
+ * @brief Sets the line number of the chunk in the input file
+ * @param line the line number of the chunk
+ */
+ void SetOrigLine(size_t line);
+
+ /**
+ * @brief Returns the column number of the chunk in the input file
+ */
+ size_t GetOrigCol() const;
+
+ /**
+ * @brief Sets the column number of the chunk in the input file
+ * @param col the column number of the chunk
+ */
+ void SetOrigCol(size_t col);
+
+ /**
+ * @brief Returns the end column number of the chunk in the input file
+ */
+ size_t GetOrigColEnd() const;
+
+ /**
+ * @brief Sets the end column number of the chunk in the input file
+ * @param col the end column number of the chunk
+ */
+ void SetOrigColEnd(size_t col);
+
+ /**
+ * @brief Returns the position of the whitespace before this chunk
+ */
+ size_t GetOrigPrevSp() const;
+
+ /**
+ * @brief Sets the position of the whitespace before this chunk
+ * @param col the end column number of the chunk in the input file
+ */
+ void SetOrigPrevSp(size_t col);
+
+ /**
+ * @brief Returns the column of the chunk
+ */
+ size_t GetColumn() const;
+
+ /**
+ * @brief Sets the column of the chunk
+ * @param col the column of the chunk
+ */
+ void SetColumn(size_t col);
+
+ /**
+ * @brief Returns the column indentation of the chunk
+ */
+ size_t GetColumnIndent() const;
+
+ /**
+ * @brief Sets the column indentation of the chunk
+ * @param col the column indentation of the chunk
+ */
+ void SetColumnIndent(size_t col);
+
+ /**
+ * @brief Returns the number of newlines in a CT_NEWLINE chunk
+ */
+ size_t GetNlCount() const;
+
+ /**
+ * @brief Sets the number of newlines in a CT_NEWLINE chunk
+ * @param cnt the number of newlines
+ */
+ void SetNlCount(size_t cnt);
+
+ /**
+ * @brief Returns the column of the newline entries
+ */
+ size_t GetNlColumn() const;
+
+ /**
+ * @brief Sets the column of the newline entries
+ * @param col the number of the column
+ */
+ void SetNlColumn(size_t col);
+
+ /**
+ * @brief Returns the level of the chunk
+ */
+ size_t GetLevel() const;
+
+ /**
+ * @brief Sets the level of the chunk
+ * @param col the level of the chunk
+ */
+ void SetLevel(size_t level);
+
+ /**
+ * @brief Returns the brace level of the chunk
+ */
+ size_t GetBraceLevel() const;
+
+ /**
+ * @brief Sets the brace level of the chunk
+ * @param level the brace level of the chunk
+ */
+ void SetBraceLevel(size_t lvl);
+
+ /**
+ * @brief Returns the preprocessor level of the chunk
+ */
+ size_t GetPpLevel() const;
+
+ /**
+ * @brief Sets the preprocessor level of the chunk
+ * @param level the preprocessor level of the chunk
+ */
+ void SetPpLevel(size_t lvl);
+
+ /**
+ * @brief Returns the after tab property of the chunk
+ */
+ bool GetAfterTab() const;
+
+ /**
+ * @brief Sets the after tab property of the chunk
+ * @param afterTab the after tab property of the chunk
+ */
+ void SetAfterTab(bool afterTab);
+
+
+ // --------- Get* chunk functions
+
+ /**
+ * @brief returns the head of the chunk list
+ * @return pointer to the first chunk
+ */
+ static Chunk *GetHead();
+
+ /**
+ * @brief returns the tail of the chunk list
+ * @return pointer to the last chunk
+ */
+ static Chunk *GetTail();
+
+ /**
+ * @brief returns the next chunk in a list of chunks
+ * @param scope code region to search in
+ * @return pointer to next chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNext(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the previous chunk in a list of chunks
+ * @param scope code region to search in
+ * @return pointer to previous chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrev(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next newline chunk
+ * @param scope code region to search in
+ * @return pointer to next newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev newline chunk
+ * @param scope code region to search in
+ * @return pointer to prev newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to next non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-comment chunk
+ * @param scope code region to search in
+ * @return pointer to next non-comment chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNc(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-comment chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-comment chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNc(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-comment and non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to next non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNcNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-comment and non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNcNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-comment, non-newline, non-preprocessor chunk
+ * @param scope code region to search in
+ * @return pointer to next non-comment, non-newline, non-preprocessor chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNcNnlNpp(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-comment, non-newline, non-preprocessor chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-comment, non-newline, non-preprocessor chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNcNnlNpp(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-preprocessor or non-comment, non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to next non-preprocessor or non-comment, non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNppOrNcNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-preprocessor or non-comment, non-newline chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-preprocessor or non-comment, non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNppOrNcNnl(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next preprocessor aware non-comment and non-newline chunk
+ * Unlike Chunk::GetNextNcNnl, this will also ignore a line continuation if
+ * the starting chunk is in a preprocessor directive, and may return a newline
+ * if the search reaches the end of a preprocessor directive.
+ * @return pointer to next preprocessor aware non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *PpaGetNextNcNnl() const;
+
+ /**
+ * @brief returns the next non-comment, non-newline, non-empty text chunk
+ * @param scope code region to search in
+ * @return pointer to next non-comment, non-newline, non-empty text chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNcNnlNet(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-comment, non-newline, non-empty text chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-comment, non-newline, non-empty text chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNcNnlNet(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-comment, non-newline, non-ignored chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-comment, non-newline, non-ignored chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNcNnlNi(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next chunk not in or part of balanced square
+ * brackets. This handles stacked [] instances to accommodate
+ * multi-dimensional array declarations
+ * @param scope code region to search in
+ * @return Chunk::NullChunkPtr or the next chunk not in or part of square brackets
+ */
+ Chunk *GetNextNisq(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next non-virtual brace chunk
+ * @param scope code region to search in
+ * @return pointer to next non-virtual brace chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNvb(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev non-virtual brace chunk
+ * @param scope code region to search in
+ * @return pointer to prev non-virtual brace chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNvb(const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next chunk of the given type at the level.
+ * @param type the type to look for
+ * @param level the level to match or ANY_LEVEL
+ * @param scope code region to search in
+ * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextType(const E_Token type, const int level = ANY_LEVEL, const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev chunk of the given type at the level.
+ * @param type the type to look for
+ * @param level the level to match or ANY_LEVEL
+ * @param scope code region to search in
+ * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevType(const E_Token type, int level = ANY_LEVEL, E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next chunk that holds a given string at a given level.
+ * @param str string to search for
+ * @param len length of string
+ * @param level the level to match or ANY_LEVEL
+ * @param scope code region to search in
+ * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextString(const char *str, const size_t len, const int level, const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the prev chunk that holds a given string at a given level.
+ * @param str string to search for
+ * @param len length of string
+ * @param level the level to match or ANY_LEVEL
+ * @param scope code region to search in
+ * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevString(const char *str, const size_t len, const int level, const E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the next chunk that is not part of balanced square brackets.
+ * This handles stacked[] instances to accommodate multidimensional arrays.
+ * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetNextNbsb() const;
+
+ /**
+ * @brief returns the prev chunk that is not part of balanced square brackets.
+ * This handles stacked[] instances to accommodate multidimensional arrays.
+ * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPrevNbsb() const;
+
+ /**
+ * @brief returns the corresponding start chunk if the given chunk is within a
+ * preprocessor directive, or Chunk::NullChunkPtr otherwise.
+ * @return start chunk of the preprocessor directive or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetPpStart() const;
+
+ /**
+ * @brief Finds the first chunk on the line the current chunk is on.
+ * This just backs up until a newline or null chuck is hit.
+ *
+ * given: [ a - b - c - n1 - d - e - n2 ]
+ * input: [ a | b | c | n1 ] => a
+ * input: [ d | e | n2 ] => d
+ *
+ * @return pointer to the first chunk on the line the current chunk is on.
+ */
+ Chunk *GetFirstChunkOnLine() const;
+
+
+ // --------- Search functions
+
+ /**
+ * @brief defines a member function pointer for a function of type
+ * Chunk *Chunk::function(const E_Scope scope)
+ * that will search for a new chunk
+ */
+ typedef Chunk *(Chunk::*T_SearchFnPtr)(const E_Scope scope) const;
+
+ /**
+ * @brief defines a member function pointer for a function of type
+ * bool Chunk::function() const;
+ * that checks whether a chunk satisty a specific condition
+ */
+ typedef bool (Chunk::*T_CheckFnPtr)() const;
+
+ /**
+ * @brief determines the search direction to use and returns a pointer
+ * to the corresponding search function.
+ * @param dir search direction
+ * @return pointer to search function
+ */
+ static T_SearchFnPtr GetSearchFn(const E_Direction dir = E_Direction::FORWARD);
+
+ /**
+ * @brief search for a chunk that satisfies a condition in a chunk list
+ *
+ * A generic function that traverses a chunks list either
+ * in forward or reverse direction. The traversal continues until a
+ * chunk satisfies the condition defined by the compare function.
+ * Depending on the parameter cond the condition will either be
+ * checked to be true or false.
+ *
+ * @param checkFn compare function
+ * @param scope code parts to consider for search
+ * @param dir search direction (forward or backward)
+ * @param cond success condition
+ * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *Search(const T_CheckFnPtr checkFn, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD, const bool cond = true) const;
+
+ /**
+ * @brief search for a chunk that satisfies a condition in a chunk list,
+ * but being aware of preprocessor chucks.
+ *
+ * This function is similar to Search, except that it is tweaked to
+ * handle searches inside of preprocessor directives. Specifically, if the
+ * starting token is inside a preprocessor directive, it will ignore a line
+ * continuation, and will abort the search if it reaches the end of the
+ * directive. This function only searches forward.
+ *
+ * @param checkFn compare function
+ * @param cond success condition
+ * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *SearchPpa(const T_CheckFnPtr checkFn, const bool cond = true) const;
+
+ /**
+ * @brief search a chunk of a given type and level. Traverses a chunk list in the
+ * specified direction until a chunk of a given type and level is found.
+ *
+ * This function is a specialization of Chunk::Search.
+ *
+ * @param type category to search for
+ * @param scope code parts to consider for search
+ * @param dir search direction
+ * @param level nesting level to match or ANY_LEVEL
+ * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *SearchTypeLevel(const E_Token type, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD, const int level = ANY_LEVEL) const;
+
+ /**
+ * @brief searches a chunk that holds a specific string
+ *
+ * Traverses a chunk list either in forward or backward direction until a chunk
+ * with the provided string was found. Additionally a nesting level can be
+ * provided to narrow down the search.
+ *
+ * @param str string that searched chunk needs to have
+ * @param len length of the string
+ * @param level nesting level of the searched chunk, ignored when negative
+ * @param scope code parts to consider for search
+ * @param dir search direction
+ * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *SearchStringLevel(const char *str, const size_t len, const int level, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD) const;
+
+ /**
+ * @brief returns the closing match for the current paren/brace/square.
+ * @param scope chunk section to consider
+ * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetClosingParen(E_Scope scope = E_Scope::ALL) const;
+
+ /**
+ * @brief returns the opening match for the current paren/brace/square.
+ * @param scope chunk section to consider
+ * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found
+ */
+ Chunk *GetOpeningParen(E_Scope scope = E_Scope::ALL) const;
+
+
+ // --------- Is* functions
+
+ /**
+ * @brief checks whether the chunk is a specific token
+ * @token the token to check for
+ * @return true if the chunk type matches the specified token, false otherwise
+ */
+ bool Is(E_Token token) const;
+
+ /**
+ * @brief checks whether the chunk token name is a specific string
+ * @param str string to compare token name with
+ * @param caseSensitive whether to do a case sensitive or insensitive comparison
+ * @return true if the chunk token name matches the specified string, false otherwise
+ */
+ bool IsString(const char *str, bool caseSensitive = true) const;
+
+ /**
+ * @brief checks whether the chunk is not a specific token
+ * @token the token to check for
+ * @return true if the chunk type does not matches the specified token, false otherwise
+ */
+ bool IsNot(E_Token token) const;
+
+ /**
+ * @brief checks whether the chunk is a newline
+ * @return true if the chunk is a newline, false otherwise
+ */
+ bool IsNewline() const;
+
+ /**
+ * @brief checks whether the chunk is a comment
+ * This means any kind of:
+ * - single line comment
+ * - multiline comment
+ * - C comment
+ * - C++ comment
+ */
+ bool IsComment() const;
+
+ /**
+ * @brief checks whether the chunk is valid and has an empty text
+ * @return true if the chunk is valid and has an empty text
+ */
+ bool IsEmptyText() const;
+
+ /**
+ * @brief checks whether the chunk is a preprocessor
+ * @return true if the chunk is a preprocessor, false otherwise
+ */
+ bool IsPreproc() const;
+
+ /**
+ * @brief checks whether the other chunk has the same preproc flags
+ * @return true if the other chunk has the same preproc flags
+ */
+ bool IsSamePreproc(const Chunk *other) const;
+
+ /**
+ * @brief checks whether the chunk is either a comment or a newline
+ * @return true if the chunk is either a comment or a newline, false otherwise
+ */
+ bool IsCommentOrNewline() const;
+
+ /**
+ * @brief checks whether the chunk is either a comment, a newline or ignored
+ * @return true if the chunk is either a comment, a newline or ignored, false otherwise
+ */
+ bool IsCommentNewlineOrIgnored() const;
+
+ /**
+ * @brief checks whether the chunk is a comment, a newline or a preprocessor
+ * @return true if the chunk is a comment, a newline or a preprocessor, false otherwise
+ */
+ bool IsCommentNewlineOrPreproc() const;
+
+ /**
+ * @brief checks whether the chunk is a preprocessor and either a comment or a newline
+ * @return true if the chunk is a preprocessor and either a comment or a newline, false otherwise
+ */
+ bool IsCommentOrNewlineInPreproc() const;
+
+ /**
+ * @brief checks whether the chunk is a comment, a newline or has an empty text
+ * @return true if the chunk is a comment, a newline or has an empty text
+ */
+ bool IsCommentNewlineOrEmptyText() const;
+
+ /**
+ * @brief checks whether the chunk is a single line comment
+ * @return true if the chunk is a single line comment
+ */
+ bool IsSingleLineComment() const;
+
+ /**
+ * @brief checks whether the chunk is a Doxygen comment
+ * @return true if the chunk is a Doxygen comment
+ */
+ bool IsDoxygenComment() const;
+
+ /**
+ * @brief checks whether the chunk is a square bracket
+ * @return true if the chunk is a square bracket
+ */
+ bool IsSquareBracket() const;
+
+ /**
+ * @brief checks whether the chunk is a virtual brace
+ * @return true if the chunk is a virtual brace
+ */
+ bool IsVBrace() const;
+
+ /**
+ * @brief checks whether the chunk matches a given type and level
+ * @param type category to search for
+ * @param level nesting level to match
+ * @return true if the chunk matches a given type and level
+ */
+ bool IsTypeAndLevel(const E_Token type, const int level) const;
+
+ /**
+ * @brief checks whether the chunk matches a given string and level
+ * @param str the expected string
+ * @param len length of the string
+ * @param caseSensitive whether to do a case sensitive or insensitive comparison
+ * @param level nesting level of the searched chunk, ignored when negative
+ * @return true if the chunk matches a given string and level
+ */
+ bool IsStringAndLevel(const char *str, const size_t len, bool caseSensitive, const int level) const;
+
+ /**
+ * @brief checks whether the chunk is a star/asterisk
+ * @return true if the chunk is a star/asterisk
+ */
+ bool IsStar() const;
+
+ /**
+ * @brief checks whether the chunk is a colon
+ * @return true if the chunk is a colon
+ */
+ bool IsColon() const;
+
+ /**
+ * @brief checks whether the chunk is a semicolon
+ * @return true if the chunk is a semicolon
+ */
+ bool IsSemicolon() const;
+
+ /**
+ * @brief checks whether the chunk is a pointer operator
+ * @return true if the chunk is a pointer operator
+ */
+ bool IsPointerOperator() const;
+
+ /**
+ * @brief checks whether the chunk is a pointer or a reference
+ * @return true if the chunk is a pointer or a reference
+ */
+ bool IsPointerOrReference() const;
+
+ /**
+ * @brief checks whether the chunk is an inheritance access specifier
+ * @return true if the chunk is an inheritance access specifier
+ */
+ bool IsCppInheritanceAccessSpecifier() const;
+
+ /**
+ * @brief checks whether the chunk is a pointer, reference or a qualifier
+ * @return true if the chunk is a pointer, reference or a qualifier
+ */
+ bool IsPointerReferenceOrQualifier() const;
+
+ /**
+ * @brief checks whether the chunk is an address
+ * @return true if the chunk is an address
+ */
+ bool IsAddress() const;
+
+ /**
+ * @brief checks whether the chunk is a MS reference
+ * @return true if the chunk is a MS reference
+ * NOTE: MS compilers for C++/CLI and WinRT use '^' instead of '*'
+ * for marking up reference types vs pointer types
+ */
+ bool IsMsRef() const;
+
+ /**
+ * @brief checks whether the chunk is nullable
+ * @return true if the chunk is nullable
+ */
+ bool IsNullable() const;
+
+ /**
+ * @brief Checks if a given chunk is the last on its line
+ * @return true or false depending on whether a given chunk is the last on its line
+ */
+ bool IsLastChunkOnLine() const;
+
+ /**
+ * @brief checks whether the current chunk is on same line of the given 'end' chunk.
+ * The current chunk must be before the 'end' chunk
+ * @param end the end chunk
+ * @return true if there is no newline between the current chunk and end chunk
+ */
+ bool IsOnSameLine(const Chunk *end) const;
+
+ /**
+ * @brief checks whether the chunk is an opening brace
+ * @return true if the chunk is an opening brace
+ */
+ bool IsBraceOpen() const;
+
+ /**
+ * @brief checks whether the chunk is a closing brace
+ * @return true if the chunk is a closing brace
+ */
+ bool IsBraceClose() const;
+
+ /**
+ * @brief checks whether the chunk is an opening parenthesis
+ * @return true if the chunk is an opening parenthesis
+ */
+ bool IsParenOpen() const;
+
+ /**
+ * @brief checks whether the chunk is a closing parenthesis
+ * @return true if the chunk is a closing parenthesis
+ */
+ bool IsParenClose() const;
+
+ /**
+ * @brief checks if a chunk points to the opening parentheses of a
+ * for (...in...) loop in Objective-C.
+ * @return true if the chunk is the opening parentheses of a for-in loop
+ */
+ bool IsOCForinOpenParen() const;
+
+ /**
+ * @brief checks whether the chunk is a type defining token
+ * @return true if the chunk is a type defining token
+ */
+ bool IsTypeDefinition() const;
+
+ /**
+ * @brief checks whether the chunk is a word
+ * @return true if the chunk is a word
+ */
+ bool IsWord() const;
+
+ /**
+ * @brief checks whether the chunk is an enum or an enum class
+ * @return true if the chunk is an enum or an enum class
+ */
+ bool IsEnum() const;
+
+ /**
+ * @brief checks whether the chunk is a class or a struct
+ * @return true if the chunk is a class or a struct
+ */
+ bool IsClassOrStruct() const;
+
+ /**
+ * @brief checks whether the chunk is a class, struct or union
+ * @return true if the chunk is a class, struct or union
+ */
+ bool IsClassStructOrUnion() const;
+
+ /**
+ * @brief checks whether the chunk is a class, enum, struct or union
+ * @return true if the chunk is a class, enum, struct or union
+ */
+ bool IsClassEnumStructOrUnion() const;
+
+ /**
+ * @brief checks whether there is a newline between this chunk and the other
+ * @return true if there is a newline between this chunk and the other
+ */
+ bool IsNewlineBetween(const Chunk *other) const;
+
+
+ // --------- Util functions
+
+ /**
+ * @brief delete the chunk from the chunk list
+ * @param pc the chunk to remove from the list
+ */
+ static void Delete(Chunk * &pc);
+
+ /**
+ * @brief add a copy of this chunk after the given position in a chunk list.
+ * @note If pos is NullChunk, add at the tail of the chunk list
+ * @param pos insert position in list
+ * @return pointer to the newly added chunk
+ */
+ Chunk *CopyAndAddAfter(Chunk *pos) const;
+
+ /**
+ * @brief add a copy of this chunk before the given position in a chunk list.
+ * @note If pos is NullChunk, add at the head of the chunk list
+ * @param pos insert position in list
+ * @return pointer to the newly added chunk
+ */
+ Chunk *CopyAndAddBefore(Chunk *pos) const;
+
+ /**
+ * @brief move the chunk after the reference position in the chunk list
+ * @param ref chunk after which to move the current chunk
+ */
+ void MoveAfter(Chunk *ref);
+
+ /**
+ * @brief swaps the place of this chunk with the given one
+ * @param other the other chunk
+ */
+ void Swap(Chunk *other);
+
+ /**
+ * @brief swaps the two lines that are started by the current chunk and the other chunk
+ * @param other the other chunk
+ */
+ void SwapLines(Chunk *other);
+
+ //!
+ /**
+ * @brief skips to the final word/type in a :: chain
+ * @return pointer to the chunk after the final word/type in a :: chain
+ */
+ Chunk *SkipDcMember() const;
+
+ /**
+ * @brief compare the positions of the chunk with another one
+ * @param other the other chunk
+ * @return returns -1 if this chunk comes first, +1 if it comes after, or 0.
+ */
+ int ComparePosition(const Chunk *other) const;
+
+ /**
+ * Returns true if it is safe to delete the newline token.
+ * The prev and next chunks must have the same PCF_IN_PREPROC flag AND
+ * the newline can't be after a C++ comment.
+ */
+ bool SafeToDeleteNl() const;
+
+
+protected:
+ // --------- Protected util functions
+
+ /**
+ * @brief copy the values from another chunk.
+ * @NOTE: this is a partial copy only: the chunk is not linked to others
+ * @param o the chunk to copy from
+ */
+ void CopyFrom(const Chunk &o);
+
+ /**
+ * @brief add a copy of this chunk before/after the given position in a chunk list.
+ * @note If pos is NullChunk, add the new chuck either at the head or tail of the
+ * list based on the specified direction.
+ * @param pos insert position in list
+ * @param dir insert before or after the given position chunk
+ * @return pointer to the newly added chunk
+ */
+ Chunk *CopyAndAdd(Chunk *pos, const E_Direction dir = E_Direction::FORWARD) const;
+
+ /**
+ * @brief set and/or clear the chunk flags
+ * @param setBits the flag bits to set
+ * @param resetBits the flag bits to reset
+ */
+ void SetResetFlags(PcfFlags resetBits, PcfFlags setBits);
+
+
+ // --------- Data members
+ E_Token m_type; //! type of the chunk itself
+ E_Token m_parentType; //! type of the parent chunk usually CT_NONE
+ size_t m_origLine; //! line number of chunk in input file
+ size_t m_origCol; //! column where chunk started in the input file, is always > 0
+ size_t m_origColEnd; //! column where chunk ended in the input file, is always > 1
+ size_t m_origPrevSp; //! whitespace before this token
+ size_t m_column; //! column of the chunk
+ size_t m_columnIndent; //! if 1st chunk on a line, set to the 'indent' column, which may
+ //! be less than the real column used to indent with tabs
+ size_t m_nlCount; //! number of newlines in CT_NEWLINE
+ size_t m_nlColumn; //! column of the subsequent newline entries(all of them should have the same column)
+ size_t m_level; //! nest level in {, (, or [. Only to help vim command }
+ size_t m_braceLevel; //! nest level in braces only
+ size_t m_ppLevel; //! nest level in preprocessor
+ bool m_afterTab; //! whether this token was after a tab
+
+ PcfFlags m_flags; //! see PCF_xxx
+ AlignmentData m_alignmentData; //! alignment data of the chunk
+ IndentationData m_indentationData; //! indentation data of the chunk
+
+ Chunk *m_next; //! pointer to next chunk in list
+ Chunk *m_prev; //! pointer to previous chunk in list
+ Chunk *m_parent; //! pointer to parent chunk (not always set)
+
+ UncText m_str; //! the token text
+ TrackList *m_trackingList; //! for debugging purpose only
+
+
+private:
+ const bool m_nullChunk; //! true for null chunks
+
+
+public:
+ static Chunk NullChunk; //! Null Chunk
+ static Chunk *const NullChunkPtr; //! Pointer to the Null Chunk
+};
+
+
+inline Chunk::Chunk(bool null_c)
+ : m_nullChunk(null_c)
+{
+ Reset();
+}
+
+
+inline Chunk::Chunk(const Chunk &o)
+ : m_nullChunk(o.m_nullChunk)
+{
+ CopyFrom(o);
+}
+
+
+inline Chunk &Chunk::operator=(const Chunk &o)
+{
+ if (this != &o)
+ {
+ CopyFrom(o);
+ }
+ return(*this);
+}
+
+
+inline size_t Chunk::Len() const
+{
+ return(m_str.size());
+}
+
+
+inline const char *Chunk::Text() const
+{
+ return(m_str.c_str());
+}
+
+
+inline Chunk *Chunk::GetParent() const
+{
+ return(m_parent);
+}
+
+
+inline void Chunk::SetParent(Chunk *parent)
+{
+ if (this != parent)
+ {
+ m_parent = parent;
+ }
+}
+
+
+inline const AlignmentData &Chunk::GetAlignData() const
+{
+ return(m_alignmentData);
+}
+
+
+inline AlignmentData &Chunk::AlignData()
+{
+ return(m_alignmentData);
+}
+
+
+inline const IndentationData &Chunk::GetIndentData() const
+{
+ return(m_indentationData);
+}
+
+
+inline IndentationData &Chunk::IndentData()
+{
+ return(m_indentationData);
+}
+
+
+inline const UncText &Chunk::GetStr() const
+{
+ return(m_str);
+}
+
+
+inline UncText &Chunk::Str()
+{
+ return(m_str);
+}
+
+
+inline const TrackList *Chunk::GetTrackingData() const
+{
+ return(m_trackingList);
+}
+
+
+inline TrackList * &Chunk::TrackingData()
+{
+ return(m_trackingList);
+}
+
+
+inline E_Token Chunk::GetType() const
+{
+ return(m_type);
+}
+
+
+inline E_Token Chunk::GetParentType() const
+{
+ return(m_parentType);
+}
+
+
+inline E_Token Chunk::GetTypeOfParent() const
+{
+ if (GetParent()->IsNullChunk())
+ {
+ return(CT_PARENT_NOT_SET);
+ }
+ return(GetParent()->GetType());
+}
+
+
+inline PcfFlags Chunk::GetFlags() const
+{
+ return(m_flags);
+}
+
+
+inline void Chunk::SetFlags(PcfFlags flags)
+{
+ m_flags = flags;
+}
+
+
+inline bool Chunk::TestFlags(PcfFlags flags) const
+{
+ return(m_flags.test(flags));
+}
+
+
+inline void Chunk::ResetFlagBits(PcfFlags resetBits)
+{
+ SetResetFlags(resetBits, PCF_NONE);
+}
+
+
+inline void Chunk::SetFlagBits(PcfFlags setBits)
+{
+ SetResetFlags(PCF_NONE, setBits);
+}
+
+
+inline void Chunk::UpdateFlagBits(PcfFlags resetBits, PcfFlags setBits)
+{
+ SetResetFlags(resetBits, setBits);
+}
+
+
+inline size_t Chunk::GetOrigLine() const
+{
+ return(m_origLine);
+}
+
+
+inline void Chunk::SetOrigLine(size_t line)
+{
+ m_origLine = line;
+}
+
+
+inline size_t Chunk::GetOrigCol() const
+{
+ return(m_origCol);
+}
+
+
+inline void Chunk::SetOrigCol(size_t col)
+{
+ m_origCol = col;
+}
+
+
+inline size_t Chunk::GetOrigColEnd() const
+{
+ return(m_origColEnd);
+}
+
+
+inline void Chunk::SetOrigColEnd(size_t col)
+{
+ m_origColEnd = col;
+}
+
+
+inline size_t Chunk::GetOrigPrevSp() const
+{
+ return(m_origPrevSp);
+}
+
+
+inline void Chunk::SetOrigPrevSp(size_t col)
+{
+ m_origPrevSp = col;
+}
+
+
+inline size_t Chunk::GetColumn() const
+{
+ return(m_column);
+}
+
+
+inline void Chunk::SetColumn(size_t col)
+{
+ m_column = col;
+}
+
+
+inline size_t Chunk::GetColumnIndent() const
+{
+ return(m_columnIndent);
+}
+
+
+inline void Chunk::SetColumnIndent(size_t col)
+{
+ m_columnIndent = col;
+}
+
+
+inline size_t Chunk::GetNlCount() const
+{
+ return(m_nlCount);
+}
+
+
+inline void Chunk::SetNlCount(size_t cnt)
+{
+ m_nlCount = cnt;
+}
+
+
+inline size_t Chunk::GetNlColumn() const
+{
+ return(m_nlColumn);
+}
+
+
+inline void Chunk::SetNlColumn(size_t col)
+{
+ m_nlColumn = col;
+}
+
+
+inline size_t Chunk::GetLevel() const
+{
+ return(m_level);
+}
+
+
+inline void Chunk::SetLevel(size_t level)
+{
+ m_level = level;
+}
+
+
+inline size_t Chunk::GetBraceLevel() const
+{
+ return(m_braceLevel);
+}
+
+
+inline void Chunk::SetBraceLevel(size_t lvl)
+{
+ m_braceLevel = lvl;
+}
+
+
+inline size_t Chunk::GetPpLevel() const
+{
+ return(m_ppLevel);
+}
+
+
+inline void Chunk::SetPpLevel(size_t lvl)
+{
+ m_ppLevel = lvl;
+}
+
+
+inline bool Chunk::GetAfterTab() const
+{
+ return(m_afterTab);
+}
+
+
+inline void Chunk::SetAfterTab(bool afterTab)
+{
+ m_afterTab = afterTab;
+}
+
+
+inline Chunk *Chunk::GetNextNl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsNewline, scope, E_Direction::FORWARD, true));
+}
+
+
+inline Chunk *Chunk::GetPrevNl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsNewline, scope, E_Direction::BACKWARD, true));
+}
+
+
+inline Chunk *Chunk::GetNextNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsNewline, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsNewline, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextNc(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsComment, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNc(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsComment, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextNcNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentOrNewline, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNcNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentOrNewline, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextNcNnlNpp(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentNewlineOrPreproc, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNcNnlNpp(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentNewlineOrPreproc, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextNppOrNcNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentOrNewlineInPreproc, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNppOrNcNnl(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentOrNewlineInPreproc, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::PpaGetNextNcNnl() const
+{
+ return(SearchPpa(&Chunk::IsCommentOrNewline, false));
+}
+
+
+inline Chunk *Chunk::GetNextNcNnlNet(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentNewlineOrEmptyText, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNcNnlNet(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentNewlineOrEmptyText, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNcNnlNi(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsCommentNewlineOrIgnored, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextNisq(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsSquareBracket, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetNextType(const E_Token type, const int level, const E_Scope scope) const
+{
+ return(SearchTypeLevel(type, scope, E_Direction::FORWARD, level));
+}
+
+
+inline Chunk *Chunk::GetPrevType(const E_Token type, const int level, const E_Scope scope) const
+{
+ return(SearchTypeLevel(type, scope, E_Direction::BACKWARD, level));
+}
+
+
+inline Chunk *Chunk::GetNextString(const char *str, const size_t len, const int level, const E_Scope scope) const
+{
+ return(SearchStringLevel(str, len, level, scope, E_Direction::FORWARD));
+}
+
+
+inline Chunk *Chunk::GetPrevString(const char *str, const size_t len, const int level, const E_Scope scope) const
+{
+ return(SearchStringLevel(str, len, level, scope, E_Direction::BACKWARD));
+}
+
+
+inline Chunk *Chunk::GetNextNvb(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsVBrace, scope, E_Direction::FORWARD, false));
+}
+
+
+inline Chunk *Chunk::GetPrevNvb(const E_Scope scope) const
+{
+ return(Search(&Chunk::IsVBrace, scope, E_Direction::BACKWARD, false));
+}
+
+
+inline bool Chunk::IsTypeAndLevel(const E_Token type, const int level) const
+{
+ return( ( level < 0
+ || m_level == static_cast<size_t>(level))
+ && m_type == type);
+}
+
+
+inline bool Chunk::Is(E_Token token) const
+{
+ return( IsNotNullChunk()
+ && m_type == token);
+}
+
+
+inline bool Chunk::IsString(const char *str, bool caseSensitive) const
+{
+ return(IsStringAndLevel(str, strlen(str), caseSensitive, ANY_LEVEL));
+}
+
+
+inline bool Chunk::IsNot(E_Token token) const
+{
+ return(!Is(token));
+}
+
+
+inline bool Chunk::IsNewline() const
+{
+ return( Is(CT_NEWLINE)
+ || Is(CT_NL_CONT));
+}
+
+
+inline bool Chunk::IsComment() const
+{
+ return( Is(CT_COMMENT)
+ || Is(CT_COMMENT_MULTI)
+ || Is(CT_COMMENT_CPP));
+}
+
+
+inline bool Chunk::IsEmptyText() const
+{
+ return( IsNotNullChunk()
+ && Len() == 0);
+}
+
+
+inline bool Chunk::IsPreproc() const
+{
+ return( IsNotNullChunk()
+ && TestFlags(PCF_IN_PREPROC));
+}
+
+
+inline bool Chunk::IsCommentOrNewline() const
+{
+ return( IsComment()
+ || IsNewline());
+}
+
+
+inline bool Chunk::IsCommentNewlineOrPreproc() const
+{
+ return( IsComment()
+ || IsNewline()
+ || IsPreproc());
+}
+
+
+inline bool Chunk::IsCommentOrNewlineInPreproc() const
+{
+ return( IsPreproc()
+ && ( IsComment()
+ || IsNewline()));
+}
+
+
+inline bool Chunk::IsCommentNewlineOrEmptyText() const
+{
+ return( IsComment()
+ || IsNewline()
+ || IsEmptyText());
+}
+
+
+inline bool Chunk::IsCommentNewlineOrIgnored() const
+{
+ return( IsComment()
+ || IsNewline()
+ || Is(CT_IGNORED));
+}
+
+
+inline bool Chunk::IsSingleLineComment() const
+{
+ return( Is(CT_COMMENT)
+ || Is(CT_COMMENT_CPP));
+}
+
+
+inline bool Chunk::IsSquareBracket() const
+{
+ return( Is(CT_SQUARE_OPEN)
+ || Is(CT_TSQUARE)
+ || Is(CT_SQUARE_CLOSE));
+}
+
+
+inline bool Chunk::IsVBrace() const
+{
+ return( Is(CT_VBRACE_OPEN)
+ || Is(CT_VBRACE_CLOSE));
+}
+
+
+inline bool Chunk::IsStar() const
+{
+ return( Len() == 1
+ && m_str[0] == '*'
+ && IsNot(CT_OPERATOR_VAL));
+}
+
+
+inline bool Chunk::IsSemicolon() const
+{
+ return( Is(CT_SEMICOLON)
+ || Is(CT_VSEMICOLON));
+}
+
+
+inline bool Chunk::IsWord() const
+{
+ return( Len() >= 1
+ && CharTable::IsKw1(m_str[0]));
+}
+
+
+inline bool Chunk::IsNullable() const
+{
+ return( language_is_set(LANG_CS | LANG_VALA)
+ && Len() == 1
+ && m_str[0] == '?');
+}
+
+
+inline bool Chunk::IsMsRef() const
+{
+ return( language_is_set(LANG_CPP)
+ && Len() == 1
+ && m_str[0] == '^'
+ && IsNot(CT_OPERATOR_VAL));
+}
+
+
+inline bool Chunk::IsPointerOperator() const
+{
+ return( IsStar()
+ || IsAddress()
+ || IsMsRef()
+ || IsNullable());
+}
+
+
+inline bool Chunk::IsPointerOrReference() const
+{
+ return( IsPointerOperator()
+ || Is(CT_BYREF));
+}
+
+
+inline bool Chunk::IsBraceOpen() const
+{
+ return( Is(CT_BRACE_OPEN)
+ || Is(CT_VBRACE_OPEN));
+}
+
+
+inline bool Chunk::IsBraceClose() const
+{
+ return( Is(CT_BRACE_CLOSE)
+ || Is(CT_VBRACE_CLOSE));
+}
+
+
+inline bool Chunk::IsParenOpen() const
+{
+ return( Is(CT_PAREN_OPEN)
+ || Is(CT_SPAREN_OPEN)
+ || Is(CT_PPAREN_OPEN)
+ || Is(CT_TPAREN_OPEN)
+ || Is(CT_FPAREN_OPEN)
+ || Is(CT_LPAREN_OPEN));
+}
+
+
+inline bool Chunk::IsParenClose() const
+{
+ return( Is(CT_PAREN_CLOSE)
+ || Is(CT_SPAREN_CLOSE)
+ || Is(CT_PPAREN_CLOSE)
+ || Is(CT_TPAREN_CLOSE)
+ || Is(CT_FPAREN_CLOSE)
+ || Is(CT_LPAREN_CLOSE));
+}
+
+
+inline bool Chunk::IsSamePreproc(const Chunk *other) const
+{
+ return( IsNotNullChunk()
+ && other->IsNotNullChunk()
+ && (TestFlags(PCF_IN_PREPROC) == other->TestFlags(PCF_IN_PREPROC)));
+}
+
+
+inline bool Chunk::SafeToDeleteNl() const
+{
+ Chunk *tmp = GetPrev();
+
+ if (tmp->Is(CT_COMMENT_CPP))
+ {
+ return(false);
+ }
+ return(tmp->IsSamePreproc(GetNext()));
+}
+
+
+inline bool Chunk::IsEnum() const
+{
+ return( Is(CT_ENUM)
+ || Is(CT_ENUM_CLASS));
+}
+
+
+inline bool Chunk::IsClassOrStruct() const
+{
+ return( Is(CT_CLASS)
+ || Is(CT_STRUCT));
+}
+
+
+inline bool Chunk::IsClassStructOrUnion() const
+{
+ return( IsClassOrStruct()
+ || Is(CT_UNION));
+}
+
+
+inline bool Chunk::IsClassEnumStructOrUnion() const
+{
+ return( IsClassStructOrUnion()
+ || IsEnum());
+}
+
+
+inline Chunk *Chunk::CopyAndAddAfter(Chunk *ref) const
+{
+ return(CopyAndAdd(ref, E_Direction::FORWARD));
+}
+
+
+inline Chunk *Chunk::CopyAndAddBefore(Chunk *ref) const
+{
+ return(CopyAndAdd(ref, E_Direction::BACKWARD));
+}
+
+
+// shift all the tokens in this line to the right Issue #3236
+void shift_the_rest_of_the_line(Chunk *first);
+
+
+#endif /* CHUNK_LIST_H_INCLUDED */