1 files changed, 497 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/EnumStructUnionParser.h b/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/EnumStructUnionParser.h
new file mode 100644
index 00000000..422662da
--- /dev/null
+++ b/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/EnumStructUnionParser.h
@@ -0,0 +1,497 @@
+/**
+ * @file combine_fix_mark_enum_struct_union.h
+ *
+ * @author
+ * @license GPL v2+
+ * extract from combine_fix_mark.h
+ */
+
+#ifndef ENUM_STRUCT_UNION_PARSER_H_INCLUDED
+#define ENUM_STRUCT_UNION_PARSER_H_INCLUDED
+
+#include "pcf_flags.h"
+#include "token_enum.h"
+#include "uncrustify_types.h"
+#include <map>
+
+
+/**
+ * Class EnumStructUnionParser : This class facilitates the parsing and interpretation
+ *                               of ALL instances of the class, enum, union, and
+ *                               struct keywords, including user-defined types with
+ *                               a body {} and any trailing inline variable declarations
+ *                               that may follow the definition (as permitted by
+ *                               the coding language in question). The class also
+ *                               interprets variable declarations preceded by one
+ *                               of those keywords, as well as any C/C++ forward
+ *                               declarations
+ */
+class EnumStructUnionParser
+{
+public:
+   /**
+    * Constructor
+    */
+   EnumStructUnionParser();
+
+
+   /**
+    * Destructor
+    */
+   ~EnumStructUnionParser();
+
+
+private:
+   /**
+    * Analyzes all identifiers (marked as CT_WORD) between the starting and
+    * ending chunks and changes CT_WORD to one of CT_TYPE, CT_MACRO_FUNC_CALL,
+    * etc. and sets flags (PCF_VAR_1ST, PCF_VAR_1ST_DEF, PCF_VAR_INLINE, etc.)
+    * for variable identifiers accordingly. Flags C++ forward declarations as
+    * PCF_INCOMPLETE
+    */
+   void analyze_identifiers();
+
+
+   /**
+    * Returns true if a pair of braces were both detected AND determined to be
+    * part of a class/enum/struct/union body
+    */
+   bool body_detected() const;
+
+
+   /**
+    * Returns true if comma-separated values were detected during parsing
+    */
+   bool comma_separated_values_detected() const;
+
+
+   /**
+    * Returns true if an enumerated integral type was detected during parsing
+    */
+   bool enum_base_detected() const;
+
+
+   /**
+    * Returns the end chunk of a class/enum/struct/union body, if detected
+    * during parsing
+    */
+   Chunk *get_body_end() const;
+
+
+   /**
+    * Returns the starting chunk of a class/enum/struct/union body, if detected
+    * during parsing
+    */
+   Chunk *get_body_start() const;
+
+
+   /**
+    * Returns the starting chunk associated with an enumerated type's base
+    * specifier statement, if detected during parsing
+    */
+   Chunk *get_enum_base_start() const;
+
+
+   /**
+    * Returns the first comma encountered at the level of the starting chunk,
+    * if detected during parsing
+    */
+   Chunk *get_first_top_level_comma() const;
+
+
+   /**
+    * Returns the ending chunk associated with an class/struct inheritance
+    * list, if detected during parsing
+    */
+   Chunk *get_inheritance_end() const;
+
+
+   /**
+    * Returns the starting chunk associated with an class/struct inheritance
+    * list, if detected during parsing
+    */
+   Chunk *get_inheritance_start() const;
+
+
+   /**
+    * Returns a numerically-indexed map of all question operators encountered
+    * during parsing
+    */
+   std::map<std::size_t, Chunk *> get_question_operators() const;
+
+
+   /**
+    * Returns the end chunk associated with a template parameter list, if
+    * detected during parsing
+    */
+   Chunk *get_template_end() const;
+
+
+   /**
+    * Return the starting chunk associated with a template parameter list, if
+    * detected during parsing
+    */
+   Chunk *get_template_start() const;
+
+
+   /**
+    * Returns a numerically-indexed map of all top-level commas encountered
+    * during parsing
+    */
+   std::map<std::size_t, Chunk *> get_top_level_commas() const;
+
+
+   /**
+    * Return the starting chunk associated with a where clause, if
+    * detected during parsing
+    */
+   Chunk *get_where_end() const;
+
+
+   /**
+    * Return the starting chunk associated with a where clause, if
+    * detected during parsing
+    */
+   Chunk *get_where_start() const;
+
+
+   /**
+    * Returns true if an inheritance list associated with a class or struct was
+    * discovered during parsing
+    */
+   bool inheritance_detected() const;
+
+
+public:
+   /**
+    * Performs object initialization prior to parsing
+    */
+   void initialize(Chunk *pc);
+
+
+private:
+   /**
+    * Returns true if the chunk under test represents a potential end chunk past
+    * which further parsing is not likely warranted
+    */
+   bool is_potential_end_chunk(Chunk *pc) const;
+
+
+   /**
+    * Returns true if the chunk under test is deemed to be located within a
+    * conditional/ternary statement
+    */
+   bool is_within_conditional(Chunk *pc) const;
+
+
+   /**
+    * Returns true if the chunk under test is deemed to be located within an
+    * inheritance list
+    */
+   bool is_within_inheritance_list(Chunk *pc) const;
+
+
+   /**
+    * Returns true if the chunk under test is deemed to be located within a
+    * where clause
+    */
+   bool is_within_where_clause(Chunk *pc) const;
+
+
+   /**
+    * Marks all base classes that appear as part of an inheritance list
+    */
+   void mark_base_classes(Chunk *pc);
+
+
+   /**
+    * Marks pairs of braces associated with the body of a class/enum/struct/union,
+    * and additionally calls a separate routine to mark any base classes for that
+    * may precede the opening brace
+    */
+   void mark_braces(Chunk *start);
+
+
+   /**
+    * Marks the beginning chunk of an inheritance list
+    */
+   void mark_class_colon(Chunk *colon);
+
+
+   /**
+    * Mark a colon as a conditional
+    */
+   void mark_conditional_colon(Chunk *colon);
+
+
+   /**
+    * Mark any struct/class constructor declarations/definitions
+    */
+   void mark_constructors();
+
+
+   /**
+    * Marks the beginning chunk of an enumerated integral type specification
+    */
+   void mark_enum_integral_type(Chunk *colon);
+
+
+   /**
+    * Scan chunks outside the definition body and mark lvalues accordingly
+    */
+   void mark_extracorporeal_lvalues();
+
+
+   /**
+    * Mark nested name specifiers preceding qualified identifiers
+    */
+   void mark_nested_name_specifiers(Chunk *pc);
+
+
+   /**
+    * Marks pointer operators preceding a variable identifier
+    */
+   void mark_pointer_types(Chunk *pc);
+
+
+   /**
+    * Marks the beginning and ending chunks associated with a template
+    * (templates may appear after the identifier type name as part of a class
+    * specialization)
+    */
+   void mark_template(Chunk *start) const;
+
+
+   /**
+    * Marks the arguments within a template argument list bounded by the
+    * starting and ending chunks
+    */
+   void mark_template_args(Chunk *start, Chunk *end) const;
+
+
+   /**
+    * Marks the type identifier associated with the class/enum/struct/union,
+    * if not anonymously defined
+    */
+   void mark_type(Chunk *pc);
+
+
+   /**
+    * Marks all variable identifiers associated with the class/enum/struct/union
+    */
+   void mark_variable(Chunk *variable, pcf_flags_t flags);
+
+
+   /**
+    * Marks all chunks belonging to a c# where clause
+    */
+   void mark_where_clause(Chunk *where);
+
+
+   /**
+    * Marks the beginning of a where clause
+    */
+   void mark_where_colon(Chunk *colon);
+
+
+public:
+   /**
+    * Parses the class/enum/struct/union and all associated chunks
+    */
+   void parse(Chunk *pc);
+
+
+private:
+   /**
+    * Parses closing and opening angle brackets
+    */
+   Chunk *parse_angles(Chunk *angle_open);
+
+
+   /**
+    * Parses closing and opening braces
+    */
+   Chunk *parse_braces(Chunk *brace_open);
+
+
+   /**
+    * Parses a single colon, which may precede an inheritance list or
+    * enumerated integral type specification
+    */
+   void parse_colon(Chunk *colon);
+
+
+   /**
+    * Parses a double colon, which may indicate a scope resolution chain
+    */
+   Chunk *parse_double_colon(Chunk *double_colon);
+
+
+   /**
+    * Returns the parsing error status
+    */
+   bool parse_error_detected() const;
+
+
+   /**
+    * Sets the parsing error status
+    */
+   void parse_error_detected(bool status);
+
+
+   /**
+    * Records all question operators encountered during parsing
+    */
+   void record_question_operator(Chunk *question);
+
+
+   /**
+    * Records a comma chunk given one the following conditions are satisfied:
+    * 1) it is encountered at the level of the starting chunk
+    * 2) it is not part of a right-hand side assignment
+    * 3) it is not part of an inheritance list
+    * 4) it is not part of a conditional/ternary expression
+    */
+   void record_top_level_comma(Chunk *comma);
+
+
+   /**
+    * Adjusts the end chunk returned by the try_find_end_chunk() function
+    * for any potential trailing inline variable declarations that may follow
+    * the body of a class/enum/struct/union definition
+    */
+   Chunk *refine_end_chunk(Chunk *pc);
+
+
+   /**
+    * Sets the chunk associated with the end of a class/enum/struct/union
+    * body
+    */
+   void set_body_end(Chunk *body_end);
+
+
+   /**
+    * Sets the chunk associated with the start of a class/enum/struct/union
+    * body
+    */
+   void set_body_start(Chunk *body_start);
+
+
+   /**
+    * Sets the chunk associated with the start of an enumerated integral
+    * base type specification
+    */
+   void set_enum_base_start(Chunk *enum_base_start);
+
+
+   /**
+    * Sets the chunk associated with the start of an inheritance list
+    */
+   void set_inheritance_start(Chunk *inheritance_start);
+
+
+   /**
+    * Sets the chunk associated with the end of a template
+    */
+   void set_template_end(Chunk *template_end);
+
+
+   /**
+    * Sets the chunk associated with the start of a template
+    */
+   void set_template_start(Chunk *template_start);
+
+
+   /**
+    * Return the ending chunk associated with a where clause, if
+    * detected during parsing
+    */
+   void set_where_end(Chunk *where_end);
+
+
+   /**
+    * Return the starting chunk associated with a where clause, if
+    * detected during parsing
+    */
+   void set_where_start(Chunk *where_start);
+
+
+   /**
+    * Returns true if a template was detected during parsing
+    */
+   bool template_detected() const;
+
+
+   /**
+    * Attempts to find the last chunk associated with the class/enum/struct/union
+    */
+   Chunk *try_find_end_chunk(Chunk *pc);
+
+
+   /**
+    * Attempts to identify any function-like macro calls which may precede the
+    * actual type identifier
+    */
+   void try_post_identify_macro_calls();
+
+
+   /**
+    * Attempts to find the identifier type name (if not anonymously-defined) post
+    * variable identifier interpretation
+    */
+   void try_post_identify_type();
+
+
+   /**
+    * Attempts to find the identifier type name prior to variable identifier
+    * interpretation
+    */
+   bool try_pre_identify_type();
+
+
+   /**
+    * Returns true if a corresponding type was identified for the class/enum/struct/union
+    */
+   bool type_identified() const;
+
+
+   /**
+    * Returns true if a where clause was detected during parsing
+    */
+   bool where_clause_detected() const;
+
+
+   /**
+    * Map of token-type, chunk pairs
+    */
+   std::map<E_Token, std::map<std::size_t, Chunk *> > m_chunk_map;
+
+
+   /**
+    * Indicates the last chunk associated with the class/enum/struct/union keyword
+    */
+   Chunk *m_end;
+
+
+   /**
+    * Indicates whether or not a parse error has occurred
+    */
+   bool m_parse_error;
+
+
+   /**
+    * Stores a pointer to the class/enum/struct/union keyword chunk with which the
+    * parse() routine was invoked
+    */
+   Chunk *m_start;
+
+
+   /**
+    * Stores a pointer to the type identifier associated with the class/enum/struct/union,
+    * if not anonymously defined
+    */
+   Chunk *m_type;
+};
+
+
+#endif