uncrustify-trinity: updated based on upstream version 0.74.0

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 0 insertions, 398 deletions

diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/token_enum.h b/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/token_enum.h
deleted file mode 100644
index 81caf0d8..00000000
--- a/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/token_enum.h
+++ /dev/null
@@ -1,398 +0,0 @@
-/**
- * @file token_enum.h
- * List of the different tokens used in the program.
- *
- * @author  Ben Gardner
- * @author  Guy Maurel since version 0.62 for uncrustify4Qt
- *          October 2015
- * @license GPL v2+
- */
-
-#ifndef TOKEN_ENUM_H_INCLUDED
-#define TOKEN_ENUM_H_INCLUDED
-
-/**
- * abbreviations used:
- * CT = chunk type
- */
-
-
-/**
- * This is an enum of all the different chunks/tokens/elements that the
- * program can work with. The parser and scanner assigns one of these to
- * each chunk/token.
- */
-enum c_token_t
-{
-   CT_NONE,
-   CT_PARENT_NOT_SET,
-   CT_EOF,
-   CT_UNKNOWN,
-
-   CT_JUNK,          // junk collected when parsing is disabled
-
-   CT_WHITESPACE,    // whitespace without any newlines
-   CT_SPACE,         // a fixed number of spaces to support weird spacing rules
-   CT_NEWLINE,       // CRA, one or more newlines
-   CT_NL_CONT,       // CRA, backslash-newline
-   CT_FORM_FEED,     // character 12
-   CT_COMMENT_CPP,   // C++ comment (always followed by CT_NEWLINE)
-   CT_COMMENT,       // C-comment, single line
-   CT_COMMENT_MULTI, // Multi-lined comment
-   CT_COMMENT_EMBED, // comment parent_type: non-newline before and after
-   CT_COMMENT_START, // comment parent_type: newline before
-   CT_COMMENT_END,   // comment parent_type: newline after
-   CT_COMMENT_WHOLE, // comment parent_type: newline before and after
-   CT_COMMENT_ENDIF, // C-comment, single line, after ENDIF
-
-   CT_IGNORED,       // a chunk of ignored text
-
-   CT_WORD,          // variable, type, function name, etc
-   CT_NUMBER,
-   CT_NUMBER_FP,
-   CT_STRING,        // quoted string "hi" or 'a' or <in> for include
-   CT_STRING_MULTI,  // quoted string with embedded newline
-   CT_IF,            // built-in keywords
-   CT_ELSE,
-   CT_ELSEIF,
-   CT_CONSTEXPR,     // only when preceded by 'if' (otherwise CT_QUALIFIER)
-   CT_FOR,
-   CT_WHILE,
-   CT_WHILE_OF_DO,
-   CT_SWITCH,
-   CT_CASE,
-   CT_DO,
-   CT_SYNCHRONIZED,
-   CT_VOLATILE,
-   CT_TYPEDEF,
-   CT_STRUCT,
-   CT_ENUM,
-   CT_ENUM_CLASS,
-   CT_SIZEOF,
-   CT_DECLTYPE,
-   CT_RETURN,
-   CT_BREAK,
-   CT_UNION,
-   CT_GOTO,
-   CT_CONTINUE,
-   CT_C_CAST,              // C-style cast:   "(int)5.6"
-   CT_CPP_CAST,            // C++-style cast: "int(5.6)"
-   CT_D_CAST,              // D-style cast:   "cast(type)" and "const(type)"
-   CT_TYPE_CAST,           // static_cast<type>(exp)
-   CT_TYPENAME,            // typename type
-   CT_TEMPLATE,            // template<...>
-   CT_WHERE_SPEC,          // 'where' : used in C# generic constraint
-
-   CT_ASSIGN,              // =, +=, /=, etc
-   CT_ASSIGN_NL,           // Assign followed by a newline - fake item for indenting
-   CT_SASSIGN,             // 'and_eq'
-
-   CT_ASSIGN_DEFAULT_ARG,  // Default argument such as
-                           // Foo( int Foo = 5 );
-   CT_ASSIGN_FUNC_PROTO,   // function prototype modifier such as
-                           // void* operator new(std::size_t) = delete;
-                           // Foo( const Foo & ) = default;
-                           // Foo( const Foo & ) = 0;
-
-   CT_COMPARE,             // ==, !=, <=, >=
-   CT_SCOMPARE,            // compare op that is a string 'is', 'neq'
-   CT_BOOL,                // || or &&
-   CT_SBOOL,               // or, and
-   CT_ARITH,               // +, -, /, etc
-   CT_SARITH,              // 'not', 'xor'
-   CT_SHIFT,               // <<, >>
-   CT_CARET,               // ^
-   CT_DEREF,               // * dereference
-   CT_INCDEC_BEFORE,       // ++a or --a
-   CT_INCDEC_AFTER,        // a++ or a--
-   CT_MEMBER,              // . or ->
-   CT_DC_MEMBER,           // ::
-   CT_C99_MEMBER,          // . in structure stuff
-   CT_INV,                 // ~
-   CT_DESTRUCTOR,          // ~
-   CT_NOT,                 // !
-   CT_D_TEMPLATE,          // ! as in Foo!(A)
-   CT_ADDR,                // &
-   CT_NEG,                 // - as in -1
-   CT_POS,                 // + as in +1
-   CT_STAR,                // * : raw char to be changed
-   CT_PLUS,                // + : raw char to be changed
-   CT_MINUS,               // - : raw char to be changed
-   CT_AMP,                 // & : raw char to be changed
-   CT_BYREF,               // & in function def/proto params
-
-   // CT_BITWISE_AND,         // &   // is a CT_ARITH
-   // CT_BITWISE_OR,          // |   // is a CT_ARITH
-   // CT_BITWISE_EXCLUSIVE_OR,// ^   // is a CT_ARITH
-   // CT_BITWISE_NOT,         // ~   // is a CT_ARITH
-
-   CT_POUND,               // #
-   CT_PREPROC,             // # at the start of a line
-   CT_PREPROC_INDENT,      // # at the start of a line that gets indented: #region
-   CT_PREPROC_BODY,        // body of every preproc EXCEPT #define
-   CT_PP,                  // ##
-   CT_ELLIPSIS,            // ...
-   CT_RANGE,               // ..
-   CT_NULLCOND,            // ?.
-
-   CT_SEMICOLON,
-   CT_VSEMICOLON,          // virtual semicolon for PAWN
-   CT_COLON,
-   CT_ASM_COLON,
-   CT_CASE_COLON,
-   CT_CASE_ELLIPSIS,       // '...' in `case 1 ... 5`:
-   CT_CLASS_COLON,         // colon after a class def
-   CT_CONSTR_COLON,        // colon after a constructor
-   CT_D_ARRAY_COLON,       // D named array initializer colon
-   CT_COND_COLON,          // conditional colon in  'b ? t : f'
-   CT_WHERE_COLON,         // C# where-constraint colon (after the type)
-   CT_QUESTION,
-   CT_COMMA,
-
-   CT_ASM,
-   CT_ATTRIBUTE,
-   CT_AUTORELEASEPOOL,     // OC: Autorelease Pool Blocks, used by iOS
-   CT_OC_AVAILABLE,
-   CT_OC_AVAILABLE_VALUE,
-   CT_CATCH,
-   CT_WHEN,
-   CT_WHERE,            // C# where clause
-   CT_CLASS,
-   CT_DELETE,
-   CT_EXPORT,
-   CT_FRIEND,
-   CT_NAMESPACE,
-   CT_PACKAGE,
-   CT_NEW,              // may turn into CT_PBRACED if followed by a '('
-   CT_OPERATOR,
-   CT_OPERATOR_VAL,
-   CT_ASSIGN_OPERATOR,  // the value after 'operator' such as:
-                        // Foo &operator= ( const Foo & );
-   CT_ACCESS,
-   CT_ACCESS_COLON,
-   CT_THROW,
-   CT_NOEXCEPT,
-   CT_TRY,
-   CT_BRACED_INIT_LIST,
-   CT_USING,
-   CT_USING_STMT,       // using (xxx) ...
-   CT_USING_ALIAS,      // using identifier attr(optional) = type-id
-   CT_D_WITH,           // D: parenthetis+braced
-   CT_D_MODULE,
-   CT_SUPER,
-   CT_DELEGATE,
-   CT_BODY,
-   CT_DEBUG,
-   CT_DEBUGGER,
-   CT_INVARIANT,
-   CT_UNITTEST,
-   CT_UNSAFE,
-   CT_FINALLY,
-   CT_FIXED,            // C# fixed
-   CT_IMPORT,
-   CT_D_SCOPE,
-   CT_D_SCOPE_IF,
-   CT_LAZY,
-   CT_D_MACRO,
-   CT_D_VERSION,        // turns into CT_D_VERSION_IF if not followed by '='
-   CT_D_VERSION_IF,     // version(x) { }
-
-   // note for parenthetis/brace/square pairs: close MUST be open + 1
-   CT_PAREN_OPEN,
-   CT_PAREN_CLOSE,
-
-   CT_ANGLE_OPEN,       // template<T*>
-   CT_ANGLE_CLOSE,
-
-   CT_SPAREN_OPEN,      // 'special' parenthetis after if/for/switch/while/synchronized/catch
-   CT_SPAREN_CLOSE,
-
-   CT_PPAREN_OPEN,      // 'protect' parenthetis to protect a type such as (*int)
-   CT_PPAREN_CLOSE,     // used at align_func_param
-
-   CT_FPAREN_OPEN,      // 'function' parenthetis after fcn/macro fcn
-   CT_FPAREN_CLOSE,
-
-   CT_LPAREN_OPEN,      // lambda-declarator parenthetis
-   CT_LPAREN_CLOSE,
-
-   CT_TPAREN_OPEN,      // 'type' parenthetis used in function types
-   CT_TPAREN_CLOSE,
-
-   CT_BRACE_OPEN,       // {...}
-   CT_BRACE_CLOSE,
-
-   CT_VBRACE_OPEN,      // virtual brace, i.e. brace inserted by uncrustify
-   CT_VBRACE_CLOSE,
-
-   CT_SQUARE_OPEN,      // [...]
-   CT_SQUARE_CLOSE,
-
-   CT_TSQUARE,          // special case of []
-
-   CT_MACRO_OPEN,       // stuff specified via custom-pair
-   CT_MACRO_CLOSE,
-   CT_MACRO_ELSE,
-
-   // aggregate types
-   CT_LABEL,              // a non-case label
-   CT_LABEL_COLON,        // the colon for a label
-   CT_FUNCTION,           // function - unspecified, call mark_function()
-   CT_FUNC_CALL,          // function call
-   CT_FUNC_CALL_USER,     // function call (special user)
-   CT_FUNC_DEF,           // function definition/implementation
-   CT_FUNC_TYPE,          // function type - foo in "typedef void (*foo)(void)"
-   CT_FUNC_VAR,           // foo and parent type of first parens in "void (*foo)(void)"
-   CT_FUNC_PROTO,         // function prototype
-   CT_FUNC_START,         // global DC member for functions(void ::func())
-   CT_FUNC_CLASS_DEF,     // ctor or dtor for a class
-   CT_FUNC_CLASS_PROTO,   // ctor or dtor for a class
-   CT_FUNC_CTOR_VAR,      // variable or class initialization
-   CT_FUNC_WRAP,          // macro that wraps the function name
-   CT_PROTO_WRAP,         // macro: "RETVAL PROTO_WRAP( fcn_name, (PARAMS))". Parens for PARAMS are optional.
-   CT_MACRO_FUNC,         // function-like macro
-   CT_MACRO_FUNC_CALL,    // function-like macro call
-   CT_MACRO,              // a macro def
-   CT_QUALIFIER,          // static, const, etc
-   CT_EXTERN,             // extern
-   CT_DECLSPEC,           // __declspec
-   CT_ALIGN,              // paren'd qualifier: align(4) struct a { }
-   CT_TYPE,
-   CT_PTR_TYPE,           // a '*' as part of a type
-   CT_TYPE_WRAP,          // macro that wraps a type name
-   CT_CPP_LAMBDA,         // parent for '[=](...){...}'
-   CT_CPP_LAMBDA_RET,     // '->' in '[=](...) -> type {...}'
-   CT_EXECUTION_CONTEXT,  // Keyword for use in lambda statement: [] CT_EXECUTION_CONTEXT ()->{}
-   CT_TRAILING_RET,       // '->' in 'auto fname(...) -> type;'
-                          // '->' in 'auto fname(...) const -> type;'
-   CT_BIT_COLON,          // a ':' in a variable declaration
-
-   CT_OC_DYNAMIC,
-   CT_OC_END,           // ObjC: @end
-   CT_OC_IMPL,          // ObjC: @implementation
-   CT_OC_INTF,          // ObjC: @interface
-   CT_OC_PROTOCOL,      // ObjC: @protocol or @protocol()
-   CT_OC_PROTO_LIST,    // ObjC: protocol list < > (parent token only)
-   CT_OC_GENERIC_SPEC,  // ObjC: specification of generic  < >
-   CT_OC_PROPERTY,      // ObjC: @property
-   CT_OC_CLASS,         // ObjC: the name after @interface or @implementation
-   CT_OC_CLASS_EXT,     // ObjC: a pair of empty parens after the class name in a @interface or @implementation
-   CT_OC_CATEGORY,      // ObjC: the category name in parens after the class name in a @interface or @implementation
-   CT_OC_SCOPE,         // ObjC: the '-' or '+' in '-(void) func: (int) i;'
-   CT_OC_MSG,           // ObjC: parent type to '[', ']' and ';' in '[class func : param name: param];'
-   CT_OC_MSG_CLASS,     // ObjC: 'class' in  '[class func : param name: param];' (see also PCF_IN_OC_MSG)
-   CT_OC_MSG_FUNC,      // ObjC: 'func' in  '[class func : param name: param];' (see also PCF_IN_OC_MSG)
-   CT_OC_MSG_NAME,      // ObjC: 'name' in  '[class func : param name: param];' (see also PCF_IN_OC_MSG)
-   CT_OC_MSG_SPEC,      // ObjC: msg spec '-(void) func: (int) i;'
-   CT_OC_MSG_DECL,      // ObjC: msg decl '-(void) func: (int) i { }'
-   CT_OC_RTYPE,         // ObjC: marks parens of the return type after scope
-   CT_OC_ATYPE,         // ObjC: marks parens of the arg type after scope
-   CT_OC_COLON,         // ObjC: the colon in a msg spec
-   CT_OC_DICT_COLON,    // ObjC: colon in dictionary constant: "KEY: VALUE"
-   CT_OC_SEL,           // ObjC: @selector
-   CT_OC_SEL_NAME,      // ObjC: selector name
-   CT_OC_BLOCK,         // ObjC: block parent type.
-   CT_OC_BLOCK_ARG,     // ObjC: block arguments parent type.
-   CT_OC_BLOCK_TYPE,    // ObjC: block declaration parent type, e.g. mainly the '(^block_t)' in 'void (^block_t)(int arg);'
-   CT_OC_BLOCK_EXPR,    // ObjC: block expression with arg: '^(int arg) { arg++; };' and without (called a block literal): '^{ ... };'
-   CT_OC_BLOCK_CARET,   // ObjC: block pointer caret: '^'
-   CT_OC_AT,            // ObjC: boxed constants using '@'
-   CT_OC_PROPERTY_ATTR, // ObjC: property attribute (strong, weak, readonly, etc...)
-
-   // start PP types
-   CT_PP_DEFINE,        // #define
-   CT_PP_DEFINED,       // #if defined
-   CT_PP_INCLUDE,       // #include
-   CT_PP_IF,            // #if, #ifdef, or #ifndef
-   CT_PP_ELSE,          // #else or #elif
-   CT_PP_ENDIF,         // #endif
-   CT_PP_ASSERT,
-   CT_PP_EMIT,
-   CT_PP_ENDINPUT,
-   CT_PP_ERROR,
-   CT_PP_FILE,
-   CT_PP_LINE,
-   CT_PP_SECTION,
-   CT_PP_ASM,           // start of assembly code section
-   CT_PP_UNDEF,
-   CT_PP_PROPERTY,
-
-   CT_PP_BODYCHUNK,     // everything after this gets put in CT_PREPROC_BODY
-
-   CT_PP_PRAGMA,        // pragma's should not be altered
-   CT_PP_REGION,        // C# #region
-   CT_PP_ENDREGION,     // C# #endregion
-   CT_PP_REGION_INDENT, // Dummy token for indenting a C# #region
-   CT_PP_IF_INDENT,     // Dummy token for indenting a #if stuff
-   CT_PP_IGNORE,        // Dummy token for ignoring a certain preprocessor directive (do not do any processing)
-   CT_PP_OTHER,         // #line, #error, #pragma, etc
-   // end PP types
-
-   // PAWN stuff
-   CT_CHAR,
-   CT_DEFINED,
-   CT_FORWARD,
-   CT_NATIVE,
-   CT_STATE,
-   CT_STOCK,
-   CT_TAGOF,
-   CT_DOT,
-   CT_TAG,
-   CT_TAG_COLON,
-
-   // C-sharp
-   CT_LOCK,             // lock/unlock
-   CT_AS,
-   CT_IN,               // "foreach (T c in x)" or "foo(in char c)" or "in { ..."
-   CT_BRACED,           // simple braced items: try {}
-   CT_THIS,             // may turn into CT_PBRACED if followed by a '('
-   CT_BASE,             // C# thingy
-   CT_DEFAULT,          // may be changed into CT_CASE
-   CT_GETSET,           // must be followed by CT_BRACE_OPEN or reverts to CT_WORD
-   CT_GETSET_EMPTY,     // get/set/add/remove followed by a semicolon
-   CT_CONCAT,           // The '~' between strings
-   CT_CS_SQ_STMT,       // '[assembly: xxx]' or '[Attribute()]' or '[Help()]', etc
-   CT_CS_SQ_COLON,      // the colon in one of those [] thingys
-   CT_CS_PROPERTY,      // word or ']' followed by '{'
-
-   // Embedded SQL - always terminated with a semicolon
-   CT_SQL_EXEC,         // the 'EXEC' in 'EXEC SQL ...'
-   CT_SQL_BEGIN,        // the 'BEGINN' in 'EXEC SQL BEGIN ...'
-   CT_SQL_END,          // the 'END' in 'EXEC SQL END ...'
-   CT_SQL_WORD,         // CT_WORDs in the 'EXEC SQL' statement
-   CT_SQL_ASSIGN,       // :=
-
-   // Vala stuff
-   CT_CONSTRUCT,        // braced "construct { }" or qualifier "(construct int x)"
-   CT_LAMBDA,
-
-   // Java
-   CT_ASSERT,       // assert EXP1 [ : EXP2 ] ;
-   CT_ANNOTATION,   // @interface or @something(...)
-   CT_FOR_COLON,    // colon in "for ( TYPE var: EXPR ) { ... }"
-   CT_DOUBLE_BRACE, // parent for double brace
-
-   /* Clang */
-   CT_CNG_HASINC,   // Clang: __has_include()
-   CT_CNG_HASINCN,  // Clang: __has_include_next()
-
-   // extensions for Qt macros
-   CT_Q_EMIT,       // guy 2015-10-16
-   CT_Q_FOREACH,    // guy 2015-09-23
-   CT_Q_FOREVER,    // guy 2015-10-18
-   CT_Q_GADGET,     // guy 2016-05-04
-   CT_Q_OBJECT,     // guy 2015-10-16
-
-   // Machine Modes
-   CT_MODE,         // guy 2016-03-11
-   CT_DI,           // guy 2016-03-11
-   CT_HI,           // guy 2016-03-11
-   CT_QI,           // guy 2016-03-11
-   CT_SI,           // guy 2016-03-11
-   CT_NOTHROW,      // guy 2016-03-11
-   CT_WORD_,        // guy 2016-03-11
-
-   CT_TOKEN_COUNT_  // NOTE: Keep this the last entry because it's used as a counter.
-};
-
-#endif /* TOKEN_ENUM_H_INCLUDED */